@kb-labs/qa-contracts 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,2191 @@
+import { z } from 'zod';
+
+/**
+ * Git submodule metadata for a repo within the monorepo.
+ */
+interface SubmoduleInfo {
+    /** Directory name (e.g. "kb-labs-mind") */
+    name: string;
+    /** Short commit hash */
+    commit: string;
+    /** Current branch */
+    branch: string;
+    /** Whether the submodule has uncommitted changes */
+    dirty: boolean;
+    /** Last commit message */
+    message: string;
+}
+
+/**
+ * QA Plugin configuration.
+ * Stored in kb.config.json → profiles[].products.qa
+ */
+/**
+ * A single QA check definition — command to run, where, and how to evaluate.
+ */
+interface QACheckConfig {
+    /** Unique check identifier (e.g. "build", "lint", "typecheck", "test") */
+    id: string;
+    /** Display name. Defaults to id if not set. */
+    name?: string;
+    /** Command to execute (e.g. "pnpm", "go", "bash") */
+    command: string;
+    /** Arguments passed to command (e.g. ["run", "build"]) */
+    args?: string[];
+    /**
+     * How to evaluate the result.
+     * - "exitcode" (default): exit 0 = pass
+     * - "json": parse stdout as JSON, pass if .ok === true or .success === true or .status === "ok"
+     */
+    parser?: 'exitcode' | 'json';
+    /** Timeout in ms. Default: 120000 (2 min) */
+    timeoutMs?: number;
+    /** If true, failure does not block the overall QA run */
+    optional?: boolean;
+    /**
+     * If true, sort packages by dependency order (topological sort) before running.
+     * Ensures upstream packages are processed first so their build artifacts (e.g. .d.ts)
+     * are available for downstream packages. Useful for build checks.
+     */
+    ordered?: boolean;
+    /**
+     * Where to execute the command:
+     * - "perPackage" (default): run in each discovered package directory
+     * - "scopePath": run once in the sub-repo root (e.g. platform/kb-labs-cli/)
+     * - "repoRoot": run once in the workspace root
+     */
+    runIn?: 'perPackage' | 'scopePath' | 'repoRoot';
+    /** Display icon (emoji, e.g. "🔒"). Used in CLI output and REST API. */
+    icon?: string;
+}
+/**
+ * Filter which packages are discovered and checked.
+ */
+interface PackagesConfig {
+    /**
+     * Glob patterns for sub-repo directories to scan, relative to workspace root.
+     * E.g. ["platform/*", "plugins/*", "infra/*"].
+     * Each matched directory is checked for pnpm-workspace.yaml.
+     * Defaults to auto-scan if omitted.
+     */
+    paths?: string[];
+    /** Include only packages whose name matches any of these patterns. Applied after discovery. */
+    include?: string[];
+    /** Exclude packages whose name matches any of these patterns. Applied after include. */
+    exclude?: string[];
+}
+interface QAPluginConfig {
+    /** Control which packages are discovered and checked. */
+    packages?: PackagesConfig;
+    /**
+     * Checks to run. If omitted, falls back to built-in runners (build/lint/typeCheck/test).
+     * Each check is executed per package or per scope depending on runIn.
+     */
+    checks?: QACheckConfig[];
+    /**
+     * Per-scope overrides. Key is a relative path or sub-repo name (e.g. "platform/kb-labs-cli").
+     * scope.checks replaces global checks entirely (no merging).
+     */
+    scopes?: Record<string, {
+        packages?: PackagesConfig;
+        checks?: QACheckConfig[];
+    }>;
+    /** Package categories for grouped reporting */
+    categories?: Record<string, CategoryConfig>;
+}
+/**
+ * Configuration for a single package category.
+ */
+interface CategoryConfig {
+    /** Display name (defaults to category key if not set) */
+    label?: string;
+    /** Package name patterns: exact name, glob ("@kb-labs/core-*"), or repo prefix ("kb-labs-cli/*") */
+    packages: string[];
+}
+
+/**
+ * Types of checks the QA plugin can run.
+ */
+type CheckType = string;
+/**
+ * Result of a single check type across all packages.
+ */
+interface CheckResult {
+    /** Packages that passed this check */
+    passed: string[];
+    /** Packages that failed this check */
+    failed: string[];
+    /** Packages that were skipped (up-to-date / excluded) */
+    skipped: string[];
+    /** Error messages keyed by package name */
+    errors: Record<string, string>;
+}
+/**
+ * Combined results of all QA check types.
+ */
+type QAResults = Record<string, CheckResult>;
+/**
+ * Options for running QA checks.
+ */
+interface QARunOptions {
+    /** Root directory of the monorepo */
+    rootDir: string;
+    /** Skip specific check IDs (e.g. ['build', 'lint', 'typecheck', 'test']) */
+    skipChecks?: string[];
+    /** Disable caching (force full run) */
+    noCache?: boolean;
+    /** Run all packages, ignoring affected analysis */
+    all?: boolean;
+    /** Filter by package name */
+    package?: string;
+    /** Filter by repo name */
+    repo?: string;
+    /** Filter by npm scope */
+    scope?: string;
+    /** Package discovery config (paths/include/exclude from kb.config.json) */
+    packagesConfig?: PackagesConfig;
+    /** Custom checks to run. If provided, replaces built-in runners (build/lint/typeCheck/test). */
+    checks?: QACheckConfig[];
+    /** Progress callback (durationMs is set for executed checks, undefined for skipped) */
+    onProgress?: (phase: string, pkg: string, status: 'pass' | 'fail' | 'skip', durationMs?: number) => void;
+}
+/**
+ * Package filter criteria.
+ */
+interface PackageFilter {
+    package?: string;
+    repo?: string;
+    scope?: string;
+}
+/**
+ * Workspace package metadata.
+ */
+interface WorkspacePackage {
+    /** Package name from package.json */
+    name: string;
+    /** Absolute path to package directory */
+    dir: string;
+    /** Relative path from root */
+    relativePath: string;
+    /** The repo/monorepo this package belongs to */
+    repo: string;
+    /** Git submodule info for this package's repo */
+    submodule?: SubmoduleInfo;
+}
+/**
+ * Extended QA run result with package metadata preserved.
+ */
+interface QARunResult {
+    results: QAResults;
+    packages: WorkspacePackage[];
+}
+
+/**
+ * Git metadata captured at baseline time.
+ */
+interface GitInfo {
+    commit: string;
+    branch: string;
+}
+/**
+ * Snapshot of a single check type in the baseline.
+ */
+interface BaselineCheckSnapshot {
+    passed: number;
+    failed: number;
+    failedPackages: string[];
+}
+/**
+ * A full baseline snapshot — the "known state" of QA for comparison.
+ */
+interface BaselineSnapshot {
+    timestamp: string;
+    git: GitInfo;
+    results: Record<string, BaselineCheckSnapshot>;
+}
+/**
+ * Diff for a single check type between current run and baseline.
+ */
+interface CheckDiff {
+    /** Packages that newly failed (weren't in baseline) */
+    newFailures: string[];
+    /** Packages that were fixed (were in baseline, now passing) */
+    fixed: string[];
+    /** Packages still failing (in both baseline and current) */
+    stillFailing: string[];
+    /** Net change in failure count (positive = regression) */
+    delta: number;
+}
+/**
+ * Full diff across all check types.
+ */
+type BaselineDiff = Record<string, CheckDiff>;
+
+/**
+ * A single history entry — one QA run saved to history.
+ */
+interface HistoryEntry {
+    timestamp: string;
+    git: {
+        commit: string;
+        branch: string;
+        message: string;
+    };
+    /** Per-repo submodule git state at time of run */
+    submodules?: Record<string, SubmoduleInfo>;
+    status: 'passed' | 'failed';
+    summary: Record<string, {
+        passed: number;
+        failed: number;
+        skipped: number;
+    }>;
+    failedPackages: Record<string, string[]>;
+}
+/**
+ * Trend analysis result for a single check type.
+ */
+interface TrendResult {
+    checkType: string;
+    /** Display label */
+    label?: string;
+    /** Display icon (emoji) */
+    icon?: string;
+    /** Failure count at start of window */
+    previous: number;
+    /** Failure count at end of window */
+    current: number;
+    /** Net change (positive = regression) */
+    delta: number;
+    trend: 'regression' | 'improvement' | 'no-change';
+}
+/**
+ * A single time-series data point for enriched trends.
+ */
+interface TrendTimeSeriesPoint {
+    timestamp: string;
+    gitCommit: string;
+    gitBranch: string;
+    gitMessage: string;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+/**
+ * A changelog entry describing what changed between two consecutive QA runs.
+ */
+interface TrendChangelogEntry {
+    timestamp: string;
+    gitCommit: string;
+    gitMessage: string;
+    newFailures: string[];
+    fixed: string[];
+    delta: number;
+}
+/**
+ * Enriched trend analysis result for a single check type.
+ * Provides full time-series data, per-entry changelog, and velocity metrics.
+ */
+interface EnrichedTrendResult {
+    checkType: string;
+    /** Display label */
+    label?: string;
+    /** Display icon (emoji) */
+    icon?: string;
+    /** All data points in the window (for time-series chart) */
+    timeSeries: TrendTimeSeriesPoint[];
+    /** What changed between consecutive entries */
+    changelog: TrendChangelogEntry[];
+    /** Failure count at start of window */
+    current: number;
+    /** Failure count at end of window */
+    previous: number;
+    /** Net change (positive = regression) */
+    delta: number;
+    trend: 'regression' | 'improvement' | 'no-change';
+    /** Average delta per entry (velocity of change) */
+    velocity: number;
+}
+/**
+ * Regression detection result.
+ */
+interface RegressionResult {
+    hasRegressions: boolean;
+    regressions: Array<{
+        checkType: string;
+        delta: number;
+        newFailures: string[];
+    }>;
+}
+
+/**
+ * Summary section of a QA report.
+ */
+interface ReportSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+/**
+ * Full QA report — returned by json reporter.
+ */
+interface QAReport {
+    status: 'passed' | 'failed';
+    timestamp: string;
+    summary: Record<string, ReportSummary>;
+    failures: Record<string, string[]>;
+    errors: Record<string, Record<string, string>>;
+    baseline: BaselineDiff | null;
+}
+
+/**
+ * Per-package status across all check types.
+ */
+interface PackageStatus {
+    name: string;
+    repo: string;
+    category: string;
+    checks: Record<string, 'passed' | 'failed' | 'skipped'>;
+    errors: Record<string, string>;
+}
+/**
+ * Results grouped by category → repo → packages.
+ */
+interface GroupedResults {
+    categories: Record<string, CategoryGroup>;
+}
+/**
+ * A single category group with its repos and summary.
+ */
+interface CategoryGroup {
+    label: string;
+    repos: Record<string, RepoGroup>;
+    summary: GroupSummary;
+}
+/**
+ * A single repo group with its packages and summary.
+ */
+interface RepoGroup {
+    packages: PackageStatus[];
+    summary: GroupSummary;
+}
+/**
+ * Summary counts at category or repo level.
+ */
+interface GroupSummary {
+    total: number;
+    /** Packages where all checks passed */
+    passed: number;
+    /** Packages where at least one check failed */
+    failed: number;
+    checks: Record<string, {
+        passed: number;
+        failed: number;
+        skipped: number;
+    }>;
+}
+
+/**
+ * Per-package detail for a single check type.
+ */
+interface PackageCheckDetail {
+    /** Package name (e.g. "@kb-labs/mind-engine") */
+    name: string;
+    /** Repo / submodule name (e.g. "kb-labs-mind") */
+    repo: string;
+    /** Check status for this package */
+    status: 'passed' | 'failed' | 'skipped';
+    /** Error output (only if failed, truncated to 2000 chars) */
+    error?: string;
+    /** Git submodule info for this package's repo */
+    submodule?: SubmoduleInfo;
+}
+
+/**
+ * A single entry in a package's QA timeline.
+ */
+interface PackageTimelineEntry {
+    /** Timestamp of the QA run */
+    timestamp: string;
+    /** Root git info at time of run */
+    git: {
+        commit: string;
+        branch: string;
+        message: string;
+    };
+    /** Submodule commit hash (if available) */
+    submoduleCommit?: string;
+    /** Per-check status for this package */
+    checks: Record<string, 'passed' | 'failed' | 'skipped'>;
+}
+/**
+ * Full timeline for a specific package across QA history.
+ */
+interface PackageTimelineResponse {
+    /** Package name */
+    packageName: string;
+    /** Repo this package belongs to */
+    repo: string;
+    /** Timeline entries (newest first) */
+    entries: PackageTimelineEntry[];
+    /** Flaky score: 0-1, higher = more flaky (flip-flops between pass/fail) */
+    flakyScore: number;
+    /** Which check types exhibit flaky behavior */
+    flakyChecks: string[];
+    /** When this package first appeared in failed state */
+    firstFailure?: string;
+    /** Current streak (passing or failing, and how many consecutive runs) */
+    currentStreak: {
+        status: 'passing' | 'failing';
+        count: number;
+    };
+}
+
+/**
+ * A group of packages sharing the same error pattern.
+ */
+interface ErrorGroup {
+    /** Error pattern identifier (e.g. ESLint rule, TS error code) */
+    pattern: string;
+    /** Number of packages with this error */
+    count: number;
+    /** Package names in this group */
+    packages: string[];
+    /** Which check type this group belongs to */
+    checkType: string;
+    /** Example error text (first 200 chars) */
+    example: string;
+}
+
+/**
+ * REST API Request/Response Types and Zod Schemas for QA Plugin
+ */
+
+declare const QASummaryRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QASummaryRequest = z.infer<typeof QASummaryRequestSchema>;
+declare const QASummaryCheckSchema: z.ZodObject<{
+    checkType: z.ZodString;
+    label: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+    skipped: z.ZodNumber;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    passed: number;
+    failed: number;
+    skipped: number;
+    checkType: string;
+    label: string;
+    total: number;
+    icon?: string | undefined;
+}, {
+    passed: number;
+    failed: number;
+    skipped: number;
+    checkType: string;
+    label: string;
+    total: number;
+    icon?: string | undefined;
+}>;
+declare const QASummaryResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    lastRunAt: z.ZodNullable<z.ZodString>;
+    git: z.ZodNullable<z.ZodObject<{
+        commit: z.ZodString;
+        branch: z.ZodString;
+    } & {
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        commit: string;
+        branch: string;
+        message: string;
+    }, {
+        commit: string;
+        branch: string;
+        message: string;
+    }>>;
+    checks: z.ZodArray<z.ZodObject<{
+        checkType: z.ZodString;
+        label: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        skipped: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        passed: number;
+        failed: number;
+        skipped: number;
+        checkType: string;
+        label: string;
+        total: number;
+        icon?: string | undefined;
+    }, {
+        passed: number;
+        failed: number;
+        skipped: number;
+        checkType: string;
+        label: string;
+        total: number;
+        icon?: string | undefined;
+    }>, "many">;
+    hasBaseline: z.ZodBoolean;
+    baselineTimestamp: z.ZodNullable<z.ZodString>;
+    historyCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    lastRunAt: string | null;
+    git: {
+        commit: string;
+        branch: string;
+        message: string;
+    } | null;
+    checks: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        checkType: string;
+        label: string;
+        total: number;
+        icon?: string | undefined;
+    }[];
+    hasBaseline: boolean;
+    baselineTimestamp: string | null;
+    historyCount: number;
+}, {
+    status: string;
+    lastRunAt: string | null;
+    git: {
+        commit: string;
+        branch: string;
+        message: string;
+    } | null;
+    checks: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        checkType: string;
+        label: string;
+        total: number;
+        icon?: string | undefined;
+    }[];
+    hasBaseline: boolean;
+    baselineTimestamp: string | null;
+    historyCount: number;
+}>;
+type QASummaryResponse = z.infer<typeof QASummaryResponseSchema>;
+declare const QALatestRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QALatestRequest = z.infer<typeof QALatestRequestSchema>;
+declare const QALatestResponseSchema: z.ZodObject<{
+    entry: z.ZodNullable<z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        } & {
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+            message: string;
+        }, {
+            commit: string;
+            branch: string;
+            message: string;
+        }>;
+        status: z.ZodEnum<["passed", "failed"]>;
+        summary: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>>;
+        failedPackages: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }, {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    entry: {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    } | null;
+}, {
+    entry: {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    } | null;
+}>;
+type QALatestResponse = z.infer<typeof QALatestResponseSchema>;
+declare const QAHistoryRequestSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+}, {
+    limit?: number | undefined;
+}>;
+type QAHistoryRequest = z.infer<typeof QAHistoryRequestSchema>;
+declare const QAHistoryResponseSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        } & {
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+            message: string;
+        }, {
+            commit: string;
+            branch: string;
+            message: string;
+        }>;
+        status: z.ZodEnum<["passed", "failed"]>;
+        summary: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>>;
+        failedPackages: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }, {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }>, "many">;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }[];
+    total: number;
+}, {
+    entries: {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }[];
+    total: number;
+}>;
+type QAHistoryResponse = z.infer<typeof QAHistoryResponseSchema>;
+declare const QATrendsRequestSchema: z.ZodObject<{
+    window: z.ZodOptional<z.ZodNumber>;
+    enriched: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    window?: number | undefined;
+    enriched?: boolean | undefined;
+}, {
+    window?: number | undefined;
+    enriched?: boolean | undefined;
+}>;
+type QATrendsRequest = z.infer<typeof QATrendsRequestSchema>;
+declare const QATrendsResponseSchema: z.ZodObject<{
+    trends: z.ZodArray<z.ZodObject<{
+        checkType: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        previous: z.ZodNumber;
+        current: z.ZodNumber;
+        delta: z.ZodNumber;
+        trend: z.ZodEnum<["regression", "improvement", "no-change"]>;
+    }, "strip", z.ZodTypeAny, {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        label?: string | undefined;
+        icon?: string | undefined;
+    }, {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        label?: string | undefined;
+        icon?: string | undefined;
+    }>, "many">;
+    historyCount: z.ZodNumber;
+    window: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    historyCount: number;
+    window: number;
+    trends: {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        label?: string | undefined;
+        icon?: string | undefined;
+    }[];
+}, {
+    historyCount: number;
+    window: number;
+    trends: {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        label?: string | undefined;
+        icon?: string | undefined;
+    }[];
+}>;
+type QATrendsResponse = z.infer<typeof QATrendsResponseSchema>;
+declare const QAEnrichedTrendsResponseSchema: z.ZodObject<{
+    trends: z.ZodArray<z.ZodObject<{
+        checkType: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        timeSeries: z.ZodArray<z.ZodObject<{
+            timestamp: z.ZodString;
+            gitCommit: z.ZodString;
+            gitBranch: z.ZodString;
+            gitMessage: z.ZodString;
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            skipped: number;
+            timestamp: string;
+            gitCommit: string;
+            gitBranch: string;
+            gitMessage: string;
+        }, {
+            passed: number;
+            failed: number;
+            skipped: number;
+            timestamp: string;
+            gitCommit: string;
+            gitBranch: string;
+            gitMessage: string;
+        }>, "many">;
+        changelog: z.ZodArray<z.ZodObject<{
+            timestamp: z.ZodString;
+            gitCommit: z.ZodString;
+            gitMessage: z.ZodString;
+            newFailures: z.ZodArray<z.ZodString, "many">;
+            fixed: z.ZodArray<z.ZodString, "many">;
+            delta: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            delta: number;
+            gitCommit: string;
+            gitMessage: string;
+            newFailures: string[];
+            fixed: string[];
+        }, {
+            timestamp: string;
+            delta: number;
+            gitCommit: string;
+            gitMessage: string;
+            newFailures: string[];
+            fixed: string[];
+        }>, "many">;
+        current: z.ZodNumber;
+        previous: z.ZodNumber;
+        delta: z.ZodNumber;
+        trend: z.ZodEnum<["regression", "improvement", "no-change"]>;
+        velocity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        timeSeries: {
+            passed: number;
+            failed: number;
+            skipped: number;
+            timestamp: string;
+            gitCommit: string;
+            gitBranch: string;
+            gitMessage: string;
+        }[];
+        changelog: {
+            timestamp: string;
+            delta: number;
+            gitCommit: string;
+            gitMessage: string;
+            newFailures: string[];
+            fixed: string[];
+        }[];
+        velocity: number;
+        label?: string | undefined;
+        icon?: string | undefined;
+    }, {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        timeSeries: {
+            passed: number;
+            failed: number;
+            skipped: number;
+            timestamp: string;
+            gitCommit: string;
+            gitBranch: string;
+            gitMessage: string;
+        }[];
+        changelog: {
+            timestamp: string;
+            delta: number;
+            gitCommit: string;
+            gitMessage: string;
+            newFailures: string[];
+            fixed: string[];
+        }[];
+        velocity: number;
+        label?: string | undefined;
+        icon?: string | undefined;
+    }>, "many">;
+    historyCount: z.ZodNumber;
+    window: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    historyCount: number;
+    window: number;
+    trends: {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        timeSeries: {
+            passed: number;
+            failed: number;
+            skipped: number;
+            timestamp: string;
+            gitCommit: string;
+            gitBranch: string;
+            gitMessage: string;
+        }[];
+        changelog: {
+            timestamp: string;
+            delta: number;
+            gitCommit: string;
+            gitMessage: string;
+            newFailures: string[];
+            fixed: string[];
+        }[];
+        velocity: number;
+        label?: string | undefined;
+        icon?: string | undefined;
+    }[];
+}, {
+    historyCount: number;
+    window: number;
+    trends: {
+        checkType: string;
+        previous: number;
+        current: number;
+        delta: number;
+        trend: "regression" | "improvement" | "no-change";
+        timeSeries: {
+            passed: number;
+            failed: number;
+            skipped: number;
+            timestamp: string;
+            gitCommit: string;
+            gitBranch: string;
+            gitMessage: string;
+        }[];
+        changelog: {
+            timestamp: string;
+            delta: number;
+            gitCommit: string;
+            gitMessage: string;
+            newFailures: string[];
+            fixed: string[];
+        }[];
+        velocity: number;
+        label?: string | undefined;
+        icon?: string | undefined;
+    }[];
+}>;
+type QAEnrichedTrendsResponse = z.infer<typeof QAEnrichedTrendsResponseSchema>;
+declare const QARegressionsRequestSchema: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    scope?: string | undefined;
+}, {
+    scope?: string | undefined;
+}>;
+type QARegressionsRequest = z.infer<typeof QARegressionsRequestSchema>;
+declare const RegressionEntrySchema: z.ZodObject<{
+    checkType: z.ZodString;
+    delta: z.ZodNumber;
+    newFailures: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    checkType: string;
+    delta: number;
+    newFailures: string[];
+}, {
+    checkType: string;
+    delta: number;
+    newFailures: string[];
+}>;
+type RegressionEntry = z.infer<typeof RegressionEntrySchema>;
+declare const QARegressionsResponseSchema: z.ZodObject<{
+    hasRegressions: z.ZodBoolean;
+    regressions: z.ZodArray<z.ZodObject<{
+        checkType: z.ZodString;
+        delta: z.ZodNumber;
+        newFailures: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        checkType: string;
+        delta: number;
+        newFailures: string[];
+    }, {
+        checkType: string;
+        delta: number;
+        newFailures: string[];
+    }>, "many">;
+    scope: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    hasRegressions: boolean;
+    regressions: {
+        checkType: string;
+        delta: number;
+        newFailures: string[];
+    }[];
+    scope?: string | undefined;
+}, {
+    hasRegressions: boolean;
+    regressions: {
+        checkType: string;
+        delta: number;
+        newFailures: string[];
+    }[];
+    scope?: string | undefined;
+}>;
+type QARegressionsResponse = z.infer<typeof QARegressionsResponseSchema>;
+declare const QABaselineRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QABaselineRequest = z.infer<typeof QABaselineRequestSchema>;
+declare const QABaselineResponseSchema: z.ZodObject<{
+    baseline: z.ZodNullable<z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+        }, {
+            commit: string;
+            branch: string;
+        }>;
+        results: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            failedPackages: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    }, {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    baseline: {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    } | null;
+}, {
+    baseline: {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    } | null;
+}>;
+type QABaselineResponse = z.infer<typeof QABaselineResponseSchema>;
+declare const QARunRequestSchema: z.ZodObject<{
+    skipChecks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    saveToHistory: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    skipChecks?: string[] | undefined;
+    saveToHistory?: boolean | undefined;
+}, {
+    skipChecks?: string[] | undefined;
+    saveToHistory?: boolean | undefined;
+}>;
+type QARunRequest = z.infer<typeof QARunRequestSchema>;
+declare const QARunResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<["passed", "failed"]>;
+    results: z.ZodRecord<z.ZodString, z.ZodObject<{
+        passed: z.ZodArray<z.ZodString, "many">;
+        failed: z.ZodArray<z.ZodString, "many">;
+        skipped: z.ZodArray<z.ZodString, "many">;
+        errors: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    }, {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    }>>;
+    entry: z.ZodNullable<z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        } & {
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+            message: string;
+        }, {
+            commit: string;
+            branch: string;
+            message: string;
+        }>;
+        status: z.ZodEnum<["passed", "failed"]>;
+        summary: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>>;
+        failedPackages: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }, {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    }>>;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "passed" | "failed";
+    entry: {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    } | null;
+    results: Record<string, {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    }>;
+    durationMs: number;
+}, {
+    status: "passed" | "failed";
+    entry: {
+        status: "passed" | "failed";
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+            skipped: number;
+        }>;
+        failedPackages: Record<string, string[]>;
+    } | null;
+    results: Record<string, {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    }>;
+    durationMs: number;
+}>;
+type QARunResponse = z.infer<typeof QARunResponseSchema>;
+declare const QADetailsRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QADetailsRequest = z.infer<typeof QADetailsRequestSchema>;
+declare const QADetailsResponseSchema: z.ZodObject<{
+    timestamp: z.ZodNullable<z.ZodString>;
+    git: z.ZodNullable<z.ZodObject<{
+        commit: z.ZodString;
+        branch: z.ZodString;
+    } & {
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        commit: string;
+        branch: string;
+        message: string;
+    }, {
+        commit: string;
+        branch: string;
+        message: string;
+    }>>;
+    submodules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        commit: z.ZodString;
+        branch: z.ZodString;
+        dirty: z.ZodBoolean;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        commit: string;
+        branch: string;
+        dirty: boolean;
+        message: string;
+        name: string;
+    }, {
+        commit: string;
+        branch: string;
+        dirty: boolean;
+        message: string;
+        name: string;
+    }>>>;
+    checks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        passed: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            repo: z.ZodString;
+            status: z.ZodEnum<["passed", "failed", "skipped"]>;
+            error: z.ZodOptional<z.ZodString>;
+            submodule: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                commit: z.ZodString;
+                branch: z.ZodString;
+                dirty: z.ZodBoolean;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            }, {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }, {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }>, "many">;
+        failed: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            repo: z.ZodString;
+            status: z.ZodEnum<["passed", "failed", "skipped"]>;
+            error: z.ZodOptional<z.ZodString>;
+            submodule: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                commit: z.ZodString;
+                branch: z.ZodString;
+                dirty: z.ZodBoolean;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            }, {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }, {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }>, "many">;
+        skipped: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            repo: z.ZodString;
+            status: z.ZodEnum<["passed", "failed", "skipped"]>;
+            error: z.ZodOptional<z.ZodString>;
+            submodule: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                commit: z.ZodString;
+                branch: z.ZodString;
+                dirty: z.ZodBoolean;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            }, {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }, {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        passed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        failed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        skipped: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+    }, {
+        passed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        failed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        skipped: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    git: {
+        commit: string;
+        branch: string;
+        message: string;
+    } | null;
+    checks: Record<string, {
+        passed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        failed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        skipped: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+    }>;
+    timestamp: string | null;
+    submodules?: Record<string, {
+        commit: string;
+        branch: string;
+        dirty: boolean;
+        message: string;
+        name: string;
+    }> | undefined;
+}, {
+    git: {
+        commit: string;
+        branch: string;
+        message: string;
+    } | null;
+    checks: Record<string, {
+        passed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        failed: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+        skipped: {
+            status: "passed" | "failed" | "skipped";
+            name: string;
+            repo: string;
+            error?: string | undefined;
+            submodule?: {
+                commit: string;
+                branch: string;
+                dirty: boolean;
+                message: string;
+                name: string;
+            } | undefined;
+        }[];
+    }>;
+    timestamp: string | null;
+    submodules?: Record<string, {
+        commit: string;
+        branch: string;
+        dirty: boolean;
+        message: string;
+        name: string;
+    }> | undefined;
+}>;
+type QADetailsResponse = z.infer<typeof QADetailsResponseSchema>;
+declare const QARunCheckRequestSchema: z.ZodObject<{
+    checkType: z.ZodString;
+    repo: z.ZodOptional<z.ZodString>;
+    package: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    checkType: string;
+    repo?: string | undefined;
+    package?: string | undefined;
+}, {
+    checkType: string;
+    repo?: string | undefined;
+    package?: string | undefined;
+}>;
+type QARunCheckRequest = z.infer<typeof QARunCheckRequestSchema>;
+declare const QARunCheckResponseSchema: z.ZodObject<{
+    checkType: z.ZodString;
+    status: z.ZodEnum<["passed", "failed"]>;
+    result: z.ZodObject<{
+        passed: z.ZodArray<z.ZodString, "many">;
+        failed: z.ZodArray<z.ZodString, "many">;
+        skipped: z.ZodArray<z.ZodString, "many">;
+        errors: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    }, {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    }>;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "passed" | "failed";
+    checkType: string;
+    durationMs: number;
+    result: {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    };
+}, {
+    status: "passed" | "failed";
+    checkType: string;
+    durationMs: number;
+    result: {
+        passed: string[];
+        failed: string[];
+        skipped: string[];
+        errors: Record<string, string>;
+    };
+}>;
+type QARunCheckResponse = z.infer<typeof QARunCheckResponseSchema>;
+declare const QABaselineUpdateRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QABaselineUpdateRequest = z.infer<typeof QABaselineUpdateRequestSchema>;
+declare const QABaselineUpdateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    baseline: z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+        }, {
+            commit: string;
+            branch: string;
+        }>;
+        results: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            failedPackages: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    }, {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    baseline: {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    };
+    success: boolean;
+}, {
+    baseline: {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    };
+    success: boolean;
+}>;
+type QABaselineUpdateResponse = z.infer<typeof QABaselineUpdateResponseSchema>;
+declare const QABaselineDiffRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QABaselineDiffRequest = z.infer<typeof QABaselineDiffRequestSchema>;
+declare const QABaselineDiffResponseSchema: z.ZodObject<{
+    hasDiff: z.ZodBoolean;
+    diff: z.ZodRecord<z.ZodString, z.ZodObject<{
+        newFailures: z.ZodArray<z.ZodString, "many">;
+        fixed: z.ZodArray<z.ZodString, "many">;
+        stillFailing: z.ZodArray<z.ZodString, "many">;
+        delta: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        delta: number;
+        newFailures: string[];
+        fixed: string[];
+        stillFailing: string[];
+    }, {
+        delta: number;
+        newFailures: string[];
+        fixed: string[];
+        stillFailing: string[];
+    }>>;
+    baseline: z.ZodNullable<z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+        }, {
+            commit: string;
+            branch: string;
+        }>;
+        results: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            failedPackages: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    }, {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    }>>;
+    current: z.ZodNullable<z.ZodObject<{
+        timestamp: z.ZodString;
+        summary: z.ZodRecord<z.ZodString, z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            passed: number;
+            failed: number;
+        }, {
+            passed: number;
+            failed: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+        }>;
+    }, {
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+        }>;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    current: {
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+        }>;
+    } | null;
+    baseline: {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    } | null;
+    hasDiff: boolean;
+    diff: Record<string, {
+        delta: number;
+        newFailures: string[];
+        fixed: string[];
+        stillFailing: string[];
+    }>;
+}, {
+    current: {
+        timestamp: string;
+        summary: Record<string, {
+            passed: number;
+            failed: number;
+        }>;
+    } | null;
+    baseline: {
+        git: {
+            commit: string;
+            branch: string;
+        };
+        timestamp: string;
+        results: Record<string, {
+            passed: number;
+            failed: number;
+            failedPackages: string[];
+        }>;
+    } | null;
+    hasDiff: boolean;
+    diff: Record<string, {
+        delta: number;
+        newFailures: string[];
+        fixed: string[];
+        stillFailing: string[];
+    }>;
+}>;
+type QABaselineDiffResponse = z.infer<typeof QABaselineDiffResponseSchema>;
+declare const QAPackageTimelineRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QAPackageTimelineRequest = z.infer<typeof QAPackageTimelineRequestSchema>;
+declare const QAPackageTimelineResponseSchema: z.ZodObject<{
+    packageName: z.ZodString;
+    repo: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        git: z.ZodObject<{
+            commit: z.ZodString;
+            branch: z.ZodString;
+        } & {
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            branch: string;
+            message: string;
+        }, {
+            commit: string;
+            branch: string;
+            message: string;
+        }>;
+        submoduleCommit: z.ZodOptional<z.ZodString>;
+        checks: z.ZodRecord<z.ZodString, z.ZodEnum<["passed", "failed", "skipped"]>>;
+    }, "strip", z.ZodTypeAny, {
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        checks: Record<string, "passed" | "failed" | "skipped">;
+        timestamp: string;
+        submoduleCommit?: string | undefined;
+    }, {
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        checks: Record<string, "passed" | "failed" | "skipped">;
+        timestamp: string;
+        submoduleCommit?: string | undefined;
+    }>, "many">;
+    flakyScore: z.ZodNumber;
+    flakyChecks: z.ZodArray<z.ZodString, "many">;
+    firstFailure: z.ZodOptional<z.ZodString>;
+    currentStreak: z.ZodObject<{
+        status: z.ZodEnum<["passing", "failing"]>;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "passing" | "failing";
+        count: number;
+    }, {
+        status: "passing" | "failing";
+        count: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        checks: Record<string, "passed" | "failed" | "skipped">;
+        timestamp: string;
+        submoduleCommit?: string | undefined;
+    }[];
+    repo: string;
+    packageName: string;
+    flakyScore: number;
+    flakyChecks: string[];
+    currentStreak: {
+        status: "passing" | "failing";
+        count: number;
+    };
+    firstFailure?: string | undefined;
+}, {
+    entries: {
+        git: {
+            commit: string;
+            branch: string;
+            message: string;
+        };
+        checks: Record<string, "passed" | "failed" | "skipped">;
+        timestamp: string;
+        submoduleCommit?: string | undefined;
+    }[];
+    repo: string;
+    packageName: string;
+    flakyScore: number;
+    flakyChecks: string[];
+    currentStreak: {
+        status: "passing" | "failing";
+        count: number;
+    };
+    firstFailure?: string | undefined;
+}>;
+type QAPackageTimelineResponse = z.infer<typeof QAPackageTimelineResponseSchema>;
+declare const QAErrorGroupsRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type QAErrorGroupsRequest = z.infer<typeof QAErrorGroupsRequestSchema>;
+declare const QAErrorGroupsResponseSchema: z.ZodObject<{
+    groups: z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        count: z.ZodNumber;
+        packages: z.ZodArray<z.ZodString, "many">;
+        checkType: z.ZodString;
+        example: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        checkType: string;
+        count: number;
+        pattern: string;
+        packages: string[];
+        example: string;
+    }, {
+        checkType: string;
+        count: number;
+        pattern: string;
+        packages: string[];
+        example: string;
+    }>, "many">;
+    ungrouped: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    groups: {
+        checkType: string;
+        count: number;
+        pattern: string;
+        packages: string[];
+        example: string;
+    }[];
+    ungrouped: number;
+}, {
+    groups: {
+        checkType: string;
+        count: number;
+        pattern: string;
+        packages: string[];
+        example: string;
+    }[];
+    ungrouped: number;
+}>;
+type QAErrorGroupsResponse = z.infer<typeof QAErrorGroupsResponseSchema>;
+
+/**
+ * Data directory for the QA plugin, relative to monorepo root.
+ */
+declare const QA_DATA_DIR = ".kb/qa";
+/**
+ * File paths for QA plugin data storage (relative to monorepo root).
+ */
+declare const PATHS: {
+    readonly BASELINE: ".kb/qa/baseline.json";
+    readonly HISTORY: ".kb/qa/history.json";
+    readonly CACHE: ".kb/qa/cache.json";
+    readonly LAST_RUN: ".kb/qa/last-run.json";
+};
+/**
+ * Maximum number of history entries to keep.
+ */
+declare const HISTORY_MAX_ENTRIES = 50;
+/**
+ * Default number of entries for trend analysis window.
+ */
+declare const TRENDS_WINDOW = 10;
+/**
+ * Get display label for a check type. Priority: configName > known default > id.
+ */
+declare function getCheckLabel(id: string, configName?: string): string;
+/**
+ * Get display icon (emoji) for a check type. Priority: configIcon > known default > generic.
+ */
+declare function getCheckIcon(id: string, configIcon?: string): string;
+
+/**
+ * @module @kb-labs/qa-contracts/routes
+ * REST API route constants for QA plugin
+ */
+/**
+ * REST API base path for QA plugin
+ */
+declare const QA_BASE_PATH: "/v1/plugins/qa";
+/**
+ * REST API route paths (relative to basePath)
+ */
+declare const QA_ROUTES: {
+    /** GET /summary - Aggregated QA overview */
+    readonly SUMMARY: "/summary";
+    /** GET /latest - Last QA run result */
+    readonly LATEST: "/latest";
+    /** GET /history - QA run history */
+    readonly HISTORY: "/history";
+    /** GET /trends - Trend analysis */
+    readonly TRENDS: "/trends";
+    /** GET /regressions - Regression detection */
+    readonly REGRESSIONS: "/regressions";
+    /** GET /baseline - Current baseline snapshot */
+    readonly BASELINE: "/baseline";
+    /** POST /run - Run QA checks */
+    readonly RUN: "/run";
+    /** GET /details - Per-package details with errors from last run */
+    readonly DETAILS: "/details";
+    /** POST /run/check - Run a single check type */
+    readonly RUN_CHECK: "/run/check";
+    /** POST /baseline/update - Update baseline from last run */
+    readonly BASELINE_UPDATE: "/baseline/update";
+    /** GET /baseline/diff - Diff current state vs baseline */
+    readonly BASELINE_DIFF: "/baseline/diff";
+    /** GET /packages/:name/timeline - Per-package QA history timeline */
+    readonly PACKAGE_TIMELINE: "/packages/:name/timeline";
+    /** GET /errors/groups - Grouped errors by pattern */
+    readonly ERROR_GROUPS: "/errors/groups";
+};
+/**
+ * Full REST API URLs (basePath + route)
+ * Useful for testing and documentation
+ */
+declare const QA_FULL_ROUTES: {
+    readonly SUMMARY: "/v1/plugins/qa/summary";
+    readonly LATEST: "/v1/plugins/qa/latest";
+    readonly HISTORY: "/v1/plugins/qa/history";
+    readonly TRENDS: "/v1/plugins/qa/trends";
+    readonly REGRESSIONS: "/v1/plugins/qa/regressions";
+    readonly BASELINE: "/v1/plugins/qa/baseline";
+    readonly RUN: "/v1/plugins/qa/run";
+    readonly DETAILS: "/v1/plugins/qa/details";
+    readonly RUN_CHECK: "/v1/plugins/qa/run/check";
+    readonly BASELINE_UPDATE: "/v1/plugins/qa/baseline/update";
+    readonly BASELINE_DIFF: "/v1/plugins/qa/baseline/diff";
+    readonly PACKAGE_TIMELINE: "/v1/plugins/qa/packages/:name/timeline";
+    readonly ERROR_GROUPS: "/v1/plugins/qa/errors/groups";
+};
+type QARoute = typeof QA_ROUTES[keyof typeof QA_ROUTES];
+
+export { type BaselineCheckSnapshot, type BaselineDiff, type BaselineSnapshot, type CategoryConfig, type CategoryGroup, type CheckDiff, type CheckResult, type CheckType, type EnrichedTrendResult, type ErrorGroup, type GitInfo, type GroupSummary, type GroupedResults, HISTORY_MAX_ENTRIES, type HistoryEntry, PATHS, type PackageCheckDetail, type PackageFilter, type PackageStatus, type PackageTimelineEntry, type PackageTimelineResponse, type PackagesConfig, type QABaselineDiffRequest, QABaselineDiffRequestSchema, type QABaselineDiffResponse, QABaselineDiffResponseSchema, type QABaselineRequest, QABaselineRequestSchema, type QABaselineResponse, QABaselineResponseSchema, type QABaselineUpdateRequest, QABaselineUpdateRequestSchema, type QABaselineUpdateResponse, QABaselineUpdateResponseSchema, type QACheckConfig, type QADetailsRequest, QADetailsRequestSchema, type QADetailsResponse, QADetailsResponseSchema, type QAEnrichedTrendsResponse, QAEnrichedTrendsResponseSchema, type QAErrorGroupsRequest, QAErrorGroupsRequestSchema, type QAErrorGroupsResponse, QAErrorGroupsResponseSchema, type QAHistoryRequest, QAHistoryRequestSchema, type QAHistoryResponse, QAHistoryResponseSchema, type QALatestRequest, QALatestRequestSchema, type QALatestResponse, QALatestResponseSchema, type QAPackageTimelineRequest, QAPackageTimelineRequestSchema, type QAPackageTimelineResponse, QAPackageTimelineResponseSchema, type QAPluginConfig, type QARegressionsRequest, QARegressionsRequestSchema, type QARegressionsResponse, QARegressionsResponseSchema, type QAReport, type QAResults, type QARoute, type QARunCheckRequest, QARunCheckRequestSchema, type QARunCheckResponse, QARunCheckResponseSchema, type QARunOptions, type QARunRequest, QARunRequestSchema, type QARunResponse, QARunResponseSchema, type QARunResult, QASummaryCheckSchema, type QASummaryRequest, QASummaryRequestSchema, type QASummaryResponse, QASummaryResponseSchema, type QATrendsRequest, QATrendsRequestSchema, type QATrendsResponse, QATrendsResponseSchema, QA_BASE_PATH, QA_DATA_DIR, QA_FULL_ROUTES, QA_ROUTES, type RegressionEntry, type RegressionResult, type RepoGroup, type ReportSummary, type SubmoduleInfo, TRENDS_WINDOW, type TrendChangelogEntry, type TrendResult, type TrendTimeSeriesPoint, type WorkspacePackage, getCheckIcon, getCheckLabel };