@vostride/agent-qa-core 0.0.1 → 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,3508 @@
+import { z } from 'zod';
+import * as ai from 'ai';
+import { LanguageModel, wrapLanguageModel, LanguageModelMiddleware } from 'ai';
+import * as better_sqlite3 from 'better-sqlite3';
+export { generateObservationId } from '@vostride/agent-qa-ids';
+
+type StepStatus = 'passed' | 'failed' | 'healed' | 'skipped' | 'cancelled';
+type TestStatus = 'passed' | 'failed' | 'skipped' | 'cancelled';
+interface StepAnnotation {
+    clickPoint?: {
+        x: number;
+        y: number;
+    };
+    boundingBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    failureHighlight?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    type: 'click' | 'fill' | 'tap' | 'hover' | 'scroll' | 'swipe' | 'pinch' | 'navigate' | 'other';
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    startPoint?: {
+        x: number;
+        y: number;
+    };
+    endPoint?: {
+        x: number;
+        y: number;
+    };
+    direction?: 'up' | 'down' | 'left' | 'right';
+    pinchScale?: 'in' | 'out';
+}
+interface HealingAttempt {
+    action: Action;
+    observationBefore: string;
+    observationAfter?: string;
+    success: boolean;
+    attemptNumber?: number;
+    strategy?: string;
+    reasoning?: string;
+    confidence?: number;
+}
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+interface SubActionTrace {
+    index: number;
+    observation: string;
+    reasoning: string;
+    plannedAction: Action;
+    result: 'success' | 'failure';
+    error?: string;
+    screenStateBefore: string;
+    screenStateAfter?: string;
+    screenContextBefore?: string;
+    screenContextAfter?: string;
+    confidence?: number;
+    verifierReasoning?: string;
+    cached: boolean;
+    tokenUsage?: TokenUsage;
+    phaseDurations?: {
+        observe?: number;
+        plan?: number;
+        execute?: number;
+        verify?: number;
+    };
+    screenshotBefore?: Buffer;
+    screenshotAfter?: Buffer;
+    annotation?: StepAnnotation;
+    data?: unknown;
+}
+interface StepTrace {
+    observation: string;
+    reasoning: string;
+    plannedAction: Action;
+    result: 'success' | 'failure';
+    error?: string;
+    screenStateBefore: string;
+    screenStateAfter?: string;
+    screenContextBefore?: string;
+    screenContextAfter?: string;
+    confidence?: number;
+    verifierReasoning?: string;
+    tokenUsage?: TokenUsage;
+    phaseDurations?: {
+        observe?: number;
+        plan?: number;
+        execute?: number;
+        verify?: number;
+        heal?: number;
+    };
+    subActions?: SubActionTrace[];
+}
+interface StepPhaseEvent {
+    phase: 'observe' | 'plan' | 'execute' | 'verify' | 'heal';
+    subActionIndex?: number;
+    phaseOrdinal?: number;
+    text?: string;
+    confidence?: number;
+    action?: unknown;
+    success?: boolean;
+    duration?: number;
+}
+interface AccessibilityViolation {
+    ruleId: string;
+    impact: 'minor' | 'moderate' | 'serious' | 'critical';
+    description: string;
+    help: string;
+    helpUrl: string;
+    nodes: Array<{
+        html: string;
+        target: string[];
+    }>;
+}
+interface ConsoleLogEntry {
+    level: string;
+    text: string;
+    location?: {
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+    };
+    timestamp: number;
+}
+interface NetworkLogEntry {
+    url: string;
+    method: string;
+    status: number;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    body?: string;
+    requestBody?: string;
+    startTime: number;
+    endTime: number;
+    timing?: Record<string, number>;
+}
+interface StepResult {
+    id?: string;
+    name: string;
+    status: StepStatus;
+    duration: number;
+    action?: Action;
+    observation?: string;
+    error?: string;
+    screenshot?: Buffer;
+    screenshotBefore?: Buffer;
+    healingAttempts?: HealingAttempt[];
+    trace?: StepTrace;
+    retryCount?: number;
+    capturedVariables?: Record<string, string>;
+    annotation?: StepAnnotation;
+    healingScreenshots?: Buffer[];
+    accessibilityViolations?: AccessibilityViolation[];
+    consoleLogs?: ConsoleLogEntry[];
+    networkLogs?: NetworkLogEntry[];
+    variableSnapshot?: Record<string, {
+        value: string;
+        source: string;
+    }>;
+    originalStepName?: string;
+}
+interface TestResult {
+    runId?: string;
+    name: string;
+    filePath: string;
+    status: TestStatus;
+    steps: StepResult[];
+    duration: number;
+    metadata?: Record<string, unknown>;
+    retryCount?: number;
+    videoPath?: string;
+    failureSummary?: string;
+}
+
+interface ObserveOptions {
+    extractDom?: boolean;
+}
+interface PlatformAdapter {
+    readonly platform: 'web' | 'android' | 'ios';
+    setup(config: PlatformConfig): Promise<void>;
+    cleanup(): Promise<void>;
+    observe(options?: ObserveOptions): Promise<ScreenState>;
+    execute(action: Action): Promise<ActionResult>;
+    screenshot?(): Promise<Buffer | undefined>;
+    drainConsoleLogs?(level?: string): ConsoleLogEntry[];
+    drainNetworkLogs?(urlPattern?: string): NetworkLogEntry[];
+}
+interface ScreenStateMetadata {
+    coordSpace: 'viewport';
+    viewportWidth: number;
+    viewportHeight: number;
+    refMap?: Record<string, unknown>;
+    imageWidth?: number;
+    imageHeight?: number;
+    domContext?: string;
+}
+interface ScreenState {
+    tree: string;
+    elements: ElementInfo[];
+    url?: string;
+    timestamp: number;
+    metadata: ScreenStateMetadata;
+}
+interface ElementInfo {
+    ref: string;
+    role: string;
+    name: string;
+    value?: string;
+    attributes: Record<string, string>;
+}
+type Action = {
+    type: 'click';
+    ref: string;
+    clickDelay?: number;
+} | {
+    type: 'fill';
+    ref: string;
+    value: string;
+} | {
+    type: 'select';
+    ref: string;
+    value: string;
+} | {
+    type: 'nativeSelect';
+    ref: string;
+    value: string;
+} | {
+    type: 'navigate';
+    url: string;
+} | {
+    type: 'scroll';
+    scrollType: 'vertical' | 'horizontal';
+    value: number;
+    ref?: string;
+    duration?: number;
+} | {
+    type: 'waitFor';
+    condition: string;
+    timeout?: number;
+} | {
+    type: 'delay';
+    ms: number;
+} | {
+    type: 'assert';
+    condition: string;
+    expected?: string;
+    visual?: boolean;
+} | {
+    type: 'keypress';
+    keys: string[];
+    convertPlatformKeys?: boolean;
+} | {
+    type: 'hover';
+    ref: string;
+} | {
+    type: 'paste';
+    ref: string;
+    value: string;
+} | {
+    type: 'keyDown';
+    key: string;
+} | {
+    type: 'keyUp';
+    key: string;
+} | {
+    type: 'refresh';
+} | {
+    type: 'navigateHistory';
+    direction: 'back' | 'forward';
+} | {
+    type: 'readConsoleLogs';
+    level?: 'log' | 'info' | 'warn' | 'error';
+    tab?: {
+        index?: number;
+        title?: string;
+        url?: string;
+    };
+} | {
+    type: 'readNetworkLogs';
+    urlPattern?: string;
+    tab?: {
+        index?: number;
+        title?: string;
+        url?: string;
+    };
+} | {
+    type: 'readCookies';
+    name?: string;
+} | {
+    type: 'setCookies';
+    cookies: Array<{
+        name: string;
+        value: string;
+        domain?: string;
+        path?: string;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: 'Strict' | 'Lax' | 'None';
+        expires?: number;
+    }>;
+} | {
+    type: 'readLocalStorage';
+    key?: string;
+} | {
+    type: 'setLocalStorage';
+    entries: Array<{
+        key: string;
+        value: string;
+    }>;
+} | {
+    type: 'newTab';
+    url: string;
+} | {
+    type: 'switchTab';
+    index?: number;
+    title?: string;
+    url?: string;
+} | {
+    type: 'doubleClick';
+    ref: string;
+    relativePosition?: {
+        x: number;
+        y: number;
+    };
+    clickDelay?: number;
+} | {
+    type: 'rightClick';
+    ref: string;
+    relativePosition?: {
+        x: number;
+        y: number;
+    };
+    clickDelay?: number;
+} | {
+    type: 'waitForUrl';
+    pattern: string;
+} | {
+    type: 'fileUpload';
+    ref: string;
+    files: string[];
+} | {
+    type: 'copy';
+    ref: string;
+} | {
+    type: 'tap';
+    ref: string;
+} | {
+    type: 'swipe';
+    direction: 'up' | 'down' | 'left' | 'right';
+    ref?: string;
+    startX?: number;
+    startY?: number;
+    endX?: number;
+    endY?: number;
+    duration?: number;
+} | {
+    type: 'longpress';
+    ref: string;
+    duration?: number;
+} | {
+    type: 'hideKeyboard';
+} | {
+    type: 'clearText';
+    ref: string;
+} | {
+    type: 'openLink';
+    url: string;
+    appId?: string;
+    bundleId?: string;
+    appPackage?: string;
+    waitForLaunch?: boolean;
+} | {
+    type: 'drag';
+    fromRef: string;
+    toRef: string;
+} | {
+    type: 'doubleTap';
+    ref: string;
+} | {
+    type: 'launchApp';
+    bundleId: string;
+} | {
+    type: 'stopApp';
+    bundleId: string;
+} | {
+    type: 'setOrientation';
+    orientation: 'portrait' | 'landscape';
+} | {
+    type: 'pinch';
+    scale: number;
+    x?: number;
+    y?: number;
+    ref?: string;
+} | {
+    type: 'multiTap';
+    fingers: number;
+    x?: number;
+    y?: number;
+    ref?: string;
+} | {
+    type: 'tapCoordinate';
+    x: number;
+    y: number;
+} | {
+    type: 'executeScript';
+    command: string;
+    args?: unknown;
+} | {
+    type: 'setVariable';
+    name: string;
+    value: string;
+};
+interface ActionResult {
+    success: boolean;
+    error?: string;
+    screenshot?: Buffer;
+    metadata?: Record<string, unknown>;
+    coordinates?: {
+        x: number;
+        y: number;
+    };
+    boundingBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    startCoordinates?: {
+        x: number;
+        y: number;
+    };
+    endCoordinates?: {
+        x: number;
+        y: number;
+    };
+    data?: unknown;
+}
+interface PlatformConfig {
+    platform: 'web' | 'android' | 'ios';
+    browser?: BrowserConfig;
+    device?: DeviceConfig;
+    bundleId?: string;
+    appPackage?: string;
+    appActivity?: string;
+    deepLinkAppId?: string;
+    appState?: 'preserve' | 'reset';
+    appPath?: string;
+    browserstackApp?: string;
+    appiumUrl?: string;
+    timeouts?: TimeoutConfig;
+    recording?: {
+        enabled: boolean;
+        videoDir: string;
+        videoSize?: {
+            width: number;
+            height: number;
+        };
+    };
+    verbose?: boolean;
+    farmSession?: {
+        hostname: string;
+        port: number;
+        path: string;
+        capabilities: Record<string, unknown>;
+    };
+    logCapture?: {
+        console?: boolean;
+        network?: boolean;
+    };
+}
+interface BrowserConfig {
+    name: 'chromium' | 'firefox' | 'webkit';
+    headless?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}
+interface DeviceConfig {
+    name: string;
+    platform: 'android' | 'ios';
+    transport: 'local' | 'browserstack';
+    match: Record<string, unknown>;
+}
+interface TimeoutConfig {
+    step?: number;
+    test?: number;
+    navigation?: number;
+}
+
+declare const CaptureConfigSchema: z.ZodObject<{
+    variable: z.ZodString;
+    method: z.ZodEnum<{
+        regex: "regex";
+        selector: "selector";
+        ai: "ai";
+    }>;
+    pattern: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const TestStepSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    step: z.ZodString;
+    timeout: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    screenshot: z.ZodOptional<z.ZodBoolean>;
+    capture: z.ZodOptional<z.ZodObject<{
+        variable: z.ZodString;
+        method: z.ZodEnum<{
+            regex: "regex";
+            selector: "selector";
+            ai: "ai";
+        }>;
+        pattern: z.ZodOptional<z.ZodString>;
+        selector: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;
+declare const TestMetaSchema: z.ZodObject<{
+    timeout: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    record: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const TestDefinitionSchema: z.ZodObject<{
+    'test-id': z.ZodString;
+    name: z.ZodString;
+    target: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    use: z.ZodOptional<z.ZodObject<{
+        browser: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodEnum<{
+                chromium: "chromium";
+                firefox: "firefox";
+                webkit: "webkit";
+            }>>;
+            headless: z.ZodOptional<z.ZodBoolean>;
+            viewport: z.ZodOptional<z.ZodObject<{
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            step: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+            test: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+            navigation: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        }, z.core.$strict>>;
+        healing: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        planner: z.ZodOptional<z.ZodObject<{
+            maxSubActions: z.ZodOptional<z.ZodNumber>;
+            previousStepCount: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        logCapture: z.ZodOptional<z.ZodObject<{
+            console: z.ZodOptional<z.ZodBoolean>;
+            network: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        cache: z.ZodOptional<z.ZodBoolean>;
+        mobile: z.ZodOptional<z.ZodObject<{
+            appState: z.ZodOptional<z.ZodEnum<{
+                preserve: "preserve";
+                reset: "reset";
+            }>>;
+        }, z.core.$strict>>;
+        llm: z.ZodOptional<z.ZodString>;
+        parallel: z.ZodOptional<z.ZodBoolean>;
+        device: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timeout: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        record: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    setup: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    teardown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    steps: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        step: z.ZodString;
+        timeout: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        screenshot: z.ZodOptional<z.ZodBoolean>;
+        capture: z.ZodOptional<z.ZodObject<{
+            variable: z.ZodString;
+            method: z.ZodEnum<{
+                regex: "regex";
+                selector: "selector";
+                ai: "ai";
+            }>;
+            pattern: z.ZodOptional<z.ZodString>;
+            selector: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+
+declare const MobileAppStateSchema: z.ZodEnum<{
+    preserve: "preserve";
+    reset: "reset";
+}>;
+declare const MobileUseSchema: z.ZodObject<{
+    appState: z.ZodEnum<{
+        preserve: "preserve";
+        reset: "reset";
+    }>;
+}, z.core.$strict>;
+declare const MobileUseOverrideSchema: z.ZodObject<{
+    appState: z.ZodOptional<z.ZodEnum<{
+        preserve: "preserve";
+        reset: "reset";
+    }>>;
+}, z.core.$strict>;
+declare const UseSchema: z.ZodObject<{
+    browser: z.ZodOptional<z.ZodObject<{
+        name: z.ZodEnum<{
+            chromium: "chromium";
+            firefox: "firefox";
+            webkit: "webkit";
+        }>;
+        headless: z.ZodBoolean;
+        viewport: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    mobile: z.ZodOptional<z.ZodObject<{
+        appState: z.ZodEnum<{
+            preserve: "preserve";
+            reset: "reset";
+        }>;
+    }, z.core.$strict>>;
+    timeout: z.ZodOptional<z.ZodObject<{
+        step: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        test: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        navigation: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    }, z.core.$strict>>;
+    healing: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodNumber;
+    }, z.core.$strict>>;
+    planner: z.ZodOptional<z.ZodObject<{
+        maxSubActions: z.ZodNumber;
+        previousStepCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    logCapture: z.ZodOptional<z.ZodObject<{
+        console: z.ZodBoolean;
+        network: z.ZodBoolean;
+    }, z.core.$strict>>;
+    cache: z.ZodOptional<z.ZodBoolean>;
+    llm: z.ZodOptional<z.ZodString>;
+    parallel: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const UseOverrideSchema: z.ZodObject<{
+    browser: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodEnum<{
+            chromium: "chromium";
+            firefox: "firefox";
+            webkit: "webkit";
+        }>>;
+        headless: z.ZodOptional<z.ZodBoolean>;
+        viewport: z.ZodOptional<z.ZodObject<{
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    timeout: z.ZodOptional<z.ZodObject<{
+        step: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        test: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        navigation: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    }, z.core.$strict>>;
+    healing: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    planner: z.ZodOptional<z.ZodObject<{
+        maxSubActions: z.ZodOptional<z.ZodNumber>;
+        previousStepCount: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    logCapture: z.ZodOptional<z.ZodObject<{
+        console: z.ZodOptional<z.ZodBoolean>;
+        network: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    cache: z.ZodOptional<z.ZodBoolean>;
+    mobile: z.ZodOptional<z.ZodObject<{
+        appState: z.ZodOptional<z.ZodEnum<{
+            preserve: "preserve";
+            reset: "reset";
+        }>>;
+    }, z.core.$strict>>;
+    llm: z.ZodOptional<z.ZodString>;
+    parallel: z.ZodOptional<z.ZodBoolean>;
+    device: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+
+type TestStep = z.infer<typeof TestStepSchema>;
+type TestMeta = z.infer<typeof TestMetaSchema>;
+type TestConfig = z.infer<typeof UseOverrideSchema>;
+type TestDefinition = z.infer<typeof TestDefinitionSchema>;
+type CaptureConfig = z.infer<typeof CaptureConfigSchema>;
+
+declare const WorkspaceSchema: z.ZodObject<{
+    testMatch: z.ZodArray<z.ZodString>;
+    suiteMatch: z.ZodArray<z.ZodString>;
+    testPathIgnore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hooksFile: z.ZodString;
+    agentRules: z.ZodString;
+    envFile: z.ZodString;
+    secretsFile: z.ZodString;
+}, z.core.$strict>;
+
+declare const DashboardConfigSchema: z.ZodObject<{
+    port: z.ZodOptional<z.ZodNumber>;
+    dbPath: z.ZodOptional<z.ZodString>;
+    artifactsDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const McpConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        http: "http";
+        stdio: "stdio";
+    }>>;
+    host: z.ZodOptional<z.ZodString & z.ZodType<"localhost" | "127.0.0.1" | "::1", string, z.core.$ZodTypeInternals<"localhost" | "127.0.0.1" | "::1", string>>>;
+    port: z.ZodOptional<z.ZodNumber>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const CacheConfigSchema: z.ZodObject<{
+    dir: z.ZodString;
+    ttl: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+}, z.core.$strict>;
+declare const LoggingConfigSchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        silent: "silent";
+        debug: "debug";
+    }>;
+}, z.core.$strict>;
+declare const RecordingConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const AccessibilityConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    standard: z.ZodOptional<z.ZodEnum<{
+        wcag2a: "wcag2a";
+        wcag2aa: "wcag2aa";
+        wcag2aaa: "wcag2aaa";
+    }>>;
+    runAfter: z.ZodOptional<z.ZodEnum<{
+        navigation: "navigation";
+        "every-step": "every-step";
+        "test-end": "test-end";
+    }>>;
+    failOnViolation: z.ZodOptional<z.ZodBoolean>;
+    disableRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const ServicesSchema: z.ZodObject<{
+    dashboard: z.ZodOptional<z.ZodObject<{
+        port: z.ZodOptional<z.ZodNumber>;
+        dbPath: z.ZodOptional<z.ZodString>;
+        artifactsDir: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    mcp: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            http: "http";
+            stdio: "stdio";
+        }>>;
+        host: z.ZodOptional<z.ZodString & z.ZodType<"localhost" | "127.0.0.1" | "::1", string, z.core.$ZodTypeInternals<"localhost" | "127.0.0.1" | "::1", string>>>;
+        port: z.ZodOptional<z.ZodNumber>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        dir: z.ZodString;
+        ttl: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    }, z.core.$strict>>;
+    logging: z.ZodOptional<z.ZodObject<{
+        level: z.ZodEnum<{
+            info: "info";
+            warn: "warn";
+            error: "error";
+            silent: "silent";
+            debug: "debug";
+        }>;
+    }, z.core.$strict>>;
+    recording: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    accessibility: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        standard: z.ZodOptional<z.ZodEnum<{
+            wcag2a: "wcag2a";
+            wcag2aa: "wcag2aa";
+            wcag2aaa: "wcag2aaa";
+        }>>;
+        runAfter: z.ZodOptional<z.ZodEnum<{
+            navigation: "navigation";
+            "every-step": "every-step";
+            "test-end": "test-end";
+        }>>;
+        failOnViolation: z.ZodOptional<z.ZodBoolean>;
+        disableRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        provider: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            local: "local";
+        }>>>;
+        dir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        minTrust: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxInjections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        curatorEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        curatorLockTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        trustConfirmDelta: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        trustContradictDelta: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        ablationEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        circuitBreakerEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        circuitBreakerWindowSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        circuitBreakerBaselineSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        circuitBreakerThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+declare const TargetSchema: z.ZodObject<{
+    product: z.ZodOptional<z.ZodString>;
+    platform: z.ZodEnum<{
+        web: "web";
+        android: "android";
+        ios: "ios";
+    }>;
+    bundleId: z.ZodOptional<z.ZodString>;
+    appPackage: z.ZodOptional<z.ZodString>;
+    appActivity: z.ZodOptional<z.ZodString>;
+    app: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        browserstack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const DeviceProfileSchema: z.ZodObject<{
+    platform: z.ZodEnum<{
+        android: "android";
+        ios: "ios";
+    }>;
+    transport: z.ZodEnum<{
+        local: "local";
+        browserstack: "browserstack";
+    }>;
+    match: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+declare const ProviderConfigSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+declare const RegistrySchema: z.ZodObject<{
+    llms: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        baseURL: z.ZodOptional<z.ZodString>;
+        providerHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        screenshotSize: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        effectiveResolution: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodString;
+        contextWindow: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    }, z.core.$strict>>>>;
+    targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        product: z.ZodOptional<z.ZodString>;
+        platform: z.ZodEnum<{
+            web: "web";
+            android: "android";
+            ios: "ios";
+        }>;
+        bundleId: z.ZodOptional<z.ZodString>;
+        appPackage: z.ZodOptional<z.ZodString>;
+        appActivity: z.ZodOptional<z.ZodString>;
+        app: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            browserstack: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    devices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        platform: z.ZodEnum<{
+            android: "android";
+            ios: "ios";
+        }>;
+        transport: z.ZodEnum<{
+            local: "local";
+            browserstack: "browserstack";
+        }>;
+        match: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strict>>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+
+declare const AnalyticsSchema: z.ZodObject<{
+    privacy: z.ZodOptional<z.ZodLiteral<true>>;
+    passRateScope: z.ZodOptional<z.ZodObject<{
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            regex: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+declare const DurationString: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+declare const SizeString: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+declare const ModelConfigSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    baseURL: z.ZodOptional<z.ZodString>;
+    providerHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    screenshotSize: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    effectiveResolution: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const NamedLLMConfigSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    baseURL: z.ZodOptional<z.ZodString>;
+    providerHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    screenshotSize: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    effectiveResolution: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodString;
+    contextWindow: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+}, z.core.$strict>;
+declare const HealingConfigSchema: z.ZodObject<{
+    maxAttempts: z.ZodNumber;
+}, z.core.$strict>;
+declare const TimeoutConfigSchema: z.ZodObject<{
+    step: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    test: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    navigation: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+}, z.core.$strict>;
+declare const BrowserConfigSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        chromium: "chromium";
+        firefox: "firefox";
+        webkit: "webkit";
+    }>;
+    headless: z.ZodBoolean;
+    viewport: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const TransportSchema: z.ZodEnum<{
+    local: "local";
+    browserstack: "browserstack";
+}>;
+declare const PlannerConfigSchema: z.ZodObject<{
+    maxSubActions: z.ZodNumber;
+    previousStepCount: z.ZodNumber;
+}, z.core.$strict>;
+declare const LogCaptureConfigSchema: z.ZodObject<{
+    console: z.ZodBoolean;
+    network: z.ZodBoolean;
+}, z.core.$strict>;
+
+declare const AuthPluginDeclarationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    package: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>]>;
+declare const PluginsSchema: z.ZodObject<{
+    auth: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        package: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>]>>>>;
+}, z.core.$strict>;
+declare const AgentQaConfigSchema: z.ZodObject<{
+    workspace: z.ZodObject<{
+        testMatch: z.ZodArray<z.ZodString>;
+        suiteMatch: z.ZodArray<z.ZodString>;
+        testPathIgnore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hooksFile: z.ZodString;
+        agentRules: z.ZodString;
+        envFile: z.ZodString;
+        secretsFile: z.ZodString;
+    }, z.core.$strict>;
+    services: z.ZodOptional<z.ZodObject<{
+        dashboard: z.ZodOptional<z.ZodObject<{
+            port: z.ZodOptional<z.ZodNumber>;
+            dbPath: z.ZodOptional<z.ZodString>;
+            artifactsDir: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        mcp: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                http: "http";
+                stdio: "stdio";
+            }>>;
+            host: z.ZodOptional<z.ZodString & z.ZodType<"localhost" | "127.0.0.1" | "::1", string, z.core.$ZodTypeInternals<"localhost" | "127.0.0.1" | "::1", string>>>;
+            port: z.ZodOptional<z.ZodNumber>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        cache: z.ZodOptional<z.ZodObject<{
+            dir: z.ZodString;
+            ttl: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        }, z.core.$strict>>;
+        logging: z.ZodOptional<z.ZodObject<{
+            level: z.ZodEnum<{
+                info: "info";
+                warn: "warn";
+                error: "error";
+                silent: "silent";
+                debug: "debug";
+            }>;
+        }, z.core.$strict>>;
+        recording: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        accessibility: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            standard: z.ZodOptional<z.ZodEnum<{
+                wcag2a: "wcag2a";
+                wcag2aa: "wcag2aa";
+                wcag2aaa: "wcag2aaa";
+            }>>;
+            runAfter: z.ZodOptional<z.ZodEnum<{
+                navigation: "navigation";
+                "every-step": "every-step";
+                "test-end": "test-end";
+            }>>;
+            failOnViolation: z.ZodOptional<z.ZodBoolean>;
+            disableRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        memory: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            provider: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                local: "local";
+            }>>>;
+            dir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            minTrust: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            maxInjections: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            curatorEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            curatorLockTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            trustConfirmDelta: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            trustContradictDelta: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            ablationEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            circuitBreakerEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            circuitBreakerWindowSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            circuitBreakerBaselineSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            circuitBreakerThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    registry: z.ZodOptional<z.ZodObject<{
+        llms: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            baseURL: z.ZodOptional<z.ZodString>;
+            providerHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            screenshotSize: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+            effectiveResolution: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            contextWindow: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        }, z.core.$strict>>>>;
+        targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            product: z.ZodOptional<z.ZodString>;
+            platform: z.ZodEnum<{
+                web: "web";
+                android: "android";
+                ios: "ios";
+            }>;
+            bundleId: z.ZodOptional<z.ZodString>;
+            appPackage: z.ZodOptional<z.ZodString>;
+            appActivity: z.ZodOptional<z.ZodString>;
+            app: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                browserstack: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        devices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            platform: z.ZodEnum<{
+                android: "android";
+                ios: "ios";
+            }>;
+            transport: z.ZodEnum<{
+                local: "local";
+                browserstack: "browserstack";
+            }>;
+            match: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strict>>>;
+        providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strict>>;
+    use: z.ZodOptional<z.ZodObject<{
+        browser: z.ZodOptional<z.ZodObject<{
+            name: z.ZodEnum<{
+                chromium: "chromium";
+                firefox: "firefox";
+                webkit: "webkit";
+            }>;
+            headless: z.ZodBoolean;
+            viewport: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        mobile: z.ZodOptional<z.ZodObject<{
+            appState: z.ZodEnum<{
+                preserve: "preserve";
+                reset: "reset";
+            }>;
+        }, z.core.$strict>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            step: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+            test: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+            navigation: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        }, z.core.$strict>>;
+        healing: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+        }, z.core.$strict>>;
+        planner: z.ZodOptional<z.ZodObject<{
+            maxSubActions: z.ZodNumber;
+            previousStepCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        logCapture: z.ZodOptional<z.ZodObject<{
+            console: z.ZodBoolean;
+            network: z.ZodBoolean;
+        }, z.core.$strict>>;
+        cache: z.ZodOptional<z.ZodBoolean>;
+        llm: z.ZodOptional<z.ZodString>;
+        parallel: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    plugins: z.ZodOptional<z.ZodObject<{
+        auth: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            package: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>]>>>>;
+    }, z.core.$strict>>;
+    analytics: z.ZodOptional<z.ZodObject<{
+        privacy: z.ZodOptional<z.ZodLiteral<true>>;
+        passRateScope: z.ZodOptional<z.ZodObject<{
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                regex: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+type AgentQaConfig = z.infer<typeof AgentQaConfigSchema>;
+type WorkspaceConfig = z.infer<typeof WorkspaceSchema>;
+type ServicesConfig = z.infer<typeof ServicesSchema>;
+type RegistryConfig = z.infer<typeof RegistrySchema>;
+type UseConfig = z.infer<typeof UseSchema>;
+
+declare const ActionPlanSchema: z.ZodObject<{
+    reasoning: z.ZodString;
+    action: z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>;
+    confidence: z.ZodNumber;
+    stepComplete: z.ZodDefault<z.ZodBoolean>;
+    stepFailed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+type ActionPlan = z.infer<typeof ActionPlanSchema>;
+
+declare const SuiteTestEntrySchema: z.ZodObject<{
+    test: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>;
+declare const SuiteDefinitionSchema: z.ZodObject<{
+    'suite-id': z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    target: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    setup: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    teardown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tests: z.ZodArray<z.ZodObject<{
+        test: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    use: z.ZodOptional<z.ZodObject<{
+        browser: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodEnum<{
+                chromium: "chromium";
+                firefox: "firefox";
+                webkit: "webkit";
+            }>>;
+            headless: z.ZodOptional<z.ZodBoolean>;
+            viewport: z.ZodOptional<z.ZodObject<{
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            step: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+            test: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+            navigation: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+        }, z.core.$strict>>;
+        healing: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        planner: z.ZodOptional<z.ZodObject<{
+            maxSubActions: z.ZodOptional<z.ZodNumber>;
+            previousStepCount: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        logCapture: z.ZodOptional<z.ZodObject<{
+            console: z.ZodOptional<z.ZodBoolean>;
+            network: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        cache: z.ZodOptional<z.ZodBoolean>;
+        mobile: z.ZodOptional<z.ZodObject<{
+            appState: z.ZodOptional<z.ZodEnum<{
+                preserve: "preserve";
+                reset: "reset";
+            }>>;
+        }, z.core.$strict>>;
+        llm: z.ZodOptional<z.ZodString>;
+        parallel: z.ZodOptional<z.ZodBoolean>;
+        device: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+declare const HookDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    runtime: z.ZodEnum<{
+        node: "node";
+        bun: "bun";
+        python: "python";
+        bash: "bash";
+    }>;
+    file: z.ZodString;
+    deps: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    packageFile: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    network: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+declare const HooksFileSchema: z.ZodObject<{
+    hooks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        runtime: z.ZodEnum<{
+            node: "node";
+            bun: "bun";
+            python: "python";
+            bash: "bash";
+        }>;
+        file: z.ZodString;
+        deps: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        packageFile: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        network: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type HooksFileConfig = z.infer<typeof HooksFileSchema>;
+
+interface ParseError {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+    severity: 'error' | 'warning';
+    source: string;
+    suggestion?: string;
+}
+interface FormatOptions {
+    noColor?: boolean;
+}
+declare function formatParseError(error: ParseError, opts?: FormatOptions): string;
+
+interface ParseResult {
+    tests: TestDefinition[];
+    errors: ParseError[];
+}
+declare function parseTestFile(content: string, filePath: string): ParseResult;
+declare function parseAllTests(filePaths: string[]): Promise<ParseResult>;
+
+interface FileAttachment {
+    name: string;
+    path: string;
+    content: Buffer;
+    mimeType: string;
+}
+declare function resolveFileReferences(stepText: string, testFilePath: string): Promise<{
+    resolvedText: string;
+    attachments: FileAttachment[];
+}>;
+
+type SuiteDefinition = z.infer<typeof SuiteDefinitionSchema>;
+interface SuiteResult {
+    runId?: string;
+    name: string;
+    status: 'passed' | 'failed' | 'cancelled';
+    tests: TestResult[];
+    duration: number;
+    failedAt?: number;
+}
+
+declare function parseSuiteFile(filePath: string): Promise<SuiteDefinition>;
+
+type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+declare const LOG_LEVEL_PRIORITY: Record<LogLevel, number>;
+type LogSource = 'agent' | 'adapter' | 'cache' | 'planner' | 'healer' | 'hook' | 'runner';
+interface LogEntry {
+    id: string;
+    stepId: string | null;
+    runId: string;
+    level: Exclude<LogLevel, 'silent'>;
+    source: LogSource;
+    message: string;
+    data: Record<string, unknown>;
+    timestamp: string;
+}
+interface LogStorage {
+    insertLogs(entries: LogEntry[]): void;
+    getLogs(opts: {
+        runId?: string;
+        stepId?: string;
+        level?: string;
+        source?: string;
+        limit?: number;
+        offset?: number;
+    }): LogEntry[];
+}
+interface ScopedLogger {
+    debug(msg: string, data?: Record<string, unknown>): void;
+    info(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+}
+declare const AgentLogDataSchema: z.ZodObject<{
+    extractDom: z.ZodOptional<z.ZodBoolean>;
+    hasScreenshot: z.ZodOptional<z.ZodBoolean>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    elementCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const AdapterLogDataSchema: z.ZodObject<{
+    actionType: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    coordinates: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    elementProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const CacheLogDataSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        set: "set";
+        get: "get";
+        invalidate: "invalidate";
+        bypass: "bypass";
+        "batch-purge": "batch-purge";
+    }>;
+    stepHash: z.ZodOptional<z.ZodString>;
+    screenHash: z.ZodOptional<z.ZodString>;
+    hit: z.ZodOptional<z.ZodBoolean>;
+    age: z.ZodOptional<z.ZodNumber>;
+    entriesDeleted: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const PlannerLogDataSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    promptTokens: z.ZodOptional<z.ZodNumber>;
+    completionTokens: z.ZodOptional<z.ZodNumber>;
+    latencyMs: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    actionType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HealerLogDataSchema: z.ZodObject<{
+    strategy: z.ZodOptional<z.ZodString>;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    stateDiffDetected: z.ZodOptional<z.ZodBoolean>;
+    success: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const HookLogDataSchema: z.ZodObject<{
+    hookName: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        setup: "setup";
+        teardown: "teardown";
+    }>>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    success: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const RunnerLogDataSchema: z.ZodObject<{
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+    totalSteps: z.ZodOptional<z.ZodNumber>;
+    testName: z.ZodOptional<z.ZodString>;
+    variablesCaptured: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const LogSourceDataSchemas: Record<LogSource, z.ZodType>;
+
+interface SecretTemplate {
+    pattern: string;
+    name: string;
+}
+interface SecretFileMetadata {
+    count: number;
+}
+declare class SecretConfigError extends Error {
+    constructor(message: string);
+}
+declare class MissingSecretError extends Error {
+    constructor(name: string);
+}
+declare class SecretStore {
+    private storage;
+    constructor(secrets?: Record<string, string>);
+    static empty(): SecretStore;
+    static fromEnvContent(content: string): SecretStore;
+    private set;
+    get(name: string): string | undefined;
+    require(name: string): string;
+    has(name: string): boolean;
+    count(): number;
+    metadata(): SecretFileMetadata;
+    forEachSecret(callback: (name: string, value: string) => void): void;
+}
+declare function findSecretTemplates(text: string): SecretTemplate[];
+declare function interpolateSecretTemplates(template: string, store: SecretStore): string;
+declare function resolveSecretTemplatesInValue<T>(value: T, store?: SecretStore): T;
+declare function redactSecretValue<T>(value: T, redactor?: SecretRedactor): T;
+declare class SecretRedactor {
+    private readonly store;
+    private readonly genericMarker;
+    private valuePatterns;
+    constructor(store: SecretStore, genericMarker?: string);
+    redactString(value: string): string;
+    redactValue(value: unknown): unknown;
+}
+
+declare class LogManager {
+    private buffer;
+    private currentStepId;
+    private runId;
+    private runIdSet;
+    private readonly displayLevel;
+    private readonly storage?;
+    private readonly ndjson;
+    private redactor?;
+    constructor(opts: {
+        runId?: string;
+        displayLevel: LogLevel;
+        storage?: LogStorage;
+        ndjson?: boolean;
+        redactor?: SecretRedactor;
+    });
+    setRedactor(redactor: SecretRedactor | undefined): void;
+    log(level: Exclude<LogLevel, 'silent'>, source: LogSource, message: string, data?: Record<string, unknown>): void;
+    private shouldDisplay;
+    private emitNdjson;
+    setCurrentStep(stepId: string): void;
+    clearCurrentStep(): void;
+    setRunId(runId: string): void;
+    flush(): void;
+    getBuffer(): LogEntry[];
+    createScopedLogger(source: LogSource): ScopedLogger;
+}
+
+interface PlannerConfig {
+    maxSubActions: number;
+    previousStepCount: number;
+}
+interface PlanResult {
+    plan: ActionPlan;
+    tokenUsage?: TokenUsage;
+}
+interface VerifyResult {
+    verification: VerificationResult;
+    tokenUsage?: TokenUsage;
+}
+type AgentPhase = {
+    type: 'observe';
+} | {
+    type: 'plan';
+    screenState: ScreenState;
+} | {
+    type: 'execute';
+    action: Action;
+    screenStateBefore: ScreenState;
+} | {
+    type: 'verify';
+    action: Action;
+    screenStateBefore: ScreenState;
+    result: ActionResult;
+} | {
+    type: 'heal';
+    error: string;
+    attempts: HealingAttempt[];
+    screenStateBefore: ScreenState;
+    failedAction: Action;
+} | {
+    type: 'done';
+    result: StepResult;
+};
+interface StepContext {
+    stepInstruction: string;
+    testName: string;
+    testContext?: string;
+    suiteContext?: string;
+    agentRules?: string;
+    previousSteps: {
+        instruction: string;
+        outcome: string;
+        reasoning?: string;
+        plannedAction?: string;
+        verifierResponse?: string;
+    }[];
+    contextWindow?: number;
+    plannerModel: LanguageModel;
+    verifierModel: LanguageModel;
+    healingConfig: HealingConfig;
+    modelId?: string;
+    variables?: Record<string, string>;
+    memoryContext?: string;
+    failureContext?: string;
+    /** Sub-actions already attempted in this step (multi-action mode). */
+    subActionHistory?: {
+        action: string;
+        reasoning?: string;
+        result: 'success' | 'failure';
+        error?: string;
+        verifierRejection?: string;
+        screenChanged?: boolean;
+        data?: string;
+    }[];
+    plannerConfig?: PlannerConfig;
+    screenshot?: Buffer;
+}
+interface HealingConfig {
+    maxAttempts: number;
+}
+interface AgentLoopConfig {
+    adapter: PlatformAdapter;
+    planner: Planner;
+    verifier?: Verifier;
+    cache?: ActionCache;
+    healingConfig: HealingConfig;
+    plannerConfig?: PlannerConfig;
+    /** Wall-clock timeout for a single step (ms). 0 or undefined = no timeout. */
+    stepTimeout?: number;
+    /** Override the consecutive failure limit for this step. */
+    maxAttempts?: number;
+    logger?: LogManager;
+    configContent?: string;
+    testFileContent?: string;
+    testFilePath?: string;
+    stepIndex?: number;
+    suiteFileContent?: string;
+    suiteTestIndex?: number;
+    cacheState?: {
+        invalidated: boolean;
+    };
+    logCapture?: {
+        console?: boolean;
+        network?: boolean;
+    };
+    screenshotSize?: number;
+    /** Max image edge (pixels) to resize screenshots to before sending to LLM. From ModelConfig. */
+    effectiveResolution?: number;
+    onSetVariable?: (name: string, value: string) => void;
+    onPhase?: (event: StepPhaseEvent) => void | Promise<void>;
+    abortSignal?: AbortSignal;
+    secretStore?: SecretStore;
+    secretRedactor?: SecretRedactor;
+}
+interface Planner {
+    plan(step: string, screenState: ScreenState, context: StepContext, abortSignal?: AbortSignal): Promise<PlanResult>;
+}
+interface Verifier {
+    verify(step: string, before: ScreenState, after: ScreenState, action: Action, screenshot?: Buffer, abortSignal?: AbortSignal): Promise<VerifyResult>;
+}
+interface VerificationResult {
+    success: boolean;
+    reasoning: string;
+    isAppError: boolean;
+}
+interface ActionCache {
+    get(stepHash: string, screenHash: string): Promise<ActionPlan | null>;
+    set(stepHash: string, screenHash: string, plan: ActionPlan): Promise<void>;
+    invalidate(stepHash: string, screenHash: string): Promise<void>;
+    getSubAction(stepHash: string, index: number): Promise<ActionPlan | null>;
+    setSubAction(stepHash: string, index: number, plan: ActionPlan): Promise<void>;
+    invalidateSubActionsFrom(stepHash: string, fromIndex: number): Promise<void>;
+}
+type AssertionType = 'text-presence' | 'element-visibility' | 'url-match' | 'element-count' | 'ai';
+interface AssertionResult {
+    passed: boolean;
+    assertionType: AssertionType;
+    expected: string;
+    actual: string;
+    reasoning: string;
+}
+interface Asserter {
+    evaluate(assertion: AssertionInput, screenState: ScreenState): Promise<AssertionResult>;
+}
+interface AssertionInput {
+    type: AssertionType;
+    value: string;
+    expected?: string;
+}
+type ExtractionMethod = 'regex' | 'selector' | 'ai';
+interface ExtractorInput {
+    method: ExtractionMethod;
+    variableName: string;
+    pattern?: string;
+    selector?: string;
+    description?: string;
+}
+interface CaptureResult {
+    success: boolean;
+    variableName: string;
+    value?: string;
+    reasoning: string;
+}
+interface VariableExtractor {
+    extract(input: ExtractorInput, screenState: ScreenState): Promise<CaptureResult>;
+}
+
+declare function truncateScreenState(state: ScreenState): string;
+declare function hashScreenState(state: ScreenState): string;
+interface StepHashInputs {
+    step: string;
+    platform?: string;
+    configContent?: string;
+    testFileContent?: string;
+    stepIndex?: number;
+    suiteFileContent?: string;
+    suiteTestIndex?: number;
+}
+declare function hashStepInstruction(inputs: StepHashInputs): string;
+declare function hashStepInstruction(step: string, platform?: string, configContent?: string, testFileContent?: string, stepIndex?: number): string;
+
+declare function estimateTokens(text: string): number;
+
+declare const SUPPORTED_PROVIDERS: readonly ["openai-compatible", "anthropic-compatible", "openai-subscription", "anthropic-subscription", "gemini"];
+type BuiltInProviderMode = typeof SUPPORTED_PROVIDERS[number];
+type ProviderMode = BuiltInProviderMode | (string & {});
+type LLMModelAdapter$1 = 'openai-responses' | 'anthropic-messages';
+interface ModelConfig {
+    provider: ProviderMode;
+    model: string;
+    modelAdapter?: LLMModelAdapter$1;
+    apiKey?: string;
+    authToken?: string;
+    baseURL?: string;
+    providerHeaders?: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+}
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue | undefined;
+};
+type ProviderOptions = Record<string, Record<string, JSONValue | undefined>> | undefined;
+declare function getProviderOptions(config: ModelConfig): ProviderOptions;
+declare function createModel(config: ModelConfig): Promise<LanguageModel>;
+
+declare class LLMPlanner implements Planner {
+    private model;
+    private platform;
+    private providerOptions;
+    private logger?;
+    private agentRules?;
+    constructor(model: LanguageModel, platform?: 'web' | 'android' | 'ios', providerOptions?: ProviderOptions, logger?: ScopedLogger, agentRules?: string);
+    plan(step: string, screenState: ScreenState, context: StepContext, abortSignal?: AbortSignal): Promise<PlanResult>;
+}
+
+declare const VerificationResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    reasoning: z.ZodString;
+    isAppError: z.ZodBoolean;
+}, z.core.$strip>;
+declare class LLMVerifier implements Verifier {
+    private model;
+    private providerOptions;
+    constructor(model: LanguageModel, providerOptions?: ProviderOptions);
+    verify(step: string, before: ScreenState, after: ScreenState, action: Action, screenshot?: Buffer, abortSignal?: AbortSignal): Promise<VerifyResult>;
+}
+
+declare function buildSystemPrompt(platform?: 'web' | 'android' | 'ios', agentRules?: string): string;
+declare function buildStepPrompt(step: string, screenState: ScreenState, context: StepContext, logger?: ScopedLogger, systemPromptContext?: {
+    platform?: 'web' | 'android' | 'ios';
+    agentRules?: string;
+}): string;
+declare function buildVerificationPrompt(step: string, beforeState: ScreenState, afterState: ScreenState, action: Action, hasScreenshot?: boolean): string;
+declare function buildAssertionPrompt(assertion: AssertionInput, screenState: ScreenState): string;
+declare function buildExtractionPrompt(input: ExtractorInput, screenState: ScreenState): string;
+
+type ToolCategory = 'action' | 'file' | 'network';
+interface ToolDefinition<T extends z.ZodType = z.ZodType> {
+    name: string;
+    description: string;
+    category: ToolCategory;
+    platform?: ('web' | 'android' | 'ios')[];
+    schema: T;
+}
+
+declare class ToolRegistry {
+    private tools;
+    register<T extends z.ZodType>(def: ToolDefinition<T>): this;
+    get(name: string): ToolDefinition | undefined;
+    getAll(): ToolDefinition[];
+    getFiltered(options: {
+        platform?: string;
+        categories?: ToolCategory[];
+    }): ToolDefinition[];
+    getSchema(name: string): z.ZodType;
+    generateDocs(platform?: string): string;
+}
+declare const defaultRegistry: ToolRegistry;
+
+declare const MOBILE_ONLY_ACTIONS: Set<string>;
+declare const WEB_ONLY_ACTIONS: Set<string>;
+
+declare function buildTools(registry: ToolRegistry, options: {
+    platform: 'web' | 'android' | 'ios';
+    categories?: ToolCategory[];
+}): Record<string, ai.Tool<any, any>>;
+declare function toolCallToActionPlan(toolName: string, args: Record<string, unknown>, registry: ToolRegistry): {
+    reasoning: string;
+    confidence: number;
+    stepComplete: boolean;
+    stepFailed: boolean;
+    action: {
+        type: string;
+    };
+};
+
+declare const toolSchemaMiddleware: LanguageModelMiddleware;
+declare function createWrappedModel(baseModel: Parameters<typeof wrapLanguageModel>[0]['model']): LanguageModel;
+
+declare const AssertionResultSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    reasoning: z.ZodString;
+    evidence: z.ZodString;
+}, z.core.$strip>;
+declare class AssertionEvaluator implements Asserter {
+    evaluate(assertion: AssertionInput, screenState: ScreenState): Promise<AssertionResult>;
+    private evaluateTextPresence;
+    private evaluateElementVisibility;
+    private evaluateUrlMatch;
+    private evaluateElementCount;
+}
+declare class LLMAssertionEvaluator implements Asserter {
+    private model;
+    constructor(model: LanguageModel);
+    evaluate(assertion: AssertionInput, screenState: ScreenState): Promise<AssertionResult>;
+}
+declare function createAsserter(model?: LanguageModel): Asserter;
+
+declare function executeStep(stepInstruction: string, config: AgentLoopConfig, context: StepContext): Promise<StepResult>;
+
+interface RebuildCommand {
+    command: string;
+    args: string[];
+}
+declare function isBetterSqlite3AbiMismatch(error: unknown): boolean;
+declare function isBetterSqlite3NativeModuleError(error: unknown): boolean;
+declare function isBetterSqlite3NodeGypSymlinkConflict(error: unknown): boolean;
+declare function resolveBetterSqliteRebuildCommand(): RebuildCommand;
+type BetterSqlite3Database = better_sqlite3.Database;
+declare function createBetterSqlite3Database(path: string): BetterSqlite3Database;
+
+interface MemoryIndexParams {
+    product: string;
+    suiteId?: string;
+    testId: string;
+    memoryRoot: string;
+    currentSuiteTests?: Array<{
+        test: string;
+        id: string;
+    }>;
+    currentPosition?: number;
+}
+declare function buildMemoryIndex(params: MemoryIndexParams): Promise<BetterSqlite3Database | null>;
+
+declare const BaseObservationSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    trust: z.ZodNumber;
+    created: z.ZodString;
+    last_confirmed: z.ZodString;
+    confirmed_count: z.ZodNumber;
+    contradicted_count: z.ZodNumber;
+    source_test: z.ZodString;
+}, z.core.$strip>;
+declare const SuiteObservationSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    trust: z.ZodNumber;
+    created: z.ZodString;
+    last_confirmed: z.ZodString;
+    confirmed_count: z.ZodNumber;
+    contradicted_count: z.ZodNumber;
+    source_test: z.ZodString;
+    position: z.ZodNumber;
+    suite_snapshot: z.ZodArray<z.ZodObject<{
+        test: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+type BaseObservation = z.infer<typeof BaseObservationSchema>;
+type SuiteObservation = z.infer<typeof SuiteObservationSchema>;
+
+interface MemoryObservationSnippet {
+    id: string;
+    title: string;
+    content: string;
+    trust: number;
+}
+interface MemoryQueryResult {
+    observations: MemoryObservationSnippet[];
+    formatted: string;
+}
+interface MemoryProvider {
+    init(params: MemoryIndexParams): Promise<void>;
+    queryForStep(stepText: string, stepIndex: number): MemoryQueryResult | null;
+    destroy(): void;
+    acquireLock(): Promise<void>;
+    releaseLock(): Promise<void>;
+    writeObservation(tier: 'products' | 'suites' | 'tests', scope: string, data: BaseObservation | SuiteObservation): Promise<string>;
+    deleteObservation(tier: 'products' | 'suites' | 'tests', scope: string, id: string): Promise<void>;
+    searchForDuplicates(content: string): MemoryObservationSnippet[];
+    getAllObservations(): MemoryObservationSnippet[];
+    getInjectedObservations(stepIndex: number): string[];
+    getRunAnalytics(): unknown;
+}
+
+interface CircuitBreakerConfig {
+    windowSize: number;
+    baselineSize: number;
+    threshold: number;
+}
+declare class CircuitBreaker {
+    private config;
+    private window;
+    private _tripped;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    record(outcome: {
+        withMemory: boolean;
+        passed: boolean;
+    }): void;
+    isTripped(): boolean;
+    private evaluate;
+}
+
+type RunAttributes = Record<string, string>;
+declare const INTERNAL_ATTRIBUTE_PREFIX = "agent-qa.";
+declare const ATTR_TRIGGER = "agent-qa.trigger";
+declare const ATTR_RUNNER = "agent-qa.runner";
+type RunAttributeTrigger = 'cli' | 'dashboard' | 'api' | 'mcp';
+type RunAttributeRunner = 'local' | 'browserstack';
+declare const RUN_ATTRIBUTE_KEY_MAX_LENGTH = 256;
+declare const RUN_ATTRIBUTE_VALUE_MAX_LENGTH = 4096;
+interface ParsedRunAttrFlags {
+    attributes: RunAttributes;
+    duplicateKeys: string[];
+}
+declare function validateUserRunAttributes(input: unknown, sourceLabel?: string): RunAttributes;
+declare function validateTrustedRunAttributes(input: unknown, sourceLabel?: string): RunAttributes;
+declare function parseRunAttrFlags(flags: string[] | undefined): ParsedRunAttrFlags;
+declare function buildInternalRunAttributes(input: {
+    trigger: RunAttributeTrigger;
+    runner: RunAttributeRunner;
+}): RunAttributes;
+declare function mergeRunAttributes(internal: RunAttributes, user: RunAttributes): RunAttributes;
+declare function sortRunAttributesForDisplay(attributes: RunAttributes, activeKeys?: string[]): Array<[string, string]>;
+declare function formatRunAttributesBlock(attributes: RunAttributes): string;
+
+declare const RUN_ARTIFACT_SCHEMA_VERSION: 1;
+type RunArtifactKind = 'test' | 'suite-parent' | 'suite-child' | 'unknown';
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type JsonArray = JsonValue[];
+type ArtifactRecord = Record<string, unknown>;
+interface RunArtifactMetadata extends ArtifactRecord {
+    attributes?: RunAttributes;
+}
+interface RunArtifactTerminalError {
+    code: string;
+    message: string;
+    phase: string;
+    details?: unknown;
+}
+interface RunArtifactConfigSnapshot {
+    rawConfigContent?: string | null;
+    parsedConfig?: unknown;
+    effectiveConfig?: unknown;
+    envFile?: {
+        path: string | null;
+        content: string | null;
+        variables: Record<string, string>;
+    };
+    secretsFile?: {
+        path: string | null;
+        status: 'loaded' | 'missing' | 'unreadable' | 'invalid';
+        count?: number;
+    } | null;
+    cliVars?: Record<string, string>;
+    inlineVars?: Record<string, string>;
+    hooks?: Array<{
+        id: string;
+        name: string;
+        runtime?: string;
+        sourcePath?: string;
+    }>;
+    model?: {
+        planner?: {
+            provider?: string;
+            model?: string;
+        };
+        verifier?: {
+            provider?: string;
+            model?: string;
+        };
+    };
+    runtime?: ArtifactRecord;
+    timeouts?: ArtifactRecord;
+    cache?: ArtifactRecord;
+    memory?: ArtifactRecord;
+}
+interface RunArtifactTestSourceSnapshot {
+    kind: 'test';
+    testId?: string | null;
+    name?: string | null;
+    filePath?: string | null;
+    rawYaml?: string | null;
+    resolvedDefinition?: unknown;
+    loadStatus?: 'queued' | 'loaded' | 'parse-error' | 'setup-error' | 'runtime-error' | 'missing' | 'validation-error' | 'skipped';
+    error?: RunArtifactTerminalError;
+}
+interface RunArtifactSuiteMemberSnapshot {
+    index: number;
+    ref: {
+        test: string;
+        id?: string;
+    };
+    filePath?: string | null;
+    testId?: string | null;
+    name?: string | null;
+    target?: string | null;
+    rawYaml?: string | null;
+    resolvedDefinition?: unknown | null;
+    loadStatus: 'loaded' | 'missing' | 'parse-error' | 'validation-error' | 'skipped';
+    error?: RunArtifactTerminalError;
+    childRunId?: string;
+    skipReason?: string;
+}
+interface RunArtifactSuiteSourceSnapshot {
+    kind: 'suite';
+    suiteId?: string | null;
+    name?: string | null;
+    filePath?: string | null;
+    rawYaml?: string | null;
+    resolvedDefinition?: unknown;
+    loadStatus?: 'queued' | 'loaded' | 'parse-error' | 'setup-error' | 'runtime-error' | 'missing' | 'validation-error' | 'skipped';
+    members?: RunArtifactSuiteMemberSnapshot[];
+    error?: RunArtifactTerminalError;
+}
+interface RunArtifactRuntimeSnapshot extends ArtifactRecord {
+    status?: string;
+    duration?: number;
+    startedAt?: string;
+    endedAt?: string;
+    videoPath?: string | null;
+    failureSummary?: string | null;
+}
+type RunArtifactMemoryDeltaAction = 'add' | 'confirm' | 'deprecate' | 'delete';
+interface RunArtifactMemoryObservationSnapshot {
+    id: string;
+    title: string;
+    content: string;
+    trust: number;
+    created: string;
+    last_confirmed: string;
+    confirmed_count: number;
+    contradicted_count: number;
+    source_test: string;
+    position?: number;
+    suite_snapshot?: Array<{
+        test: string;
+        id: string;
+    }>;
+}
+interface RunArtifactMemoryDelta {
+    action: RunArtifactMemoryDeltaAction;
+    tier: 'products' | 'suites' | 'tests';
+    scope: string;
+    observationId: string;
+    reasoning: string;
+    before: RunArtifactMemoryObservationSnapshot | null;
+    after: RunArtifactMemoryObservationSnapshot | null;
+    error?: string;
+}
+interface RunArtifactMemorySnapshot {
+    log?: {
+        added: number;
+        confirmed: number;
+        deprecated: number;
+        deleted?: number;
+        deltas?: RunArtifactMemoryDelta[];
+        errors: string[];
+        curatorDuration: number;
+        tokenUsage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    };
+    aggregate?: ArtifactRecord;
+}
+interface RunArtifactPayload {
+    schemaVersion: typeof RUN_ARTIFACT_SCHEMA_VERSION;
+    config?: RunArtifactConfigSnapshot | ArtifactRecord;
+    source?: RunArtifactTestSourceSnapshot | RunArtifactSuiteSourceSnapshot | ArtifactRecord;
+    runtime?: RunArtifactRuntimeSnapshot;
+    memory?: RunArtifactMemorySnapshot | ArtifactRecord;
+    errors?: RunArtifactTerminalError[];
+    metadata?: RunArtifactMetadata;
+}
+interface RunArtifactStageInput extends Partial<Omit<RunArtifactPayload, 'schemaVersion'>> {
+    schemaVersion?: typeof RUN_ARTIFACT_SCHEMA_VERSION;
+}
+interface RunArtifactFinalizeInput extends RunArtifactStageInput {
+    finalizedAt?: string;
+}
+interface RunArtifactReporterContext {
+    runId?: string;
+    parentRunId?: string | null;
+    artifact?: RunArtifactStageInput & {
+        kind?: RunArtifactKind;
+        suiteIndex?: number;
+        parentRunId?: string | null;
+    };
+}
+
+interface RunSummary {
+    results: TestResult[];
+    duration: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+interface SuiteSummary {
+    runId?: string;
+    name: string;
+    status: 'passed' | 'failed' | 'cancelled';
+    tests: TestResult[];
+    duration: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+interface HookEvent {
+    hookId?: string;
+    hookName: string;
+    phase: 'setup' | 'teardown' | 'inline';
+    hookExecutionId: string;
+    runId?: string;
+    stepId?: string;
+}
+interface StepEventContext {
+    runId?: string;
+    parentRunId?: string | null;
+    suiteIndex?: number;
+    testIndex?: number;
+    stepIndex?: number;
+    stepId?: string;
+}
+interface HookResultEvent extends HookEvent {
+    status: 'passed' | 'failed';
+    duration: number;
+    stdout: string;
+    stderr: string;
+    variables: Record<string, string>;
+    error?: string;
+    type?: 'hook' | 'appium-script' | 'runjs';
+}
+interface Reporter {
+    onSuiteStart?(suite: SuiteDefinition, context?: RunArtifactReporterContext): void | Promise<void>;
+    onSuiteEnd?(summary: SuiteSummary): void | Promise<void>;
+    onRunStart?(tests: TestDefinition[]): void | Promise<void>;
+    onTestStart?(test: TestDefinition, filePath: string, context?: RunArtifactReporterContext): void | Promise<void>;
+    onStepStart?(step: string, testName: string, context?: StepEventContext): void | Promise<void>;
+    onStepEnd?(result: StepResult, testName: string, context?: StepEventContext): void | Promise<void>;
+    onTestEnd?(result: TestResult): void | Promise<void>;
+    onRunEnd?(summary: RunSummary): void | Promise<void>;
+    onStepPhase?(phase: StepPhaseEvent, stepName: string, testName: string, context?: StepEventContext): void | Promise<void>;
+    onHookStart?(event: HookEvent): void | Promise<void>;
+    onHookEnd?(event: HookResultEvent): void | Promise<void>;
+}
+type ReporterEvent = {
+    type: 'suite-start';
+    suite: SuiteDefinition;
+    context?: RunArtifactReporterContext;
+} | {
+    type: 'suite-end';
+    summary: SuiteSummary;
+} | {
+    type: 'run-start';
+    tests: TestDefinition[];
+} | {
+    type: 'test-start';
+    test: TestDefinition;
+    filePath: string;
+    context?: RunArtifactReporterContext;
+} | {
+    type: 'step-start';
+    step: string;
+    testName: string;
+    context?: StepEventContext;
+} | {
+    type: 'step-end';
+    result: StepResult;
+    testName: string;
+    context?: StepEventContext;
+} | {
+    type: 'test-end';
+    result: TestResult;
+} | {
+    type: 'run-end';
+    summary: RunSummary;
+} | {
+    type: 'step-phase';
+    phase: StepPhaseEvent;
+    stepName: string;
+    testName: string;
+    context?: StepEventContext;
+} | {
+    type: 'hook-start';
+    event: HookEvent;
+} | {
+    type: 'hook-end';
+    event: HookResultEvent;
+};
+declare class FatalReporterError extends Error {
+    readonly fatal = true;
+    constructor(message: string, options?: ErrorOptions);
+}
+declare class MultiReporter implements Reporter {
+    private reporters;
+    constructor(reporters: Reporter[]);
+    private handleReporterError;
+    onSuiteStart(suite: SuiteDefinition, context?: RunArtifactReporterContext): Promise<void>;
+    onSuiteEnd(summary: SuiteSummary): Promise<void>;
+    onRunStart(tests: TestDefinition[]): Promise<void>;
+    onTestStart(test: TestDefinition, filePath: string, context?: RunArtifactReporterContext): Promise<void>;
+    onStepStart(step: string, testName: string, context?: StepEventContext): Promise<void>;
+    onStepEnd(result: StepResult, testName: string, context?: StepEventContext): Promise<void>;
+    onTestEnd(result: TestResult): Promise<void>;
+    onRunEnd(summary: RunSummary): Promise<void>;
+    onStepPhase(phase: StepPhaseEvent, stepName: string, testName: string, context?: StepEventContext): Promise<void>;
+    onHookStart(event: HookEvent): Promise<void>;
+    onHookEnd(event: HookResultEvent): Promise<void>;
+}
+
+type HookRuntime = 'node' | 'bun' | 'python' | 'bash';
+interface HookDefinition {
+    id: string;
+    name: string;
+    runtime: HookRuntime;
+    file: string;
+    deps: string[];
+    packageFile?: string;
+    timeout: number;
+    network: boolean;
+}
+interface HookResult {
+    success: boolean;
+    variables: Record<string, string>;
+    output: string;
+    stdout: string;
+    stderr: string;
+    duration: number;
+    error?: string;
+}
+declare const RUNTIME_IMAGE_MAP: Record<HookRuntime, string>;
+
+interface SandboxRunnerOptions {
+    dockerBin?: string;
+    pullPolicy?: 'always' | 'if-not-present' | 'never';
+    envVars?: Record<string, string>;
+    secretStore?: SecretStore;
+    secretRedactor?: SecretRedactor;
+}
+declare function checkDockerAvailable(dockerBin?: string): Promise<boolean>;
+declare function runHookInSandbox(hook: HookDefinition, options?: SandboxRunnerOptions): Promise<HookResult>;
+
+interface RunTestConfig {
+    runId?: string;
+    parentRunId?: string | null;
+    adapter: PlatformAdapter;
+    planner: Planner;
+    verifier?: Verifier;
+    cache?: ActionCache;
+    healingConfig: HealingConfig;
+    plannerModel: LanguageModel;
+    verifierModel: LanguageModel;
+    reporters?: Reporter[];
+    captureScreenshots?: boolean;
+    screenshotMode?: 'failure' | 'every-step';
+    timeouts?: {
+        step?: number;
+        test?: number;
+        navigation?: number;
+    };
+    recording?: {
+        enabled: boolean;
+        videoDir: string;
+        videoSize?: {
+            width: number;
+            height: number;
+        };
+    };
+    accessibility?: {
+        enabled: boolean;
+        standard?: 'wcag2a' | 'wcag2aa' | 'wcag2aaa';
+        runAfter?: 'every-step' | 'navigation' | 'test-end';
+        failOnViolation?: boolean;
+        disableRules?: string[];
+        exclude?: string[];
+    };
+    plannerConfig?: PlannerConfig;
+    logger?: LogManager;
+    configContent?: string;
+    testFileContent?: string;
+    envFileVars?: Record<string, string>;
+    inlineVars?: Record<string, string>;
+    suiteVars?: Record<string, string>;
+    cliVars?: Record<string, string>;
+    hookSetupVars?: Record<string, string>;
+    inlineHookDefs?: Map<string, HookDefinition>;
+    inlineHookSandboxOptions?: SandboxRunnerOptions;
+    suiteFileContent?: string;
+    suiteTestIndex?: number;
+    suiteContext?: string;
+    logCapture?: {
+        console?: boolean;
+        network?: boolean;
+    };
+    screenshotSize?: number;
+    effectiveResolution?: number;
+    contextWindow?: number;
+    memoryProvider?: MemoryProvider;
+    memoryInitParams?: MemoryIndexParams;
+    circuitBreaker?: CircuitBreaker;
+    skipReporterOnTestStart?: boolean;
+    secretStore?: SecretStore;
+    secretRedactor?: SecretRedactor;
+    secretsFileMetadata?: {
+        path: string | null;
+        status: string;
+        count?: number;
+    } | null;
+}
+declare function runTest(test: TestDefinition, config: RunTestConfig, filePath: string, failureContext?: string): Promise<TestResult>;
+declare function runTestWithRetry(test: TestDefinition, config: RunTestConfig, filePath: string): Promise<TestResult>;
+
+interface InlineHookCall {
+    hookId: string;
+    fullMatch: string;
+}
+declare function parseHookInline(text: string): InlineHookCall[];
+declare function stripHookInline(text: string): string;
+
+declare function generateFailureSummary(steps: StepResult[]): string;
+
+declare const ExtractionResultSchema: z.ZodObject<{
+    value: z.ZodString;
+    reasoning: z.ZodString;
+}, z.core.$strip>;
+type VariableSource = 'env' | 'inline' | 'suite' | 'cli' | 'capture' | 'hook' | 'step';
+declare class VariableStore {
+    private storage;
+    set(name: string, value: string, source?: VariableSource): void;
+    get(name: string): string | undefined;
+    has(name: string): boolean;
+    getSource(name: string): VariableSource | undefined;
+    getAll(): Map<string, string>;
+    setAll(vars: Record<string, string>, source?: VariableSource): void;
+    snapshot(): Record<string, {
+        value: string;
+        source: VariableSource;
+    }>;
+}
+declare function parseEnvFile(content: string): Record<string, string>;
+declare function serializeEnvFile(vars: Record<string, string>): string;
+declare function interpolateVariables(template: string, store: VariableStore): string;
+interface UnresolvedTemplate {
+    pattern: string;
+    message: string;
+}
+declare function findUnresolvedTemplates(text: string): UnresolvedTemplate[];
+declare function findBareVariables(text: string): string[];
+declare class ExplicitExtractor implements VariableExtractor {
+    extract(input: ExtractorInput, screenState: ScreenState): Promise<CaptureResult>;
+    private extractByRegex;
+    private extractBySelector;
+}
+declare class LLMVariableExtractor implements VariableExtractor {
+    private model;
+    constructor(model: LanguageModel);
+    extract(input: ExtractorInput, screenState: ScreenState): Promise<CaptureResult>;
+}
+declare function createExtractor(model?: LanguageModel, method?: string): VariableExtractor;
+
+declare class FileActionCache implements ActionCache {
+    private dir;
+    private ttlMs;
+    private logger?;
+    constructor(config: {
+        dir: string;
+        ttl: number | string;
+        logger?: ScopedLogger;
+    });
+    get(stepHash: string, screenHash: string): Promise<ActionPlan | null>;
+    set(stepHash: string, screenHash: string, plan: ActionPlan, metadata?: {
+        model: string;
+        provider: string;
+        stepInstruction: string;
+    }): Promise<void>;
+    invalidate(stepHash: string, screenHash: string): Promise<void>;
+    getSubAction(stepHash: string, index: number): Promise<ActionPlan | null>;
+    setSubAction(stepHash: string, index: number, plan: ActionPlan): Promise<void>;
+    invalidateSubActionsFrom(stepHash: string, fromIndex: number): Promise<void>;
+    private buildPath;
+}
+declare function parseTTL(ttl: string): number;
+
+declare class NullActionCache implements ActionCache {
+    get(_stepHash: string, _screenHash: string): Promise<ActionPlan | null>;
+    set(_stepHash: string, _screenHash: string, _plan: ActionPlan): Promise<void>;
+    invalidate(_stepHash: string, _screenHash: string): Promise<void>;
+    getSubAction(_stepHash: string, _index: number): Promise<ActionPlan | null>;
+    setSubAction(_stepHash: string, _index: number, _plan: ActionPlan): Promise<void>;
+    invalidateSubActionsFrom(_stepHash: string, _fromIndex: number): Promise<void>;
+}
+
+declare const CACHE_SCHEMA_VERSION = 9;
+interface CacheEntry {
+    schemaVersion?: number;
+    stepInstruction: string;
+    stepHash: string;
+    screenHash: string;
+    plan: ActionPlan;
+    createdAt: string;
+    model: string;
+    provider: string;
+}
+
+interface ConsoleReporterOptions {
+    verbose?: boolean;
+    colorize?: boolean;
+    logLevel?: string;
+    plain?: boolean;
+}
+declare class ConsoleReporter implements Reporter {
+    private verbose;
+    private colorize;
+    private plain;
+    private inSuite;
+    private hookPhaseStarted;
+    private lastHookPhase;
+    private canOverwrite;
+    private stepsPassed;
+    private stepsFailed;
+    private stepsSkipped;
+    private cacheHits;
+    private cacheMisses;
+    private lastWriteLen;
+    constructor(options?: ConsoleReporterOptions);
+    private c;
+    private stripAnsi;
+    private clearWrappedLines;
+    private writeLine;
+    private printLine;
+    private testBadge;
+    private resetCounters;
+    private formatStepsLine;
+    private formatCacheLine;
+    onSuiteStart(suite: SuiteDefinition): void;
+    onRunStart(tests: TestDefinition[]): void;
+    onTestStart(test: TestDefinition, filePath: string): void;
+    onStepStart(step: string, _testName: string): void;
+    onStepEnd(result: StepResult, _testName: string): void;
+    onHookStart(event: HookEvent): void;
+    onHookEnd(event: HookResultEvent): void;
+    onTestEnd(result: TestResult): void;
+    onRunEnd(summary: RunSummary): void;
+    onSuiteEnd(summary: SuiteSummary): void;
+    private printStandaloneSummary;
+    private printFailedTests;
+    private statusIcon;
+}
+
+interface JUnitReporterOptions {
+    outputPath: string;
+}
+declare class JUnitReporter implements Reporter {
+    private outputPath;
+    private results;
+    private inSuiteRun;
+    constructor(options: JUnitReporterOptions);
+    onSuiteStart(_suite: SuiteDefinition): void;
+    onTestEnd(result: TestResult): void;
+    onRunEnd(summary: RunSummary): Promise<void>;
+    onSuiteEnd(summary: SuiteSummary): Promise<void>;
+    private writeXml;
+    private buildXml;
+    private buildSuiteXml;
+    private buildTestCase;
+    private getFailureMessage;
+    private buildFailureDetails;
+    private buildStepSummary;
+}
+
+declare function captureFailureScreenshot(adapter: PlatformAdapter): Promise<Buffer | undefined>;
+
+interface StdoutLiveReporterOptions {
+    active?: boolean;
+    redactor?: SecretRedactor;
+}
+declare class StdoutLiveReporter implements Reporter {
+    private active;
+    private heartbeatInterval;
+    private activeRunId;
+    private activeParentRunId;
+    private activeSuiteIndex;
+    private redactor?;
+    constructor(options?: StdoutLiveReporterOptions);
+    private emit;
+    private withRunId;
+    private withRunContext;
+    onTestStart(test: TestDefinition, filePath: string, context?: RunArtifactReporterContext): void;
+    onStepStart(step: string, testName: string, context?: StepEventContext): void;
+    onStepEnd(result: StepResult, testName: string, context?: StepEventContext): void;
+    onStepPhase(phase: StepPhaseEvent, stepName: string, testName: string, context?: StepEventContext): void;
+    onHookStart(event: HookEvent): void;
+    onHookEnd(event: HookResultEvent): void;
+    onTestEnd(result: TestResult): void;
+}
+
+interface MobileNode {
+    index: number;
+    type: string;
+    label?: string;
+    value?: string;
+    bounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    enabled?: boolean;
+    children: MobileNode[];
+}
+type MobileRefMap = Record<string, {
+    role: string;
+    name?: string;
+    nth?: number;
+    bounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    nativeType?: string;
+    value?: string;
+}>;
+interface ParsedMobileTree {
+    tree: string;
+    elements: ElementInfo[];
+    refs: MobileRefMap;
+}
+
+declare function parseMobileSource(xml: string, platform: 'android' | 'ios', viewport?: {
+    width: number;
+    height: number;
+}): ParsedMobileTree;
+
+declare const ANDROID_ROLE_MAP: Record<string, string>;
+declare const IOS_ROLE_MAP: Record<string, string>;
+declare function normalizeRole(type: string, platform: 'android' | 'ios'): string;
+
+declare class MobileElementResolver {
+    private refs;
+    constructor(refs: MobileRefMap);
+    resolve(ref: string): {
+        role: string;
+        name?: string;
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        center: {
+            x: number;
+            y: number;
+        };
+    };
+    resolveAction(action: Action): {
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        center: {
+            x: number;
+            y: number;
+        };
+    } | null;
+}
+
+declare const KEY_MAP: Record<string, string>;
+declare function computePinch(centerX: number, centerY: number, scale: number, startDistance?: number): {
+    finger1Start: {
+        x: number;
+        y: number;
+    };
+    finger1End: {
+        x: number;
+        y: number;
+    };
+    finger2Start: {
+        x: number;
+        y: number;
+    };
+    finger2End: {
+        x: number;
+        y: number;
+    };
+};
+declare function computeFingerPositions(centerX: number, centerY: number, fingers: number, spacing?: number): {
+    x: number;
+    y: number;
+}[];
+declare function computeSwipe(centerX: number, centerY: number, direction: 'up' | 'down' | 'left' | 'right', distance: number): {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+};
+
+type MobilePlatform = 'android' | 'ios';
+type MobileTransport = 'local' | 'browserstack';
+type MobileAppState = 'preserve' | 'reset';
+type MobileSetupErrorCategory = 'device-resolution' | 'appium-startup' | 'device-readiness' | 'adapter-load' | 'app-install' | 'app-launch';
+interface MobileSetupErrorOptions {
+    category: MobileSetupErrorCategory;
+    message: string;
+    platform?: MobilePlatform;
+    targetName?: string;
+    deviceName?: string;
+    appId?: string;
+    cause?: unknown;
+    sourceTrace?: string[];
+}
+declare class MobileSetupError extends Error {
+    readonly category: MobileSetupErrorCategory;
+    readonly platform?: MobilePlatform;
+    readonly targetName?: string;
+    readonly deviceName?: string;
+    readonly appId?: string;
+    readonly sourceTrace?: string[];
+    readonly cause?: unknown;
+    constructor(options: MobileSetupErrorOptions);
+}
+interface ResolvedMobileDevice {
+    name: string;
+    platform: MobilePlatform;
+    transport: MobileTransport;
+    match: Record<string, unknown>;
+}
+interface ResolvedMobileAppInstall {
+    path?: string;
+    browserstack?: string;
+    browserstackBaseDir?: string;
+    sourceTrace: Record<string, string>;
+}
+interface ResolvedMobileApp {
+    bundleId?: string;
+    appPackage?: string;
+    appActivity?: string;
+    deepLinkAppId?: string;
+    install?: ResolvedMobileAppInstall;
+    sourceTrace: Record<string, string>;
+}
+interface ResolvedMobileRunConfig {
+    platform: MobilePlatform;
+    targetName: string;
+    deviceName: string;
+    transport: MobileTransport;
+    device: ResolvedMobileDevice;
+    app: ResolvedMobileApp;
+    appState: MobileAppState;
+    appium: {
+        url?: string;
+        managed?: boolean;
+    };
+    sourceTrace: string[];
+}
+interface ResolveMobileRunConfigInput {
+    config: Record<string, any>;
+    targetName: string;
+    platform?: MobilePlatform;
+    explicitDeviceName?: string;
+    useDeviceName?: string;
+    appState?: MobileAppState;
+    localBindings?: {
+        devices?: Record<string, Record<string, unknown>>;
+        apps?: Record<string, {
+            path?: string;
+            browserstack?: string;
+        }>;
+        filePath?: string;
+    } | null;
+    configFilePath?: string;
+    localConfigFilePath?: string;
+    appiumUrl?: string;
+}
+declare function resolveMobileRunConfig(input: ResolveMobileRunConfigInput): ResolvedMobileRunConfig;
+
+type AuthProvider = string;
+type LLMModelAdapter = 'openai-responses' | 'anthropic-messages';
+type BuiltInLLMProviderMode = 'openai-compatible' | 'anthropic-compatible' | 'openai-subscription' | 'anthropic-subscription' | 'gemini';
+type LLMProviderMode = BuiltInLLMProviderMode | (string & {});
+interface OAuthTokens {
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+}
+type AuthCredential = {
+    type: 'oauth';
+    provider: AuthProvider;
+    tokens: OAuthTokens;
+} | {
+    type: 'api';
+    provider: string;
+    key: string;
+} | {
+    type: 'bearer';
+    provider: string;
+    token: string;
+};
+type AuthStore = Record<string, AuthCredential>;
+type ResolvedLLMAuth = {
+    kind: 'api-key';
+    credentialKey: string;
+    provider: BuiltInLLMProviderMode;
+    apiKey: string;
+} | {
+    kind: 'bearer-token';
+    credentialKey: string;
+    provider: 'anthropic-compatible';
+    token: string;
+} | {
+    kind: 'auth-fetch';
+    credentialKey: string;
+    provider: string;
+    modelAdapter: LLMModelAdapter;
+    fetch: typeof globalThis.fetch;
+    expires?: number;
+} | {
+    kind: 'unauthenticated';
+    credentialKey: string;
+    provider: 'openai-compatible' | 'anthropic-compatible';
+    optional: true;
+    message: string;
+} | {
+    kind: 'missing';
+    credentialKey: string;
+    provider: string;
+    required: true;
+    message: string;
+};
+type TokenRefreshFn = (provider: AuthProvider, refreshToken: string) => Promise<OAuthTokens>;
+
+declare function getAuthPath(): string;
+declare function readAuth(path?: string): Promise<AuthStore>;
+declare function writeAuth(provider: string, credential: AuthCredential, path?: string): Promise<void>;
+declare function removeAuth(provider: string, path?: string): Promise<void>;
+declare function getCredential(provider: string, path?: string): Promise<AuthCredential | null>;
+
+interface LLMAuthConfig {
+    provider: LLMProviderMode | string;
+    model: string;
+    baseURL?: string;
+    providerHeaders?: Record<string, string>;
+}
+declare function resolveLLMAuth(configName: string, llmConfig: LLMAuthConfig, authPath?: string): Promise<ResolvedLLMAuth>;
+
+type DashboardAuthMode = 'browser-poll' | 'manual-code';
+interface DashboardAuthMetadata {
+    mode: DashboardAuthMode;
+    buttonLabel?: string;
+}
+interface StartAuthContext {
+    configName: string;
+    callbackUrl?: string;
+}
+interface StartAuthResult {
+    authorizeUrl: string;
+    sessionState?: unknown;
+    waitForTokens?: Promise<OAuthTokens>;
+    cleanup?: () => void;
+}
+interface ExchangeCodeContext {
+    code: string;
+    sessionState: unknown;
+}
+interface CreateAuthFetchContext {
+    getTokens: () => Promise<OAuthTokens>;
+    onRefreshed: (tokens: OAuthTokens) => Promise<void>;
+}
+interface LLMAuthProviderPlugin {
+    providerId: string;
+    credentialProviderId: string;
+    label: string;
+    modelAdapter: LLMModelAdapter;
+    dashboardAuth: DashboardAuthMetadata;
+    startAuth?: (ctx: StartAuthContext) => Promise<StartAuthResult>;
+    exchangeCode?: (ctx: ExchangeCodeContext) => Promise<OAuthTokens>;
+    createAuthFetch: (ctx: CreateAuthFetchContext) => typeof globalThis.fetch;
+}
+declare function registerLLMAuthProviderPlugin(plugin: LLMAuthProviderPlugin): void;
+declare function registerLLMAuthProviderPlugins(providerPlugins: LLMAuthProviderPlugin[]): void;
+declare function getLLMAuthProviderPlugin(providerId: string): LLMAuthProviderPlugin | undefined;
+declare function listLLMAuthProviderPlugins(): LLMAuthProviderPlugin[];
+declare function clearLLMAuthProviderPlugins(): void;
+
+type AuthPluginDeclaration = {
+    package: string;
+    path?: never;
+} | {
+    path: string;
+    package?: never;
+};
+interface AuthPluginBundle {
+    providers: LLMAuthProviderPlugin[];
+}
+interface LoadLLMAuthPluginsOptions {
+    baseDir?: string;
+}
+declare function loadLLMAuthPlugins(declarations: AuthPluginDeclaration[] | undefined, options?: LoadLLMAuthPluginsOptions): Promise<LLMAuthProviderPlugin[]>;
+declare function clearLoadedLLMAuthPluginModules(): void;
+
+declare function generatePKCE(): {
+    verifier: string;
+    challenge: string;
+};
+declare function generateState(): string;
+
+interface CreateAuthFetchOptions {
+    provider: AuthProvider;
+    getTokens: () => Promise<OAuthTokens>;
+    refreshTokens: TokenRefreshFn;
+    onTokensRefreshed: (tokens: OAuthTokens) => Promise<void>;
+    headerTransform?: (headers: Headers, tokens: OAuthTokens) => void;
+    urlTransform?: (url: string) => string;
+}
+declare function createAuthFetch(options: CreateAuthFetchOptions): typeof globalThis.fetch;
+
+declare function formatLogEntry(entry: LogEntry): string;
+
+interface FarmProvider {
+    readonly name: string;
+    readonly slug: string;
+    resolveWebEndpoint(config: FarmWebConfig): Promise<{
+        wsEndpoint: string;
+        capabilities: Record<string, unknown>;
+    }>;
+    resolveMobileCapabilities(config: FarmMobileConfig): Promise<{
+        hostname: string;
+        port: number;
+        path: string;
+        capabilities: Record<string, unknown>;
+    }>;
+    resolveCredentials(providerConfig?: FarmProviderConfig): {
+        username: string;
+        accessKey: string;
+    };
+    validateDevice(deviceName: string, platform: 'android' | 'ios'): Promise<{
+        valid: boolean;
+        suggestions?: string[];
+    }>;
+    getSessionUrl(sessionId: string, type: 'web' | 'mobile'): string;
+}
+interface FarmWebConfig {
+    browser: BrowserConfig;
+    credentials: {
+        username: string;
+        accessKey: string;
+    };
+    testName?: string;
+    playwrightVersion?: string;
+}
+interface FarmMobileConfig {
+    match: Record<string, unknown>;
+    platform: 'android' | 'ios';
+    credentials: {
+        username: string;
+        accessKey: string;
+    };
+    testName?: string;
+    testTimeout?: number;
+    app?: string;
+    appState?: 'preserve' | 'reset';
+    appBaseDir?: string;
+    appSourceTrace?: string[];
+}
+interface FarmProviderConfig {
+    username?: string;
+    accessKey?: string;
+}
+
+declare function registerProvider(provider: FarmProvider): void;
+declare function getProvider(slug: string): FarmProvider | undefined;
+declare function listProviders(): FarmProvider[];
+declare function registerAllProviders(): void;
+
+declare function resolveFarmCredentials(provider: string, providerConfig?: FarmProviderConfig): {
+    username: string;
+    accessKey: string;
+};
+
+declare function detectPlaywrightVersion(): string;
+declare function mapWebCapabilities(browser: BrowserConfig, credentials: {
+    username: string;
+    accessKey: string;
+}, opts?: {
+    testName?: string;
+    playwrightVersion?: string;
+}): Record<string, unknown>;
+declare function mapMobileCapabilities(match: Record<string, unknown>, platform: 'android' | 'ios', credentials: {
+    username: string;
+    accessKey: string;
+}, opts?: {
+    testName?: string;
+    testTimeout?: number;
+}): Record<string, unknown>;
+
+declare const browserstackProvider: FarmProvider;
+
+interface MemoryLog {
+    added: number;
+    confirmed: number;
+    deprecated: number;
+    deleted: number;
+    deltas: MemoryDelta[];
+    errors: string[];
+    curatorDuration: number;
+    tokenUsage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+type MemoryDeltaAction = 'add' | 'confirm' | 'deprecate' | 'delete';
+interface MemoryObservationSnapshot {
+    id: string;
+    title: string;
+    content: string;
+    trust: number;
+    created: string;
+    last_confirmed: string;
+    confirmed_count: number;
+    contradicted_count: number;
+    source_test: string;
+    position?: number;
+    suite_snapshot?: Array<{
+        test: string;
+        id: string;
+    }>;
+}
+interface MemoryDelta {
+    action: MemoryDeltaAction;
+    tier: 'products' | 'suites' | 'tests';
+    scope: string;
+    observationId: string;
+    reasoning: string;
+    before: MemoryObservationSnapshot | null;
+    after: MemoryObservationSnapshot | null;
+    error?: string;
+}
+interface CuratorContext {
+    testResult: TestResult;
+    provider: MemoryProvider;
+    model: LanguageModel;
+    providerOptions?: ProviderOptions;
+    memoryRoot: string;
+    product: string;
+    testId: string;
+    suiteId?: string;
+    suiteContext?: {
+        tests: Array<{
+            test: string;
+            id: string;
+        }>;
+        position: number;
+    };
+    injectedObservationIds: Map<number, string[]>;
+    trustConfirmDelta?: number;
+    trustContradictDelta?: number;
+}
+declare const CuratorResponseSchema: z.ZodObject<{
+    decisions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"add">;
+        title: z.ZodString;
+        content: z.ZodString;
+        scope: z.ZodEnum<{
+            test: "test";
+            product: "product";
+            suite: "suite";
+        }>;
+        reasoning: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"update">;
+        observationId: z.ZodString;
+        reasoning: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"deprecate">;
+        observationId: z.ZodString;
+        reasoning: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"noop">;
+        reasoning: z.ZodString;
+    }, z.core.$strip>], "action">>;
+}, z.core.$strip>;
+declare function runCurator(ctx: CuratorContext): Promise<MemoryLog>;
+declare function deprecateOnFailure(ctx: Pick<CuratorContext, 'testResult' | 'provider' | 'memoryRoot' | 'injectedObservationIds' | 'trustContradictDelta'>): Promise<MemoryLog>;
+
+interface RunSuiteConfig {
+    runId?: string;
+    adapter: PlatformAdapter;
+    platformConfig: PlatformConfig;
+    planner: Planner;
+    verifier?: Verifier;
+    cache?: ActionCache;
+    healingConfig: HealingConfig;
+    plannerModel: LanguageModel;
+    verifierModel: LanguageModel;
+    providerOptions?: ProviderOptions;
+    reporters?: Reporter[];
+    captureScreenshots?: boolean;
+    screenshotMode?: 'failure' | 'every-step';
+    timeouts?: {
+        step?: number;
+        test?: number;
+        navigation?: number;
+    };
+    logger?: LogManager;
+    configContent?: string;
+    suiteFileContent?: string;
+    envFileVars?: Record<string, string>;
+    inlineVars?: Record<string, string>;
+    cliVars?: Record<string, string>;
+    resolvedHooks?: Map<string, HookDefinition>;
+    sandboxOptions?: SandboxRunnerOptions;
+    logCapture?: {
+        console?: boolean;
+        network?: boolean;
+    };
+    screenshotSize?: number;
+    effectiveResolution?: number;
+    memoryProvider?: MemoryProvider;
+    memoryRoot?: string;
+    memoryConfig?: {
+        enabled?: boolean;
+        curatorEnabled?: boolean;
+        ablationEnabled?: boolean;
+        trustConfirmDelta?: number;
+        trustContradictDelta?: number;
+    };
+    circuitBreaker?: CircuitBreaker;
+    product?: string;
+    createAdapter?: () => Promise<PlatformAdapter>;
+    resolveUrl?: (targetName: string) => string | undefined;
+    onCuratorComplete?: (testName: string, memoryLog: MemoryLog) => void;
+    artifactContext?: Record<string, unknown>;
+    secretStore?: SecretStore;
+    secretRedactor?: SecretRedactor;
+}
+declare function runSuite(suite: SuiteDefinition, testEntries: [TestDefinition, string][], config: RunSuiteConfig): Promise<SuiteResult>;
+
+type WorkspaceFileKind = 'test' | 'suite';
+interface ResolvedWorkspaceFile {
+    configuredPath: string;
+    absolutePath: string;
+    workspaceRelativePath: string;
+}
+interface WorkspaceFileRecord {
+    kind: WorkspaceFileKind;
+    absolutePath: string;
+    workspaceRelativePath: string;
+}
+interface ResolvedWorkspacePaths {
+    configPath: string;
+    configDir: string;
+    testMatch: string[];
+    suiteMatch: string[];
+    testPathIgnore: string[];
+    hooksFile: ResolvedWorkspaceFile;
+    agentRules: ResolvedWorkspaceFile;
+    envFile: ResolvedWorkspaceFile;
+    secretsFile: ResolvedWorkspaceFile;
+}
+interface ResolveWorkspacePathsInput {
+    config: AgentQaConfig;
+    configPath: string;
+    requireExistingFiles?: boolean;
+}
+declare function resolveWorkspacePaths(input: ResolveWorkspacePathsInput): ResolvedWorkspacePaths;
+declare function discoverWorkspaceFiles(input: {
+    workspace: ResolvedWorkspacePaths;
+    kind: WorkspaceFileKind;
+}): Promise<WorkspaceFileRecord[]>;
+declare function resolveWorkspaceFileTarget(input: {
+    workspace: ResolvedWorkspacePaths;
+    kind: WorkspaceFileKind;
+    filePath: string;
+    requireExisting?: boolean;
+}): Promise<WorkspaceFileRecord>;
+declare function isWorkspacePathMatch(input: {
+    workspace: ResolvedWorkspacePaths;
+    kind: WorkspaceFileKind;
+    workspaceRelativePath: string;
+}): boolean;
+
+interface ValidationDiagnostic {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+    severity: 'error' | 'warning';
+}
+interface ValidationResult {
+    diagnostics: ValidationDiagnostic[];
+    fileCount: number;
+    errorCount: number;
+    warningCount: number;
+}
+declare const VALID_FILENAME_RE: RegExp;
+declare function validateConfig(configPath: string): Promise<ValidationDiagnostic[]>;
+declare function validateTestFile(filePath: string, content: string): ValidationDiagnostic[];
+declare function validateSuiteFile(filePath: string, content: string, basedir: string): ValidationDiagnostic[];
+declare function validateFilename(filePath: string): ValidationDiagnostic[];
+declare function detectGlobOverlap(testMatch: string[], suiteMatch: string[], ignore: string[], cwd?: string): Promise<string[]>;
+declare function validateFiles(filePaths: string[], configPath?: string, options?: {
+    basedir?: string;
+}): Promise<ValidationResult>;
+declare function validateProject(options?: {
+    configPath?: string;
+    files?: string[];
+    testMatch?: string[];
+    testPathIgnore?: string[];
+    suiteMatch?: string[];
+    hooksFile?: string;
+    workspace?: ResolvedWorkspacePaths;
+}): Promise<ValidationResult>;
+
+declare function formatDiagnostics(result: ValidationResult): string;
+declare function formatDiagnosticsPlain(result: ValidationResult): string;
+
+declare function warnIfOutOfBounds(coords: {
+    x?: number;
+    y?: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, actionType: string): void;
+
+declare function parseHooksFile(filePath: string): Promise<{
+    hooks: HookDefinition[];
+    errors: string[];
+}>;
+
+declare const DEFAULT_CLEANUP_TARGETS: readonly [".agent-qa"];
+type CleanupTarget = (typeof DEFAULT_CLEANUP_TARGETS)[number];
+interface HookReferenceRewriteFile {
+    path: string;
+    content: string;
+}
+interface HookReferenceMigrationSuccess {
+    ok: true;
+    hookNameToId: Record<string, string>;
+    rewriteFiles: HookReferenceRewriteFile[];
+    cleanupTargets: CleanupTarget[];
+}
+interface HookReferenceMigrationFailure {
+    ok: false;
+    errors: string[];
+    rewriteFiles: [];
+    cleanupTargets: [];
+}
+type HookReferenceMigrationAudit = HookReferenceMigrationSuccess | HookReferenceMigrationFailure;
+interface HookReferenceMigrationOptions {
+    workspaceDir: string;
+    configPath?: string;
+    generateId?: () => string;
+}
+declare class HookReferenceMigrationError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+declare function auditWorkspaceHookReferenceMigration(options: HookReferenceMigrationOptions): Promise<HookReferenceMigrationAudit>;
+declare function applyWorkspaceHookReferenceMigration(options: HookReferenceMigrationOptions): Promise<HookReferenceMigrationSuccess>;
+
+interface HookOrchestrationResult {
+    results: Map<string, HookResult>;
+    variables: Record<string, string>;
+    allPassed: boolean;
+    duration: number;
+}
+declare function runHooks(hooks: HookDefinition[], options?: SandboxRunnerOptions): Promise<HookOrchestrationResult>;
+
+interface ObservationFrontmatter {
+    id: string;
+    title: string;
+    trust: number;
+    created: string;
+    last_confirmed: string;
+    confirmed_count: number;
+    contradicted_count: number;
+    source_test: string;
+}
+interface SuiteObservationFrontmatter extends ObservationFrontmatter {
+    position: number;
+    suite_snapshot: Array<{
+        test: string;
+        id: string;
+    }>;
+}
+
+declare function ensureMemoryDirs(root: string): Promise<void>;
+declare function writeObservation(root: string, tier: 'products' | 'suites' | 'tests', scope: string, data: BaseObservation | SuiteObservation): Promise<string>;
+declare function parseObservation(content: string, filename: string): {
+    data: BaseObservation | SuiteObservation | null;
+    error: string | null;
+};
+declare function listObservations(dir: string): Promise<string[]>;
+
+declare function scanContent(text: string): {
+    safe: boolean;
+    matchedPattern?: string;
+};
+
+declare function escapeXml(str: string): string;
+
+declare function createMemoryProvider(config: {
+    provider: string;
+    memoryRoot?: string;
+    curatorLockTimeout?: number;
+}): Promise<MemoryProvider>;
+
+declare class LocalMemoryProvider implements MemoryProvider {
+    private db;
+    private minTrust;
+    private maxInjections;
+    private injectedMap;
+    private memoryRoot;
+    private lockManager;
+    constructor(opts?: {
+        memoryRoot?: string;
+        minTrust?: number;
+        maxInjections?: number;
+        curatorLockTimeout?: number;
+    });
+    init(params: MemoryIndexParams): Promise<void>;
+    queryForStep(stepText: string, stepIndex: number): MemoryQueryResult | null;
+    private formatMemoryContext;
+    destroy(): void;
+    getInjectedObservations(stepIndex: number): string[];
+    acquireLock(): Promise<void>;
+    releaseLock(): Promise<void>;
+    writeObservation(tier: 'products' | 'suites' | 'tests', scope: string, data: BaseObservation | SuiteObservation): Promise<string>;
+    deleteObservation(tier: 'products' | 'suites' | 'tests', scope: string, id: string): Promise<void>;
+    getAllObservations(): MemoryObservationSnippet[];
+    searchForDuplicates(content: string): MemoryObservationSnippet[];
+    getRunAnalytics(): unknown;
+}
+
+declare const DEFAULT_MEMORY_DIR = "agent-qa-memory";
+interface MemoryRootConfig {
+    services?: {
+        memory?: {
+            dir?: string;
+        };
+    };
+}
+declare function resolveMemoryRoot(config: MemoryRootConfig | undefined, configDir: string): string;
+
+declare class LockManager {
+    private lockPath;
+    private timeout;
+    constructor(lockPath: string, timeout?: number);
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    private isStale;
+}
+
+declare function shouldAblate(result: {
+    status: string;
+    steps: Array<unknown>;
+}, provider: MemoryProvider): boolean;
+declare function collectAllInjectedIds(result: {
+    steps: Array<unknown>;
+}, provider: MemoryProvider): Map<number, string[]>;
+
+declare function generateRunId(): string;
+
+type AnalyticsRuntimeContext = 'user' | 'ci' | 'agent';
+type AnalyticsAgentProduct = 'claude_code' | 'cursor' | 'gemini_cli' | 'augment' | 'goose' | 'opencode' | 'codex' | 'cline' | 'amp';
+interface AnalyticsIdentity {
+    distinctId: string;
+    runtimeContext: AnalyticsRuntimeContext;
+    agentProduct?: AnalyticsAgentProduct;
+    isInternal?: boolean;
+}
+interface AnalyticsIdentityStore {
+    distinctId: string;
+    is_internal: boolean;
+}
+interface ResolveAnalyticsIdentityOptions {
+    env?: Record<string, string | undefined>;
+    identityPath?: string;
+    homeDir?: string;
+}
+declare function getAnalyticsIdentityPath(env?: Record<string, string | undefined>, homeDir?: string): string;
+declare function generateAnalyticsUserId(): string;
+declare function readAnalyticsIdentity(path?: string): Promise<AnalyticsIdentityStore | null>;
+declare function writeAnalyticsIdentity(distinctId: string, path?: string, isInternal?: boolean): Promise<void>;
+declare function resolveAnalyticsAgentProduct(env?: Record<string, string | undefined>): AnalyticsAgentProduct | undefined;
+declare function resolveAnalyticsIdentity(options?: ResolveAnalyticsIdentityOptions): Promise<AnalyticsIdentity>;
+
+type AnalyticsEventName = 'agent-qa.analytics.initialized' | 'agent-qa.analytics.test_event' | 'agent-qa.test_run.completed' | 'agent-qa.suite_run.completed' | 'agent-qa.dashboard.opened' | 'agent-qa.dashboard.live_mode.started' | 'agent-qa.dashboard.entity.created' | 'agent-qa.mcp.server.lifecycle' | 'agent-qa.mcp.tool.invoked';
+type AnalyticsSurface = 'core' | 'cli' | 'dashboard-server' | 'dashboard-ui' | 'mcp';
+type AnalyticsTransportKind = 'posthog' | 'noop' | 'mock';
+interface AnalyticsEventProperties {
+    agent_qa_version?: string;
+    surface?: AnalyticsSurface;
+    runtime_context?: AnalyticsRuntimeContext;
+    agent_product?: AnalyticsAgentProduct;
+    transport?: AnalyticsTransportKind;
+    privacy_enabled?: boolean;
+    posthog_key_present?: boolean;
+    trigger_source?: 'cli' | 'dashboard' | 'api' | 'mcp' | 'unknown';
+    runner?: 'local' | 'browserstack' | 'unknown';
+    platform?: 'web' | 'android' | 'ios' | 'unknown';
+    entity_type?: 'test' | 'suite' | 'hook' | 'unknown';
+    outcome?: 'created';
+    status?: 'passed' | 'failed' | 'skipped' | 'cancelled' | 'timeout' | 'unknown';
+    duration_ms?: number;
+    run_id?: string;
+    parent_run_id?: string;
+    test_id?: string;
+    suite_id?: string;
+    model_name?: string;
+    provider?: string;
+    provider_mode?: string;
+    planner_model?: string;
+    verifier_model?: string;
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    planner_call_count?: number;
+    verifier_call_count?: number;
+    step_count?: number;
+    passed_step_count?: number;
+    failed_step_count?: number;
+    skipped_step_count?: number;
+    subaction_count?: number;
+    cached_subaction_count?: number;
+    failed_subaction_count?: number;
+    healing_attempt_count?: number;
+    hook_count?: number;
+    failed_hook_count?: number;
+    retry_count?: number;
+    is_flaky?: boolean;
+    cancelled?: boolean;
+    timed_out?: boolean;
+    failure_category?: 'assertion' | 'timeout' | 'cancelled' | 'setup' | 'hook' | 'appium' | 'browser_install' | 'llm_context' | 'llm_provider' | 'memory' | 'framework' | 'unknown';
+    browser_name?: string;
+    mobile_transport?: string;
+    mobile_provider?: string;
+    app_state?: string;
+    execution_destination?: string;
+    memory_enabled?: boolean;
+    memory_injected_observation_count?: number;
+    memory_curator_input_tokens?: number;
+    memory_curator_output_tokens?: number;
+    memory_curator_total_tokens?: number;
+    memory_added_count?: number;
+    memory_confirmed_count?: number;
+    memory_deprecated_count?: number;
+    memory_deleted_count?: number;
+    memory_error_count?: number;
+    suite_child_count?: number;
+    suite_passed_count?: number;
+    suite_failed_count?: number;
+    suite_skipped_count?: number;
+    suite_execution_mode?: 'sequential' | 'parallel' | 'unknown';
+    mcp_tool_count?: number;
+    mcp_server_state?: 'started' | 'disabled';
+    mcp_transport?: 'stdio' | 'http';
+    mcp_host_kind?: 'loopback' | 'other';
+    mcp_port_kind?: 'default' | 'custom';
+    mcp_path_kind?: 'default' | 'custom';
+    tool_name?: string;
+    mcp_tool_category?: 'discovery' | 'schema' | 'id' | 'authoring' | 'hook' | 'run' | 'triage' | 'unknown';
+    mcp_tool_status?: 'success' | 'error';
+    mcp_error_category?: 'validation' | 'dashboard_unavailable' | 'dashboard_error' | 'config' | 'tool_error' | 'unknown';
+    '$process_person_profile'?: false;
+}
+type BuiltAnalyticsEventProperties = Record<string, string | number | boolean | undefined>;
+interface AnalyticsEventInput {
+    name: AnalyticsEventName | string;
+    properties?: Record<string, unknown>;
+}
+interface BuiltAnalyticsEvent {
+    name: AnalyticsEventName;
+    properties: BuiltAnalyticsEventProperties;
+}
+
+declare const ANALYTICS_EVENT_NAMES: readonly ["agent-qa.analytics.initialized", "agent-qa.analytics.test_event", "agent-qa.test_run.completed", "agent-qa.suite_run.completed", "agent-qa.dashboard.opened", "agent-qa.dashboard.live_mode.started", "agent-qa.dashboard.entity.created", "agent-qa.mcp.server.lifecycle", "agent-qa.mcp.tool.invoked"];
+declare const ANALYTICS_SURFACES: readonly ["core", "cli", "dashboard-server", "dashboard-ui", "mcp"];
+declare const ANALYTICS_RUNTIME_CONTEXTS: readonly ["user", "ci", "agent"];
+declare const ANALYTICS_AGENT_PRODUCTS: readonly ["claude_code", "cursor", "gemini_cli", "augment", "goose", "opencode", "codex", "cline", "amp"];
+declare const ANALYTICS_TRANSPORT_KINDS: readonly ["posthog", "noop", "mock"];
+declare const ANALYTICS_TRIGGER_SOURCES: readonly ["cli", "dashboard", "api", "mcp", "unknown"];
+declare const ANALYTICS_RUNNERS: readonly ["local", "browserstack", "unknown"];
+declare const ANALYTICS_PLATFORMS: readonly ["web", "android", "ios", "unknown"];
+declare const ANALYTICS_DASHBOARD_ENTITY_TYPES: readonly ["test", "suite", "hook", "unknown"];
+declare const ANALYTICS_DASHBOARD_OUTCOMES: readonly ["created"];
+declare const ANALYTICS_RUN_STATUSES: readonly ["passed", "failed", "skipped", "cancelled", "timeout", "unknown"];
+declare const ANALYTICS_MCP_SERVER_STATES: readonly ["started", "disabled"];
+declare const ANALYTICS_MCP_TRANSPORTS: readonly ["stdio", "http"];
+declare const ANALYTICS_MCP_HOST_KINDS: readonly ["loopback", "other"];
+declare const ANALYTICS_MCP_PORT_KINDS: readonly ["default", "custom"];
+declare const ANALYTICS_MCP_PATH_KINDS: readonly ["default", "custom"];
+declare const ANALYTICS_MCP_TOOL_CATEGORIES: readonly ["discovery", "schema", "id", "authoring", "hook", "run", "triage", "unknown"];
+declare const ANALYTICS_MCP_TOOL_STATUSES: readonly ["success", "error"];
+declare const ANALYTICS_MCP_ERROR_CATEGORIES: readonly ["validation", "dashboard_unavailable", "dashboard_error", "config", "tool_error", "unknown"];
+declare const ANALYTICS_FAILURE_CATEGORIES: readonly ["assertion", "timeout", "cancelled", "setup", "hook", "appium", "browser_install", "llm_context", "llm_provider", "memory", "framework", "unknown"];
+declare const ANALYTICS_SUITE_EXECUTION_MODES: readonly ["sequential", "parallel", "unknown"];
+declare function buildAnalyticsEvent(input: AnalyticsEventInput): BuiltAnalyticsEvent;
+
+interface AnalyticsCapturePayload {
+    distinctId: string;
+    isInternal?: boolean;
+    event: BuiltAnalyticsEvent;
+}
+interface AnalyticsTransport {
+    capture(payload: AnalyticsCapturePayload): void | Promise<void>;
+    flush(): void | Promise<void>;
+}
+declare class NoopAnalyticsTransport implements AnalyticsTransport {
+    capture(): void;
+    flush(): void;
+}
+declare class MockAnalyticsTransport implements AnalyticsTransport {
+    readonly events: AnalyticsCapturePayload[];
+    flushCount: number;
+    capture(payload: AnalyticsCapturePayload): void;
+    flush(): void;
+}
+
+declare const EMPTY_POSTHOG_KEY_WARNING = "PostHog analytics initialization failed because AGENT_QA_POSTHOG_KEY is empty. Analytics telemetry is disabled.";
+interface AnalyticsServiceConfig {
+    analytics?: {
+        privacy?: true;
+    };
+}
+interface AnalyticsPostHogTransportFactoryOptions {
+    projectKey: string;
+    host: string;
+    disableGeoip: false;
+}
+interface AnalyticsServiceOptions {
+    config?: AnalyticsServiceConfig;
+    surface?: AnalyticsSurface;
+    transport?: AnalyticsTransport;
+    warningSink?: (message: string) => void;
+    projectKey?: string;
+    projectHost?: string;
+    identityPath?: string;
+    env?: Record<string, string | undefined>;
+    posthogTransportFactory?: (options: AnalyticsPostHogTransportFactoryOptions) => AnalyticsTransport;
+}
+interface AnalyticsService {
+    capture(event: BuiltAnalyticsEvent): Promise<void>;
+    flush(): Promise<void>;
+}
+interface AnalyticsStandardPropertiesOptions {
+    surface?: AnalyticsSurface;
+    identityPath?: string;
+    env?: Record<string, string | undefined>;
+    agentQaVersion?: string;
+}
+declare function resolveAnalyticsStandardProperties(options?: AnalyticsStandardPropertiesOptions): Promise<AnalyticsEventProperties>;
+declare function createAnalyticsService(options?: AnalyticsServiceOptions): AnalyticsService;
+declare function getAnalyticsService(options?: AnalyticsServiceOptions): AnalyticsService;
+declare function resetAnalyticsServiceForTests(): void;
+declare function captureAnalytics(event: BuiltAnalyticsEvent, options?: AnalyticsServiceOptions): Promise<void>;
+declare function flushAnalytics(options?: AnalyticsServiceOptions): Promise<void>;
+
+declare const AGENT_QA_POSTHOG_KEY = "phc_siDVZ3DEoSCiBSocn2GZMRhx5UcRwekJDVtap5Zteii3";
+declare const AGENT_QA_POSTHOG_HOST = "https://us.i.posthog.com";
+
+interface AnalyticsRunReporterOptions extends Omit<AnalyticsServiceOptions, 'transport'> {
+    surface?: AnalyticsSurface;
+    service?: AnalyticsService;
+    transport?: AnalyticsTransport;
+}
+declare class AnalyticsRunReporter implements Reporter {
+    private readonly service;
+    private readonly surface;
+    private readonly identityPath?;
+    private readonly env?;
+    private readonly disabled;
+    private readonly runStates;
+    private readonly suiteStates;
+    constructor(options?: AnalyticsRunReporterOptions);
+    onSuiteStart(suite: SuiteDefinition, context?: RunArtifactReporterContext): Promise<void>;
+    onTestStart(test: TestDefinition, _filePath: string, context?: RunArtifactReporterContext): Promise<void>;
+    onHookEnd(event: HookResultEvent): Promise<void>;
+    onTestEnd(): Promise<void>;
+    onRunEnd(summary: RunSummary): Promise<void>;
+    onSuiteEnd(summary: SuiteSummary): Promise<void>;
+    flush(): Promise<void>;
+    private findStateForResult;
+    private captureTestResult;
+    private captureSuiteResult;
+}
+declare function createAnalyticsRunReporter(options?: AnalyticsRunReporterOptions): AnalyticsRunReporter;
+
+declare const AGENT_QA_VERSION = "0.1.0";
+declare function getAgentQaVersion(): string;
+
+declare const DEFAULT_AGENT_QA_RUNTIME_DIR = ".agent-qa";
+declare const DEFAULT_AGENT_QA_ARTIFACTS_DIR = ".agent-qa/artifacts";
+declare const DEFAULT_AGENT_QA_CACHE_DIR = ".agent-qa/cache";
+declare const DEFAULT_AGENT_QA_SCREENSHOTS_DIR = ".agent-qa/artifacts/screenshots";
+declare const DEFAULT_AGENT_QA_VIDEOS_DIR = ".agent-qa/artifacts/videos";
+declare const DEFAULT_AGENT_QA_RUNS_DB_PATH = ".agent-qa/runs.db";
+declare const LEGACY_AGENT_QA_DASHBOARD_DB_PATH = ".agent-qa/dashboard.db";
+
+interface CompressOptions {
+    effectiveResolution: number;
+    maxBytes?: number;
+    actionSpaceWidth: number;
+}
+interface CompressResult {
+    buffer: Buffer;
+    imageWidth: number;
+    imageHeight: number;
+}
+declare function compressScreenshot(buffer: Buffer, opts: CompressOptions, logger?: ScopedLogger): Promise<CompressResult>;
+
+interface AlignOptions {
+    width: number;
+    height: number;
+}
+/** Resize buffer to exact window dimensions. Used by mobile adapters for
+ *  action-space alignment (e.g., iOS physical pixels → logical points). */
+declare function alignToWindow(buffer: Buffer, opts: AlignOptions): Promise<Buffer>;
+
+interface ImageDimensions {
+    width: number;
+    height: number;
+}
+/** Read image buffer width/height without decoding pixels.
+ *  Used by mobile adapters for action-space drift assertions (D-06/D-07). */
+declare function getImageDimensions(buffer: Buffer): Promise<ImageDimensions | undefined>;
+
+/**
+ * Converts "Meta" tokens in keyboard combo strings to "Control" on non-Mac platforms.
+ *
+ * Users write combos like "Meta+k" and we route them to Cmd+K on Mac, Ctrl+K on
+ * Windows/Linux. Uses split/join (not regex) to avoid edge-case bugs with adjacent
+ * tokens like "Shift+Meta+Meta+T".
+ *
+ * @param keys - Array of key/combo strings (e.g., ["Meta+k", "Enter"])
+ * @param options.enabled - When false, keys are returned unchanged
+ * @param options.isMac - When true, keys are returned unchanged (Meta is native)
+ * @returns New array with Meta tokens replaced by Control (when applicable)
+ */
+declare function convertKeysForPlatform(keys: string[], options: {
+    enabled: boolean;
+    isMac: boolean;
+}): string[];
+/**
+ * Returns true when running on macOS. Reads process.platform at call time so
+ * tests can override it via Object.defineProperty(process, 'platform', ...).
+ */
+declare function isMacPlatform(): boolean;
+
+declare function isPathInsideDir(childPath: string, parentDir: string): boolean;
+
+export { AGENT_QA_POSTHOG_HOST, AGENT_QA_POSTHOG_KEY, AGENT_QA_VERSION, ANALYTICS_AGENT_PRODUCTS, ANALYTICS_DASHBOARD_ENTITY_TYPES, ANALYTICS_DASHBOARD_OUTCOMES, ANALYTICS_EVENT_NAMES, ANALYTICS_FAILURE_CATEGORIES, ANALYTICS_MCP_ERROR_CATEGORIES, ANALYTICS_MCP_HOST_KINDS, ANALYTICS_MCP_PATH_KINDS, ANALYTICS_MCP_PORT_KINDS, ANALYTICS_MCP_SERVER_STATES, ANALYTICS_MCP_TOOL_CATEGORIES, ANALYTICS_MCP_TOOL_STATUSES, ANALYTICS_MCP_TRANSPORTS, ANALYTICS_PLATFORMS, ANALYTICS_RUNNERS, ANALYTICS_RUNTIME_CONTEXTS, ANALYTICS_RUN_STATUSES, ANALYTICS_SUITE_EXECUTION_MODES, ANALYTICS_SURFACES, ANALYTICS_TRANSPORT_KINDS, ANALYTICS_TRIGGER_SOURCES, ANDROID_ROLE_MAP, ATTR_RUNNER, ATTR_TRIGGER, AccessibilityConfigSchema, type AccessibilityViolation, type Action, type ActionCache, type ActionPlan, ActionPlanSchema, type ActionResult, AdapterLogDataSchema, AgentLogDataSchema, type AgentLoopConfig, type AgentPhase, type AgentQaConfig, AgentQaConfigSchema, type AlignOptions, type AnalyticsAgentProduct, type AnalyticsCapturePayload, type AnalyticsEventInput, type AnalyticsEventName, type AnalyticsEventProperties, type AnalyticsIdentity, type AnalyticsIdentityStore, type AnalyticsPostHogTransportFactoryOptions, AnalyticsRunReporter, type AnalyticsRunReporterOptions, type AnalyticsRuntimeContext, AnalyticsSchema, type AnalyticsService, type AnalyticsServiceConfig, type AnalyticsServiceOptions, type AnalyticsStandardPropertiesOptions, type AnalyticsSurface, type AnalyticsTransport, type AnalyticsTransportKind, type ArtifactRecord, type Asserter, AssertionEvaluator, type AssertionInput, type AssertionResult, AssertionResultSchema, type AssertionType, type AuthCredential, type AuthPluginBundle, type AuthPluginDeclaration, AuthPluginDeclarationSchema, type AuthProvider, type AuthStore, type BaseObservation, BaseObservationSchema, type BetterSqlite3Database, type BrowserConfig, BrowserConfigSchema, type BuiltAnalyticsEvent, type BuiltAnalyticsEventProperties, CACHE_SCHEMA_VERSION, CacheConfigSchema, type CacheEntry, CacheLogDataSchema, type CaptureConfig, CaptureConfigSchema, type CaptureResult, CircuitBreaker, type CircuitBreakerConfig, type CompressOptions, type CompressResult, type ConsoleLogEntry, ConsoleReporter, type ConsoleReporterOptions, type CreateAuthFetchContext, type CreateAuthFetchOptions, type CuratorContext, CuratorResponseSchema, DEFAULT_AGENT_QA_ARTIFACTS_DIR, DEFAULT_AGENT_QA_CACHE_DIR, DEFAULT_AGENT_QA_RUNS_DB_PATH, DEFAULT_AGENT_QA_RUNTIME_DIR, DEFAULT_AGENT_QA_SCREENSHOTS_DIR, DEFAULT_AGENT_QA_VIDEOS_DIR, DEFAULT_MEMORY_DIR, type DashboardAuthMetadata, type DashboardAuthMode, DashboardConfigSchema, type DeviceConfig, DeviceProfileSchema, DurationString, EMPTY_POSTHOG_KEY_WARNING, type ElementInfo, type ExchangeCodeContext, ExplicitExtractor, type ExtractionMethod, ExtractionResultSchema, type ExtractorInput, type FarmMobileConfig, type FarmProvider, type FarmProviderConfig, type FarmWebConfig, FatalReporterError, FileActionCache, type FileAttachment, HealerLogDataSchema, type HealingAttempt, type HealingConfig, HealingConfigSchema, type HookDefinition, HookDefinitionSchema, type HookEvent, HookLogDataSchema, type HookOrchestrationResult, HookReferenceMigrationError, type HookResult, type HookResultEvent, type HookRuntime, type HooksFileConfig, HooksFileSchema, INTERNAL_ATTRIBUTE_PREFIX, IOS_ROLE_MAP, type ImageDimensions, JUnitReporter, type JUnitReporterOptions, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, KEY_MAP, LEGACY_AGENT_QA_DASHBOARD_DB_PATH, LLMAssertionEvaluator, type LLMAuthProviderPlugin, type LLMModelAdapter, LLMPlanner, type LLMProviderMode, LLMVariableExtractor, LLMVerifier, LOG_LEVEL_PRIORITY, type LoadLLMAuthPluginsOptions, LocalMemoryProvider, LockManager, LogCaptureConfigSchema, type LogEntry, type LogLevel, LogManager, type LogSource, LogSourceDataSchemas, type LogStorage, LoggingConfigSchema, MOBILE_ONLY_ACTIONS, McpConfigSchema, type MemoryDelta, type MemoryDeltaAction, type MemoryIndexParams, type MemoryLog, type MemoryObservationSnapshot, type MemoryProvider, type MemoryQueryResult, MissingSecretError, type MobileAppState, MobileAppStateSchema, MobileElementResolver, type MobileNode, type MobilePlatform, type MobileRefMap, MobileSetupError, type MobileSetupErrorCategory, type MobileSetupErrorOptions, type MobileTransport, MobileUseOverrideSchema, MobileUseSchema, MockAnalyticsTransport, type ModelConfig, ModelConfigSchema, MultiReporter, NamedLLMConfigSchema, type NetworkLogEntry, NoopAnalyticsTransport, NullActionCache, type OAuthTokens, type ObservationFrontmatter, type ObserveOptions, type ParseError, type ParseResult, type ParsedMobileTree, type ParsedRunAttrFlags, type PlanResult, type Planner, type PlannerConfig, PlannerConfigSchema, PlannerLogDataSchema, type PlatformAdapter, type PlatformConfig, PluginsSchema, ProviderConfigSchema, type ProviderOptions, RUNTIME_IMAGE_MAP, RUN_ARTIFACT_SCHEMA_VERSION, RUN_ATTRIBUTE_KEY_MAX_LENGTH, RUN_ATTRIBUTE_VALUE_MAX_LENGTH, RecordingConfigSchema, type RegistryConfig, RegistrySchema, type Reporter, type ReporterEvent, type ResolveAnalyticsIdentityOptions, type ResolveMobileRunConfigInput, type ResolvedLLMAuth, type ResolvedMobileApp, type ResolvedMobileAppInstall, type ResolvedMobileDevice, type ResolvedMobileRunConfig, type ResolvedWorkspaceFile, type ResolvedWorkspacePaths, type RunArtifactConfigSnapshot, type RunArtifactFinalizeInput, type RunArtifactKind, type RunArtifactMemoryDelta, type RunArtifactMemoryDeltaAction, type RunArtifactMemoryObservationSnapshot, type RunArtifactMemorySnapshot, type RunArtifactMetadata, type RunArtifactPayload, type RunArtifactReporterContext, type RunArtifactRuntimeSnapshot, type RunArtifactStageInput, type RunArtifactSuiteMemberSnapshot, type RunArtifactSuiteSourceSnapshot, type RunArtifactTerminalError, type RunArtifactTestSourceSnapshot, type RunAttributeRunner, type RunAttributeTrigger, type RunAttributes, type RunSuiteConfig, type RunSummary, type RunTestConfig, RunnerLogDataSchema, type SandboxRunnerOptions, type ScopedLogger, type ScreenState, type ScreenStateMetadata, SecretConfigError, type SecretFileMetadata, SecretRedactor, SecretStore, type SecretTemplate, type ServicesConfig, ServicesSchema, SizeString, type StartAuthContext, type StartAuthResult, StdoutLiveReporter, type StepAnnotation, type StepContext, type StepHashInputs, type StepPhaseEvent, type StepResult, type StepStatus, type StepTrace, type SuiteDefinition, SuiteDefinitionSchema, type SuiteObservation, type SuiteObservationFrontmatter, SuiteObservationSchema, type SuiteResult, type SuiteSummary, SuiteTestEntrySchema, TargetSchema, type TestConfig, type TestDefinition, TestDefinitionSchema, type TestMeta, TestMetaSchema, type TestResult, type TestStatus, type TestStep, TestStepSchema, type TimeoutConfig, TimeoutConfigSchema, type TokenRefreshFn, type TokenUsage, type ToolCategory, type ToolDefinition, ToolRegistry, TransportSchema, type UseConfig, UseSchema, VALID_FILENAME_RE, type ValidationDiagnostic, type ValidationResult, type VariableExtractor, type VariableSource, VariableStore, type VerificationResult, VerificationResultSchema, type Verifier, type VerifyResult, WEB_ONLY_ACTIONS, type WorkspaceConfig, type WorkspaceFileKind, type WorkspaceFileRecord, WorkspaceSchema, alignToWindow, applyWorkspaceHookReferenceMigration, auditWorkspaceHookReferenceMigration, browserstackProvider, buildAnalyticsEvent, buildAssertionPrompt, buildExtractionPrompt, buildInternalRunAttributes, buildMemoryIndex, buildStepPrompt, buildSystemPrompt, buildTools, buildVerificationPrompt, captureAnalytics, captureFailureScreenshot, checkDockerAvailable, clearLLMAuthProviderPlugins, clearLoadedLLMAuthPluginModules, collectAllInjectedIds, compressScreenshot, computeFingerPositions, computePinch, computeSwipe, convertKeysForPlatform, createAnalyticsRunReporter, createAnalyticsService, createAsserter, createAuthFetch, createBetterSqlite3Database, createExtractor, createMemoryProvider, createModel, createWrappedModel, defaultRegistry, deprecateOnFailure, detectGlobOverlap, detectPlaywrightVersion, discoverWorkspaceFiles, ensureMemoryDirs, escapeXml, estimateTokens, executeStep, findBareVariables, findSecretTemplates, findUnresolvedTemplates, flushAnalytics, formatDiagnostics, formatDiagnosticsPlain, formatLogEntry, formatParseError, formatRunAttributesBlock, generateAnalyticsUserId, generateFailureSummary, generatePKCE, generateRunId, generateState, getAgentQaVersion, getAnalyticsIdentityPath, getAnalyticsService, getAuthPath, getCredential, getImageDimensions, getLLMAuthProviderPlugin, getProvider, getProviderOptions, hashScreenState, hashStepInstruction, interpolateSecretTemplates, interpolateVariables, isBetterSqlite3AbiMismatch, isBetterSqlite3NativeModuleError, isBetterSqlite3NodeGypSymlinkConflict, isMacPlatform, isPathInsideDir, isWorkspacePathMatch, listLLMAuthProviderPlugins, listObservations, listProviders, loadLLMAuthPlugins, mapMobileCapabilities, mapWebCapabilities, mergeRunAttributes, normalizeRole, parseAllTests, parseEnvFile, parseHookInline, parseHooksFile, parseMobileSource, parseObservation, parseRunAttrFlags, parseSuiteFile, parseTTL, parseTestFile, readAnalyticsIdentity, readAuth, redactSecretValue, registerAllProviders, registerLLMAuthProviderPlugin, registerLLMAuthProviderPlugins, registerProvider, removeAuth, resetAnalyticsServiceForTests, resolveAnalyticsAgentProduct, resolveAnalyticsIdentity, resolveAnalyticsStandardProperties, resolveBetterSqliteRebuildCommand, resolveFarmCredentials, resolveFileReferences, resolveLLMAuth, resolveMemoryRoot, resolveMobileRunConfig, resolveSecretTemplatesInValue, resolveWorkspaceFileTarget, resolveWorkspacePaths, runCurator, runHookInSandbox, runHooks, runSuite, runTest, runTestWithRetry, scanContent, serializeEnvFile, shouldAblate, sortRunAttributesForDisplay, stripHookInline, toolCallToActionPlan, toolSchemaMiddleware, truncateScreenState, validateConfig, validateFilename, validateFiles, validateProject, validateSuiteFile, validateTestFile, validateTrustedRunAttributes, validateUserRunAttributes, warnIfOutOfBounds, writeAnalyticsIdentity, writeAuth, writeObservation };