@remnic/bench 9.49.0 → 9.49.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { GatewayConfig, FallbackLlmRuntimeContext, FallbackLlmClient, EngramAccessService } from '@remnic/core';
+import { z } from 'zod';
 
 /**
  * Types for the ingestion benchmark tier.
@@ -1906,8 +1907,12 @@ declare function parseCodexJsonlUsage(output: string): CodexCliNativeUsage | und
 declare function calculateCodexBudgetUnits(model: string, usage: CodexCliNativeUsage): number;
 declare function buildCodexCreditReceipt(ledgerPath: string, runId?: string): Promise<CodexCreditReceipt>;
 
-declare const BENCHMARK_REPRO_MANIFEST_FILENAME = "MANIFEST.json";
-declare const BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION = 1;
+declare const BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION = 2;
+interface BenchmarkReproManifestSupplementalArtifact {
+    path: string;
+    sha256: string;
+    sizeBytes: number;
+}
 interface BenchmarkReproManifestFile {
     path: string;
     kind: "file" | "symlink";
@@ -1973,7 +1978,7 @@ interface BenchmarkReproManifest {
         platform: NodeJS.Platform;
         arch: string;
         nodeVersion: string;
-        hostname: string;
+        hostname?: string;
         packageManager?: string;
     };
     qmd?: {
@@ -1991,9 +1996,12 @@ interface BenchmarkReproManifest {
     }>;
     datasets: BenchmarkReproManifestDataset[];
     results: BenchmarkReproManifestResult[];
+    supplementalArtifacts?: BenchmarkReproManifestSupplementalArtifact[];
     codexCredit?: CodexCreditReceipt;
     artifactHash: string;
 }
+
+declare const BENCHMARK_REPRO_MANIFEST_FILENAME = "MANIFEST.json";
 interface BuildBenchmarkReproManifestOptions {
     resultPaths?: string[];
     runId?: string;
@@ -2022,7 +2030,14 @@ interface BuildBenchmarkReproManifestOptions {
         cacheDir?: string;
         collections?: string[];
     };
+    supplementalArtifactPaths?: string[];
+    publicSafe?: boolean;
+    generatedAt?: string;
 }
+/** Recompute the public integrity hash for a manifest before its hash field is attached. */
+declare function computeBenchmarkReproManifestArtifactHash(manifest: Omit<BenchmarkReproManifest, "artifactHash">): string;
+/** Recompute the canonical sorted-file inventory hash stored on a dataset entry. */
+declare function computeBenchmarkReproDatasetInventoryHash(files: BenchmarkReproManifestFile[]): string;
 declare function buildBenchmarkReproManifest(resultsDir: string, options?: BuildBenchmarkReproManifestOptions): Promise<BenchmarkReproManifest>;
 declare function writeBenchmarkReproManifest(resultsDir: string, options?: BuildBenchmarkReproManifestOptions): Promise<string>;
 
@@ -2379,9 +2394,20 @@ declare function createCodexCliProvider(config: CodexCliProviderConfig, deps?: C
  */
 
 declare function redactBenchmarkResultSecrets<T>(value: T): T;
+declare function sanitizeBenchmarkResultForJson<T>(value: T): T;
 declare function writeBenchmarkResult(result: BenchmarkResult, outputDir: string): Promise<string>;
 declare function getRemnicVersion(): Promise<string>;
 declare function getGitSha(): string;
+interface BenchmarkExecutionProvenance {
+    gitSha: string;
+    runId: string;
+    gitDirty: boolean;
+    gitDirtyEntryCount: number;
+}
+/** Capture source and ledger identity at the start of benchmark execution. */
+declare function captureBenchmarkExecutionProvenance(): BenchmarkExecutionProvenance;
+
+declare function resolveBenchmarkRunId(env?: NodeJS.ProcessEnv): string;
 
 interface DiscoverAllProvidersOptions {
     includeCodexCli?: boolean;
@@ -2432,7 +2458,7 @@ interface AmaBenchLeaderboardRow {
 }
 declare function writeLeaderboardArtifactsForResult(result: BenchmarkResult, outputDir: string): Promise<LeaderboardArtifactWrite[]>;
 declare function buildAmaBenchLeaderboardRows(result: BenchmarkResult): AmaBenchLeaderboardRow[];
-declare function serializeJsonl(rows: readonly AmaBenchLeaderboardRow[]): string;
+declare function serializeJsonl<T>(rows: readonly T[]): string;
 
 type AmaBenchDiagnosticRecallMode = "remnic-full" | "explicit-evidence-only" | "oracle-trajectory";
 type AmaBenchDiagnosticAnswererMode = "normal" | "strong";
@@ -5849,6 +5875,3409 @@ declare function checkCodingGraphRegression(report: CodingGraphBenchReport, base
  */
 declare function buildBaselineFromReport(report: CodingGraphBenchReport, note: string): CodingGraphBaseline;
 
+declare const H6_TRAP_IDS: readonly ["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"];
+type H6TrapId = (typeof H6_TRAP_IDS)[number];
+declare const GATE_STATUSES: readonly ["NO_MATCH", "MATCH_WARN", "ERROR_FAIL_OPEN"];
+type GateStatus = (typeof GATE_STATUSES)[number];
+declare const STATE_CLASSIFICATIONS: readonly ["UNFIXED", "TRAPPED", "FIXED", "no-trap"];
+type StateClassification = (typeof STATE_CLASSIFICATIONS)[number];
+declare const DATASET_SPLITS: readonly ["dev", "pilot", "main"];
+type DatasetSplit = (typeof DATASET_SPLITS)[number];
+declare const H6_FROZEN_SEED = 81;
+declare const H6_FROZEN_INVENTORY_HASH = "687615b5f7ff46977d268a03e30018070f7d0bec9d01e04da2d0c723e59a5b27";
+declare const H6_FROZEN_SPLITS: Readonly<{
+    dev: readonly never[];
+    pilot: readonly string[];
+    main: readonly string[];
+}>;
+declare const TrapFingerprintV1Schema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+    symbol: z.ZodString;
+    file: z.ZodString;
+    pattern: z.ZodString;
+    strategyId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    pattern: string;
+    version: 1;
+    file: string;
+    trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+    strategyId: string;
+}, {
+    symbol: string;
+    pattern: string;
+    version: 1;
+    file: string;
+    trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+    strategyId: string;
+}>;
+type TrapFingerprintV1 = z.infer<typeof TrapFingerprintV1Schema>;
+declare const ActionIntentV1Schema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    actionType: z.ZodString;
+    targetSymbol: z.ZodString;
+    filePath: z.ZodString;
+    contextHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    actionType: string;
+    targetSymbol: string;
+    filePath: string;
+    contextHash: string;
+}, {
+    version: 1;
+    actionType: string;
+    targetSymbol: string;
+    filePath: string;
+    contextHash: string;
+}>;
+type ActionIntentV1 = z.infer<typeof ActionIntentV1Schema>;
+declare const SyntheticFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    isExecutable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+    isExecutable?: boolean | undefined;
+}, {
+    path: string;
+    content: string;
+    isExecutable?: boolean | undefined;
+}>;
+type SyntheticFile = z.infer<typeof SyntheticFileSchema>;
+declare const StrategyPatchSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        isExecutable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    files: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    description: string;
+}, {
+    id: string;
+    files: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    description: string;
+}>;
+type StrategyPatch = z.infer<typeof StrategyPatchSchema>;
+declare const TaskVariantSchema: z.ZodObject<{
+    variantId: z.ZodString;
+    baseTaskId: z.ZodString;
+    variantIndex: z.ZodNumber;
+    distance: z.ZodNumber;
+    domain: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        isExecutable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }>, "many">;
+    strategyCandidates: z.ZodTuple<[z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }>], null>;
+    badStrategyPatch: z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }>;
+    goodStrategyPatch: z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }>;
+    noTrapControlFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        isExecutable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }>, "many">;
+    cleanRevisionSha: z.ZodString;
+    trapRevisionSha: z.ZodString;
+    rightRevisionSha: z.ZodString;
+    noTrapRevisionSha: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    files: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    domain: string;
+    distance: number;
+    variantId: string;
+    baseTaskId: string;
+    variantIndex: number;
+    strategyCandidates: [{
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }];
+    badStrategyPatch: {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    };
+    goodStrategyPatch: {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    };
+    noTrapControlFiles: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    cleanRevisionSha: string;
+    trapRevisionSha: string;
+    rightRevisionSha: string;
+    noTrapRevisionSha: string;
+}, {
+    files: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    domain: string;
+    distance: number;
+    variantId: string;
+    baseTaskId: string;
+    variantIndex: number;
+    strategyCandidates: [{
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }, {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    }];
+    badStrategyPatch: {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    };
+    goodStrategyPatch: {
+        id: string;
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        description: string;
+    };
+    noTrapControlFiles: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    cleanRevisionSha: string;
+    trapRevisionSha: string;
+    rightRevisionSha: string;
+    noTrapRevisionSha: string;
+}>;
+type TaskVariant = z.infer<typeof TaskVariantSchema>;
+declare const BaseTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+    domain: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    canonicalBaseFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        isExecutable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }, {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }>, "many">;
+    checkCommand: z.ZodString;
+    fileCount: z.ZodNumber;
+    lineCount: z.ZodNumber;
+    fingerprint: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+        symbol: z.ZodString;
+        file: z.ZodString;
+        pattern: z.ZodString;
+        strategyId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        pattern: string;
+        version: 1;
+        file: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        strategyId: string;
+    }, {
+        symbol: string;
+        pattern: string;
+        version: 1;
+        file: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        strategyId: string;
+    }>;
+    normalizedActionIntent: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        actionType: z.ZodString;
+        targetSymbol: z.ZodString;
+        filePath: z.ZodString;
+        contextHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        version: 1;
+        actionType: string;
+        targetSymbol: string;
+        filePath: string;
+        contextHash: string;
+    }, {
+        version: 1;
+        actionType: string;
+        targetSymbol: string;
+        filePath: string;
+        contextHash: string;
+    }>;
+    offlineCheckMark: z.ZodString;
+    offlineFailureMark: z.ZodString;
+    maxTokenCap: z.ZodNumber;
+    maxAttemptCap: z.ZodNumber;
+    split: z.ZodEnum<["dev", "pilot", "main"]>;
+    variants: z.ZodArray<z.ZodObject<{
+        variantId: z.ZodString;
+        baseTaskId: z.ZodString;
+        variantIndex: z.ZodNumber;
+        distance: z.ZodNumber;
+        domain: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+        strategyCandidates: z.ZodTuple<[z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                isExecutable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }>, z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                isExecutable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }>], null>;
+        badStrategyPatch: z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                isExecutable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }>;
+        goodStrategyPatch: z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                isExecutable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }>;
+        noTrapControlFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+        cleanRevisionSha: z.ZodString;
+        trapRevisionSha: z.ZodString;
+        rightRevisionSha: z.ZodString;
+        noTrapRevisionSha: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        domain: string;
+        distance: number;
+        variantId: string;
+        baseTaskId: string;
+        variantIndex: number;
+        strategyCandidates: [{
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }];
+        badStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        goodStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        noTrapControlFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        cleanRevisionSha: string;
+        trapRevisionSha: string;
+        rightRevisionSha: string;
+        noTrapRevisionSha: string;
+    }, {
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        domain: string;
+        distance: number;
+        variantId: string;
+        baseTaskId: string;
+        variantIndex: number;
+        strategyCandidates: [{
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }];
+        badStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        goodStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        noTrapControlFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        cleanRevisionSha: string;
+        trapRevisionSha: string;
+        rightRevisionSha: string;
+        noTrapRevisionSha: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    split: "dev" | "main" | "pilot";
+    id: string;
+    fileCount: number;
+    description: string;
+    domain: string;
+    lineCount: number;
+    trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+    canonicalBaseFiles: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    checkCommand: string;
+    fingerprint: {
+        symbol: string;
+        pattern: string;
+        version: 1;
+        file: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        strategyId: string;
+    };
+    normalizedActionIntent: {
+        version: 1;
+        actionType: string;
+        targetSymbol: string;
+        filePath: string;
+        contextHash: string;
+    };
+    offlineCheckMark: string;
+    offlineFailureMark: string;
+    maxTokenCap: number;
+    maxAttemptCap: number;
+    variants: {
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        domain: string;
+        distance: number;
+        variantId: string;
+        baseTaskId: string;
+        variantIndex: number;
+        strategyCandidates: [{
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }];
+        badStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        goodStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        noTrapControlFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        cleanRevisionSha: string;
+        trapRevisionSha: string;
+        rightRevisionSha: string;
+        noTrapRevisionSha: string;
+    }[];
+}, {
+    title: string;
+    split: "dev" | "main" | "pilot";
+    id: string;
+    fileCount: number;
+    description: string;
+    domain: string;
+    lineCount: number;
+    trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+    canonicalBaseFiles: {
+        path: string;
+        content: string;
+        isExecutable?: boolean | undefined;
+    }[];
+    checkCommand: string;
+    fingerprint: {
+        symbol: string;
+        pattern: string;
+        version: 1;
+        file: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        strategyId: string;
+    };
+    normalizedActionIntent: {
+        version: 1;
+        actionType: string;
+        targetSymbol: string;
+        filePath: string;
+        contextHash: string;
+    };
+    offlineCheckMark: string;
+    offlineFailureMark: string;
+    maxTokenCap: number;
+    maxAttemptCap: number;
+    variants: {
+        files: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        domain: string;
+        distance: number;
+        variantId: string;
+        baseTaskId: string;
+        variantIndex: number;
+        strategyCandidates: [{
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }, {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        }];
+        badStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        goodStrategyPatch: {
+            id: string;
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            description: string;
+        };
+        noTrapControlFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        cleanRevisionSha: string;
+        trapRevisionSha: string;
+        rightRevisionSha: string;
+        noTrapRevisionSha: string;
+    }[];
+}>;
+type BaseTask = z.infer<typeof BaseTaskSchema>;
+declare const TrapTaxonomyItemSchema: z.ZodObject<{
+    trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    trapMechanism: z.ZodString;
+    correctFix: z.ZodString;
+    inspiredBy: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+    trapMechanism: string;
+    correctFix: string;
+    inspiredBy: string;
+}, {
+    name: string;
+    description: string;
+    trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+    trapMechanism: string;
+    correctFix: string;
+    inspiredBy: string;
+}>;
+type TrapTaxonomyItem = z.infer<typeof TrapTaxonomyItemSchema>;
+declare const H6BenchmarkDatasetSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    seed: z.ZodNumber;
+    createdAt: z.ZodString;
+    inventoryHash: z.ZodString;
+    supportArtifactHashes: z.ZodObject<{
+        "trap-taxonomy.json": z.ZodString;
+        "arms/arms.json": z.ZodString;
+        "schema/action-intent.schema.json": z.ZodString;
+        "schema/dataset.schema.json": z.ZodString;
+        "schema/task.schema.json": z.ZodString;
+        "schema/trap-fingerprint.schema.json": z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        "trap-taxonomy.json": string;
+        "arms/arms.json": string;
+        "schema/action-intent.schema.json": string;
+        "schema/dataset.schema.json": string;
+        "schema/task.schema.json": string;
+        "schema/trap-fingerprint.schema.json": string;
+    }, {
+        "trap-taxonomy.json": string;
+        "arms/arms.json": string;
+        "schema/action-intent.schema.json": string;
+        "schema/dataset.schema.json": string;
+        "schema/task.schema.json": string;
+        "schema/trap-fingerprint.schema.json": string;
+    }>;
+    taxonomy: z.ZodArray<z.ZodObject<{
+        trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+        name: z.ZodString;
+        description: z.ZodString;
+        trapMechanism: z.ZodString;
+        correctFix: z.ZodString;
+        inspiredBy: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        trapMechanism: string;
+        correctFix: string;
+        inspiredBy: string;
+    }, {
+        name: string;
+        description: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        trapMechanism: string;
+        correctFix: string;
+        inspiredBy: string;
+    }>, "many">;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+        domain: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        canonicalBaseFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            isExecutable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }, {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }>, "many">;
+        checkCommand: z.ZodString;
+        fileCount: z.ZodNumber;
+        lineCount: z.ZodNumber;
+        fingerprint: z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            trapId: z.ZodEnum<["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"]>;
+            symbol: z.ZodString;
+            file: z.ZodString;
+            pattern: z.ZodString;
+            strategyId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            symbol: string;
+            pattern: string;
+            version: 1;
+            file: string;
+            trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+            strategyId: string;
+        }, {
+            symbol: string;
+            pattern: string;
+            version: 1;
+            file: string;
+            trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+            strategyId: string;
+        }>;
+        normalizedActionIntent: z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            actionType: z.ZodString;
+            targetSymbol: z.ZodString;
+            filePath: z.ZodString;
+            contextHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            version: 1;
+            actionType: string;
+            targetSymbol: string;
+            filePath: string;
+            contextHash: string;
+        }, {
+            version: 1;
+            actionType: string;
+            targetSymbol: string;
+            filePath: string;
+            contextHash: string;
+        }>;
+        offlineCheckMark: z.ZodString;
+        offlineFailureMark: z.ZodString;
+        maxTokenCap: z.ZodNumber;
+        maxAttemptCap: z.ZodNumber;
+        split: z.ZodEnum<["dev", "pilot", "main"]>;
+        variants: z.ZodArray<z.ZodObject<{
+            variantId: z.ZodString;
+            baseTaskId: z.ZodString;
+            variantIndex: z.ZodNumber;
+            distance: z.ZodNumber;
+            domain: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                isExecutable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }>, "many">;
+            strategyCandidates: z.ZodTuple<[z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    content: z.ZodString;
+                    isExecutable: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }>, z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    content: z.ZodString;
+                    isExecutable: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }>], null>;
+            badStrategyPatch: z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    content: z.ZodString;
+                    isExecutable: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }>;
+            goodStrategyPatch: z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    content: z.ZodString;
+                    isExecutable: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }, {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }>;
+            noTrapControlFiles: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                isExecutable: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }, {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }>, "many">;
+            cleanRevisionSha: z.ZodString;
+            trapRevisionSha: z.ZodString;
+            rightRevisionSha: z.ZodString;
+            noTrapRevisionSha: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            domain: string;
+            distance: number;
+            variantId: string;
+            baseTaskId: string;
+            variantIndex: number;
+            strategyCandidates: [{
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }];
+            badStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            goodStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            noTrapControlFiles: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            cleanRevisionSha: string;
+            trapRevisionSha: string;
+            rightRevisionSha: string;
+            noTrapRevisionSha: string;
+        }, {
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            domain: string;
+            distance: number;
+            variantId: string;
+            baseTaskId: string;
+            variantIndex: number;
+            strategyCandidates: [{
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }];
+            badStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            goodStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            noTrapControlFiles: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            cleanRevisionSha: string;
+            trapRevisionSha: string;
+            rightRevisionSha: string;
+            noTrapRevisionSha: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        split: "dev" | "main" | "pilot";
+        id: string;
+        fileCount: number;
+        description: string;
+        domain: string;
+        lineCount: number;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        canonicalBaseFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        checkCommand: string;
+        fingerprint: {
+            symbol: string;
+            pattern: string;
+            version: 1;
+            file: string;
+            trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+            strategyId: string;
+        };
+        normalizedActionIntent: {
+            version: 1;
+            actionType: string;
+            targetSymbol: string;
+            filePath: string;
+            contextHash: string;
+        };
+        offlineCheckMark: string;
+        offlineFailureMark: string;
+        maxTokenCap: number;
+        maxAttemptCap: number;
+        variants: {
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            domain: string;
+            distance: number;
+            variantId: string;
+            baseTaskId: string;
+            variantIndex: number;
+            strategyCandidates: [{
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }];
+            badStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            goodStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            noTrapControlFiles: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            cleanRevisionSha: string;
+            trapRevisionSha: string;
+            rightRevisionSha: string;
+            noTrapRevisionSha: string;
+        }[];
+    }, {
+        title: string;
+        split: "dev" | "main" | "pilot";
+        id: string;
+        fileCount: number;
+        description: string;
+        domain: string;
+        lineCount: number;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        canonicalBaseFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        checkCommand: string;
+        fingerprint: {
+            symbol: string;
+            pattern: string;
+            version: 1;
+            file: string;
+            trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+            strategyId: string;
+        };
+        normalizedActionIntent: {
+            version: 1;
+            actionType: string;
+            targetSymbol: string;
+            filePath: string;
+            contextHash: string;
+        };
+        offlineCheckMark: string;
+        offlineFailureMark: string;
+        maxTokenCap: number;
+        maxAttemptCap: number;
+        variants: {
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            domain: string;
+            distance: number;
+            variantId: string;
+            baseTaskId: string;
+            variantIndex: number;
+            strategyCandidates: [{
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }];
+            badStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            goodStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            noTrapControlFiles: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            cleanRevisionSha: string;
+            trapRevisionSha: string;
+            rightRevisionSha: string;
+            noTrapRevisionSha: string;
+        }[];
+    }>, "many">;
+    splits: z.ZodObject<{
+        dev: z.ZodArray<z.ZodString, "many">;
+        pilot: z.ZodArray<z.ZodString, "many">;
+        main: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        dev: string[];
+        main: string[];
+        pilot: string[];
+    }, {
+        dev: string[];
+        main: string[];
+        pilot: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    tasks: {
+        title: string;
+        split: "dev" | "main" | "pilot";
+        id: string;
+        fileCount: number;
+        description: string;
+        domain: string;
+        lineCount: number;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        canonicalBaseFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        checkCommand: string;
+        fingerprint: {
+            symbol: string;
+            pattern: string;
+            version: 1;
+            file: string;
+            trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+            strategyId: string;
+        };
+        normalizedActionIntent: {
+            version: 1;
+            actionType: string;
+            targetSymbol: string;
+            filePath: string;
+            contextHash: string;
+        };
+        offlineCheckMark: string;
+        offlineFailureMark: string;
+        maxTokenCap: number;
+        maxAttemptCap: number;
+        variants: {
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            domain: string;
+            distance: number;
+            variantId: string;
+            baseTaskId: string;
+            variantIndex: number;
+            strategyCandidates: [{
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }];
+            badStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            goodStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            noTrapControlFiles: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            cleanRevisionSha: string;
+            trapRevisionSha: string;
+            rightRevisionSha: string;
+            noTrapRevisionSha: string;
+        }[];
+    }[];
+    seed: number;
+    createdAt: string;
+    inventoryHash: string;
+    supportArtifactHashes: {
+        "trap-taxonomy.json": string;
+        "arms/arms.json": string;
+        "schema/action-intent.schema.json": string;
+        "schema/dataset.schema.json": string;
+        "schema/task.schema.json": string;
+        "schema/trap-fingerprint.schema.json": string;
+    };
+    taxonomy: {
+        name: string;
+        description: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        trapMechanism: string;
+        correctFix: string;
+        inspiredBy: string;
+    }[];
+    splits: {
+        dev: string[];
+        main: string[];
+        pilot: string[];
+    };
+}, {
+    version: 1;
+    tasks: {
+        title: string;
+        split: "dev" | "main" | "pilot";
+        id: string;
+        fileCount: number;
+        description: string;
+        domain: string;
+        lineCount: number;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        canonicalBaseFiles: {
+            path: string;
+            content: string;
+            isExecutable?: boolean | undefined;
+        }[];
+        checkCommand: string;
+        fingerprint: {
+            symbol: string;
+            pattern: string;
+            version: 1;
+            file: string;
+            trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+            strategyId: string;
+        };
+        normalizedActionIntent: {
+            version: 1;
+            actionType: string;
+            targetSymbol: string;
+            filePath: string;
+            contextHash: string;
+        };
+        offlineCheckMark: string;
+        offlineFailureMark: string;
+        maxTokenCap: number;
+        maxAttemptCap: number;
+        variants: {
+            files: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            domain: string;
+            distance: number;
+            variantId: string;
+            baseTaskId: string;
+            variantIndex: number;
+            strategyCandidates: [{
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }, {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            }];
+            badStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            goodStrategyPatch: {
+                id: string;
+                files: {
+                    path: string;
+                    content: string;
+                    isExecutable?: boolean | undefined;
+                }[];
+                description: string;
+            };
+            noTrapControlFiles: {
+                path: string;
+                content: string;
+                isExecutable?: boolean | undefined;
+            }[];
+            cleanRevisionSha: string;
+            trapRevisionSha: string;
+            rightRevisionSha: string;
+            noTrapRevisionSha: string;
+        }[];
+    }[];
+    seed: number;
+    createdAt: string;
+    inventoryHash: string;
+    supportArtifactHashes: {
+        "trap-taxonomy.json": string;
+        "arms/arms.json": string;
+        "schema/action-intent.schema.json": string;
+        "schema/dataset.schema.json": string;
+        "schema/task.schema.json": string;
+        "schema/trap-fingerprint.schema.json": string;
+    };
+    taxonomy: {
+        name: string;
+        description: string;
+        trapId: "flaky-looking-test" | "misleading-error-message" | "wrong-layer-fix" | "hidden-invariant" | "stale-cache-illusion" | "config-shadowing";
+        trapMechanism: string;
+        correctFix: string;
+        inspiredBy: string;
+    }[];
+    splits: {
+        dev: string[];
+        main: string[];
+        pilot: string[];
+    };
+}>;
+type H6BenchmarkDataset = z.infer<typeof H6BenchmarkDatasetSchema>;
+interface StateEvaluationResult {
+    state: StateClassification;
+    gateStatus: GateStatus;
+    fingerprintMatched: boolean;
+    testPassed: boolean;
+    exitCode: number;
+    reason: string;
+}
+interface EvaluateTaskStateOptions {
+    isNoTrapControl?: boolean;
+}
+
+declare const H6_SUPPORT_ARTIFACT_PATHS: readonly ["trap-taxonomy.json", "arms/arms.json", "schema/action-intent.schema.json", "schema/dataset.schema.json", "schema/task.schema.json", "schema/trap-fingerprint.schema.json"];
+declare const H6_ACTION_INTENT_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "action-intent.schema.json";
+    readonly title: "H6ActionIntentV1";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version", "actionType", "targetSymbol", "filePath", "contextHash"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "integer";
+            readonly const: 1;
+        };
+        readonly actionType: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly targetSymbol: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly filePath: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly contextHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+declare const H6_TRAP_FINGERPRINT_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "trap-fingerprint.schema.json";
+    readonly title: "H6TrapFingerprintV1";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version", "trapId", "symbol", "file", "pattern", "strategyId"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "integer";
+            readonly const: 1;
+        };
+        readonly trapId: {
+            readonly type: "string";
+            readonly enum: readonly ["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"];
+        };
+        readonly symbol: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly file: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly pattern: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly strategyId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+declare const H6_TASK_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "task.schema.json";
+    readonly title: "H6BaseTask";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["id", "trapId", "domain", "title", "description", "canonicalBaseFiles", "checkCommand", "fileCount", "lineCount", "fingerprint", "normalizedActionIntent", "offlineCheckMark", "offlineFailureMark", "maxTokenCap", "maxAttemptCap", "split", "variants"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly trapId: {
+            readonly type: "string";
+            readonly enum: readonly ["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"];
+        };
+        readonly domain: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly canonicalBaseFiles: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly $ref: "#/definitions/syntheticFile";
+            };
+        };
+        readonly checkCommand: {
+            readonly type: "string";
+            readonly const: "node test/check.js";
+        };
+        readonly fileCount: {
+            readonly type: "integer";
+            readonly minimum: 8;
+            readonly maximum: 15;
+        };
+        readonly lineCount: {
+            readonly type: "integer";
+            readonly minimum: 300;
+            readonly maximum: 600;
+        };
+        readonly fingerprint: {
+            readonly $ref: "./trap-fingerprint.schema.json";
+        };
+        readonly normalizedActionIntent: {
+            readonly $ref: "./action-intent.schema.json";
+        };
+        readonly offlineCheckMark: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly offlineFailureMark: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly maxTokenCap: {
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+        readonly maxAttemptCap: {
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+        readonly split: {
+            readonly type: "string";
+            readonly enum: readonly ["dev", "pilot", "main"];
+        };
+        readonly variants: {
+            readonly type: "array";
+            readonly minItems: 3;
+            readonly maxItems: 3;
+            readonly items: {
+                readonly $ref: "#/definitions/taskVariant";
+            };
+        };
+    };
+    readonly definitions: {
+        readonly syntheticFile: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["path", "content"];
+            readonly properties: {
+                readonly path: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly content: {
+                    readonly type: "string";
+                };
+                readonly isExecutable: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly strategyPatch: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "description", "files"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly description: {
+                    readonly type: "string";
+                };
+                readonly files: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/syntheticFile";
+                    };
+                };
+            };
+        };
+        readonly taskVariant: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["variantId", "baseTaskId", "variantIndex", "distance", "domain", "files", "strategyCandidates", "badStrategyPatch", "goodStrategyPatch", "noTrapControlFiles", "cleanRevisionSha", "trapRevisionSha", "rightRevisionSha", "noTrapRevisionSha"];
+            readonly properties: {
+                readonly variantId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly baseTaskId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly variantIndex: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 3;
+                };
+                readonly distance: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 3;
+                };
+                readonly domain: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly files: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/syntheticFile";
+                    };
+                };
+                readonly strategyCandidates: {
+                    readonly type: "array";
+                    readonly minItems: 2;
+                    readonly maxItems: 2;
+                    readonly items: {
+                        readonly $ref: "#/definitions/strategyPatch";
+                    };
+                };
+                readonly badStrategyPatch: {
+                    readonly $ref: "#/definitions/strategyPatch";
+                };
+                readonly goodStrategyPatch: {
+                    readonly $ref: "#/definitions/strategyPatch";
+                };
+                readonly noTrapControlFiles: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/syntheticFile";
+                    };
+                };
+                readonly cleanRevisionSha: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9a-f]{40}$";
+                };
+                readonly trapRevisionSha: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9a-f]{40}$";
+                };
+                readonly rightRevisionSha: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9a-f]{40}$";
+                };
+                readonly noTrapRevisionSha: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9a-f]{40}$";
+                };
+            };
+        };
+    };
+};
+declare const H6_DATASET_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "dataset.schema.json";
+    readonly title: "H6BenchmarkDataset";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version", "seed", "createdAt", "inventoryHash", "supportArtifactHashes", "taxonomy", "tasks", "splits"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "integer";
+            readonly const: 1;
+        };
+        readonly seed: {
+            readonly type: "integer";
+        };
+        readonly createdAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly inventoryHash: {
+            readonly type: "string";
+            readonly pattern: "^[0-9a-f]{64}$";
+        };
+        readonly supportArtifactHashes: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["trap-taxonomy.json", "arms/arms.json", "schema/action-intent.schema.json", "schema/dataset.schema.json", "schema/task.schema.json", "schema/trap-fingerprint.schema.json"];
+            readonly properties: {
+                [k: string]: {
+                    type: string;
+                    pattern: string;
+                };
+            };
+        };
+        readonly taxonomy: {
+            readonly type: "array";
+            readonly minItems: 6;
+            readonly maxItems: 6;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["trapId", "name", "description", "trapMechanism", "correctFix", "inspiredBy"];
+                readonly properties: {
+                    readonly trapId: {
+                        readonly type: "string";
+                        readonly enum: readonly ["flaky-looking-test", "misleading-error-message", "wrong-layer-fix", "hidden-invariant", "stale-cache-illusion", "config-shadowing"];
+                    };
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly trapMechanism: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly correctFix: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly inspiredBy: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly tasks: {
+            readonly type: "array";
+            readonly minItems: 30;
+            readonly maxItems: 30;
+            readonly items: {
+                readonly $ref: "./task.schema.json";
+            };
+        };
+        readonly splits: {
+            readonly type: "object";
+            readonly required: readonly ["dev", "pilot", "main"];
+            readonly properties: {
+                readonly dev: {
+                    readonly type: "array";
+                    readonly minItems: 0;
+                    readonly maxItems: 0;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly pilot: {
+                    readonly type: "array";
+                    readonly minItems: 12;
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly main: {
+                    readonly type: "array";
+                    readonly minItems: 18;
+                    readonly maxItems: 18;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+    };
+};
+declare const H6_DECISION_RULE: {
+    readonly version: 10;
+    readonly name: "H6 Failure Gate Decision Rule";
+    readonly preregistration: {
+        readonly path: "docs/research/failure-gate/preregistration.md";
+        readonly sha256: "7c5bb227279b42f5e82aa2a0e7d05b7759736bee9a5e5893e1f126c95906b6aa";
+    };
+    readonly analysisPopulation: {
+        readonly datasetVersion: 1;
+        readonly datasetInventoryHash: "687615b5f7ff46977d268a03e30018070f7d0bec9d01e04da2d0c723e59a5b27";
+        readonly split: "main";
+        readonly taskCount: 18;
+        readonly seedsPerModelProfile: 5;
+        readonly modelProfileCount: 1;
+        readonly unit: "task";
+        readonly pairingKey: readonly ["taskId", "variantId", "seed", "modelProfileId", "modelProfileHash"];
+        readonly maximumPrimaryTaskCuts: 0;
+    };
+    readonly analysis: {
+        readonly bootstrap: {
+            readonly draws: 10000;
+            readonly group: "task";
+            readonly confidenceLevel: 0.95;
+            readonly method: "percentile";
+        };
+        readonly shuffle: {
+            readonly draws: 10000;
+            readonly group: "task";
+            readonly alternative: "candidate_benefit";
+            readonly plusOneCorrection: true;
+        };
+        readonly alpha: 0.05;
+        readonly multiplicity: {
+            readonly method: "HOLM";
+            readonly family: readonly ["H6_TIMING_REPEATED_FAILURE", "H6_CONTENT_COMPOUND"];
+            readonly contentCompoundP: "max(repeatedFailureP,taskPassP)";
+        };
+    };
+    readonly factMatching: {
+        readonly timing: {
+            readonly factCount: 1;
+            readonly requireSameFactIds: true;
+            readonly requireSameCitationHashes: true;
+            readonly requireSameRenderedTokenCount: true;
+        };
+        readonly content: {
+            readonly factCount: 1;
+            readonly requireSamePathShape: true;
+            readonly requireSameActionShape: true;
+            readonly textSimilarity: {
+                readonly metric: "normalized_token_set_jaccard";
+                readonly minimumInclusive: 0.8;
+                readonly maximumInclusive: 1;
+            };
+            readonly tokenCountGap: {
+                readonly maximumAbsolute: 8;
+                readonly maximumRelative: 0.05;
+                readonly requireBoth: true;
+            };
+        };
+    };
+    readonly hypotheses: {
+        readonly "H6-timing": {
+            readonly baselineArm: "TURN_START_FAILURE";
+            readonly candidateArm: "PRE_ACTION_FAILURE";
+            readonly metric: "repeatedFailure";
+            readonly minimumRelativeRiskReduction: 0.3;
+            readonly minimumAbsoluteRepeatedFailureBenefit: 0.05;
+            readonly requireRepeatedFailureBenefitIntervalLowerStrictlyAbove: 0;
+            readonly requireHolmAdjustedPStrictlyBelow: 0.05;
+            readonly zeroBaselineDecision: "NOT_ESTIMABLE";
+        };
+        readonly "H6-content": {
+            readonly baselineArm: "TURN_START_SUCCESS";
+            readonly candidateArm: "TURN_START_FAILURE";
+            readonly metrics: readonly ["repeatedFailure", "taskPassed"];
+            readonly requireRepeatedFailureBenefitIntervalLowerStrictlyAbove: 0;
+            readonly requireTaskPassBenefitIntervalLowerStrictlyAbove: 0;
+            readonly requireHolmAdjustedCompoundPStrictlyBelow: 0.05;
+            readonly unmatchedPairDecision: "NOT_ESTIMABLE";
+        };
+    };
+    readonly power: {
+        readonly simulationDraws: 10000;
+        readonly minimumTimingPower: 0.8;
+        readonly minimumContentPower: 0.8;
+        readonly sourceSplit: "pilot";
+        readonly increaseIndependentTasksIfBelowThreshold: true;
+    };
+    readonly trapAudit: {
+        readonly minimumTrappedRate: 0.3;
+        readonly minimumNonFixedRate: 0.5;
+        readonly maximumInvalidRows: 0;
+        readonly requireCompleteRows: true;
+    };
+    readonly timidity: {
+        readonly baselineArm: "NO_MEMORY";
+        readonly candidateArm: "PRE_ACTION_FAILURE";
+        readonly population: "main_no_trap_revisions";
+        readonly confidenceLevel: 0.9;
+        readonly passRateMargin: 0.02;
+        readonly stepsMargin: 2;
+        readonly requireIntervalsStrictlyInsideMargins: true;
+        readonly minimumSimulatedPower: 0.8;
+    };
+    readonly completeness: {
+        readonly expectedRowsFormula: "taskCount*variantsPerTask*seedsPerModelProfile*modelProfileCount*armCount";
+        readonly primaryArmCount: 5;
+        readonly hostFaultRetriesAfterFirstTry: 5;
+        readonly rerunTaskResults: false;
+        readonly invalidReasons: readonly ["CORPUS_INVALID", "CORE_REPO_DIR_MISMATCH", "START_DRIFT", "TRACE_GAP", "VAGUE_CHECK", "MIXED_ARM_STATE", "UNMATCHED_FACTS", "WAIT_RULE_FAULT", "HOST_RETRIES_EXHAUSTED"];
+    };
+    readonly outcomes: {
+        readonly PASS: "timing=SUPPORTED and content=SUPPORTED";
+        readonly PARTIAL: "exactly one primary is SUPPORTED and the other is REJECTED";
+        readonly REJECT: "timing=REJECTED and content=REJECTED";
+        readonly NOT_ESTIMABLE: "either primary is NOT_ESTIMABLE";
+    };
+    readonly gateStatuses: readonly ["NO_MATCH", "MATCH_WARN", "ERROR_FAIL_OPEN"];
+};
+declare const H6_ARMS: readonly [{
+    readonly id: "NO_MEMORY";
+    readonly name: "No Memory Baseline";
+    readonly description: "Floor baseline with no memory recall or gate warning active.";
+}, {
+    readonly id: "TURN_START_FAILURE";
+    readonly name: "Turn-Start Failure Memory Recall";
+    readonly description: "Failure trajectory recalled at turn start.";
+}, {
+    readonly id: "TURN_START_SUCCESS";
+    readonly name: "Turn-Start Success Memory Recall";
+    readonly description: "Matched success memories recalled at turn start.";
+}, {
+    readonly id: "PRE_ACTION_FAILURE";
+    readonly name: "Pre-Action Failure Gate";
+    readonly description: "Pre-action gate injects advisory warning prior to matched action execution.";
+}, {
+    readonly id: "BOTH";
+    readonly name: "Pre-Action Gate + Turn-Start Recall";
+    readonly description: "Both pre-action gate advisory and turn-start recall active.";
+}];
+declare function serializeH6FixtureJson(value: unknown): string;
+declare function computeH6SupportArtifactHashes(taxonomy: unknown): {
+    [K in (typeof H6_SUPPORT_ARTIFACT_PATHS)[number]]: string;
+};
+
+declare const TRAP_TAXONOMY: TrapTaxonomyItem[];
+declare function getTrapTaxonomyItem(trapId: H6TrapId): TrapTaxonomyItem;
+
+declare function computeH6InventoryHash(dataset: Omit<H6BenchmarkDataset, "inventoryHash">): string;
+declare const INVENTED_DOMAINS: readonly ["quillboard-inventory-sync", "nexus-billing-engine", "starlight-auth-vault", "nebula-cache-matrix", "hyperion-router-mesh", "cyber-telemetry-stream", "apex-payment-gateway", "quantum-order-pipeline", "pulse-notification-bus", "vector-session-store", "crypto-wallet-core", "analytics-beacon-hub", "media-transcoder-service", "identity-provider-node", "config-server-cluster", "search-index-cluster", "workflow-runner-engine", "storage-bucket-manager", "scheduler-daemon-service", "rate-limiter-filter", "feature-flag-service", "audit-logger-stream", "dns-resolver-cache", "load-balancer-proxy", "event-dispatcher-bus", "queue-worker-daemon", "metrics-collector-agent", "policy-enforcer-engine", "schema-registry-store", "secret-manager-vault"];
+declare function generateH6BenchmarkDataset(seed?: number): Promise<H6BenchmarkDataset>;
+
+interface MaterializeOptions {
+    authorName?: string;
+    authorEmail?: string;
+    commitDate?: string;
+    commitMessage?: string;
+}
+interface MaterializedRepo {
+    dir: string;
+    commitSha: string;
+    cleanup: () => Promise<void>;
+}
+declare function isSafeSyntheticPath(filePath: string): boolean;
+declare function materializeTaskRepo(files: SyntheticFile[], options?: MaterializeOptions): Promise<MaterializedRepo>;
+declare function applyPatchAndCommit(dir: string, patchFiles: SyntheticFile[], message?: string): Promise<string>;
+interface RevisionShas {
+    cleanSha: string;
+    trapSha: string;
+    rightSha: string;
+    noTrapSha: string;
+}
+declare function computeRevisionShas(cleanFiles: SyntheticFile[], badPatchFiles: SyntheticFile[], goodPatchFiles: SyntheticFile[], noTrapFiles: SyntheticFile[]): Promise<RevisionShas>;
+
+declare function tokenizeContent(text: string): Set<string>;
+declare function calculateJaccardSimilarity(textA: string, textB: string): number;
+declare function validateH6StateDefiningIndependence(dataset: H6BenchmarkDataset): {
+    maxSimilarity: number;
+    issues: ValidationIssue[];
+};
+
+declare function unresolvedHelperImports(files: readonly SyntheticFile[]): string[];
+
+declare function evaluateTaskState(_task: BaseTask, _variant: TaskVariant, files: SyntheticFile[], options?: EvaluateTaskStateOptions): Promise<StateEvaluationResult>;
+interface ValidationIssue {
+    code: string;
+    message: string;
+    path?: string;
+}
+interface ValidationReport {
+    valid: boolean;
+    issues: ValidationIssue[];
+    metrics: {
+        totalTasks: number;
+        totalVariants: number;
+        maxPairwiseSimilarity: number;
+        maxStateDefiningSimilarity: number;
+        devTaskCount: number;
+        pilotTaskCount: number;
+        mainTaskCount: number;
+    };
+}
+declare function validateH6Dataset(dataset: H6BenchmarkDataset): Promise<ValidationReport>;
+declare function validateH6FixtureBundle(directory: string): Promise<ValidationReport>;
+declare function writeH6FixtureBundle(outputDir: string, input: H6BenchmarkDataset): Promise<string>;
+
+declare function resolveCommittedH6FixtureDirectory(moduleUrl?: string): Promise<string>;
+declare function loadCommittedH6BenchmarkDataset(): Promise<H6BenchmarkDataset>;
+
+declare const REPEATED_FAILURE_ARMS: readonly ["NO_MEMORY", "TURN_START_FAILURE", "TURN_START_SUCCESS", "PRE_ACTION_FAILURE", "BOTH"];
+type RepeatedFailureArm = (typeof REPEATED_FAILURE_ARMS)[number];
+interface RepeatedFailureRowIdentity {
+    suiteVersion: string;
+    taskId: string;
+    variantId: string;
+    modelProfileId: string;
+    modelProfileHash: string;
+    seed: number;
+    arm: RepeatedFailureArm;
+}
+declare const REPEATED_FAILURE_INVALID_REASONS: readonly ["CORPUS_INVALID", "CORE_REPO_DIR_MISMATCH", "START_DRIFT", "TRACE_GAP", "VAGUE_CHECK", "MIXED_ARM_STATE", "UNMATCHED_FACTS", "WAIT_RULE_FAULT", "HOST_RETRIES_EXHAUSTED"];
+type RepeatedFailureInvalidReason = (typeof REPEATED_FAILURE_INVALID_REASONS)[number];
+interface RepeatedFailureTokenUsage {
+    input: number;
+    output: number;
+    total: number;
+    cachedInput: number;
+    cacheWriteInput: number;
+    reasoningOutput: number;
+}
+type RepeatedFailureFinalState = "UNFIXED" | "TRAPPED" | "FIXED" | "NO_TRAP" | "INVALID";
+type RepeatedFailureFactPairAudit = "MATCHED" | "UNMATCHED" | "NOT_APPLICABLE";
+interface RepeatedFailureIsolationIdentity {
+    repoId: string;
+    memoryId: string;
+    codingScopeId: string;
+    codeGraphId: string;
+    chatId: string;
+    sessionId: string;
+    cacheId: string;
+}
+interface RepeatedFailureGateEvent {
+    status: "NO_MATCH" | "MATCH_WARN" | "ERROR_FAIL_OPEN";
+    fingerprintHash: string;
+    warningHash?: string;
+    faultCode?: string;
+}
+interface RepeatedFailureEpisodeEvidence {
+    startRepoHash: string;
+    startMemoryHash: string;
+    historyHash: string;
+    askedActionHash: string;
+    traceArtifactPath: string;
+    traceArtifactHash: string;
+    gate: RepeatedFailureGateEvent;
+    actionExecuted: boolean;
+    checkResult: "PASS" | "FAIL" | "INDETERMINATE";
+    repeatedFailure: boolean;
+    taskPassed: boolean;
+    steps: number;
+    warningCount: number;
+    falseWarningCount: number;
+    factPairAudit: RepeatedFailureFactPairAudit;
+    faults: readonly string[];
+}
+type RepeatedFailureEpisode = {
+    status: "VALID";
+    finalState: Exclude<RepeatedFailureFinalState, "INVALID">;
+    evidence: RepeatedFailureEpisodeEvidence;
+    isolation: RepeatedFailureIsolationIdentity;
+} | {
+    status: "INVALID";
+    finalState: "INVALID";
+    invalidReason: RepeatedFailureInvalidReason;
+    evidence?: RepeatedFailureEpisodeEvidence;
+    isolation?: RepeatedFailureIsolationIdentity;
+};
+/**
+ * The host-fault retry budget is per run session, not cumulative across the
+ * lifetime of a row: resuming a paused run asserts the endpoint was repaired,
+ * so the row earns a fresh budget while its attempt history keeps growing.
+ * `attempt` is therefore a bounded counter rather than a fixed-width union.
+ */
+interface RepeatedFailureTry {
+    attempt: number;
+    durationMs: number;
+    tokens: RepeatedFailureTokenUsage;
+    outcome: {
+        kind: "HOST_API_FAULT";
+        code: string;
+        messageHash: string;
+        traceArtifactPath: string;
+        traceArtifactHash: string;
+        exhausted?: boolean;
+        evidence?: RepeatedFailureEpisodeEvidence;
+        isolation?: RepeatedFailureIsolationIdentity;
+    } | {
+        kind: "TASK_RESULT";
+        episode: RepeatedFailureEpisode;
+    };
+}
+interface RepeatedFailureEpisodeRow {
+    schemaVersion: 1;
+    rowKey: string;
+    identity: RepeatedFailureRowIdentity;
+    status: "VALID" | "INVALID";
+    finalState: RepeatedFailureFinalState;
+    invalidReason?: RepeatedFailureInvalidReason;
+    repeatedFailure?: boolean;
+    taskPassed?: boolean;
+    steps?: number;
+    warningCount?: number;
+    falseWarningCount?: number;
+    factPairAudit?: RepeatedFailureFactPairAudit;
+    durationMs: number;
+    tokens: RepeatedFailureTokenUsage;
+    tryCount: number;
+    evidence?: RepeatedFailureEpisodeEvidence;
+    isolation?: RepeatedFailureIsolationIdentity;
+}
+interface RepeatedFailureRowCheckpoint {
+    schemaVersion: 1;
+    rowKey: string;
+    identity: RepeatedFailureRowIdentity;
+    tries: RepeatedFailureTry[];
+    terminal?: RepeatedFailureEpisodeRow;
+}
+type RepeatedFailureCheckpointLoadResult = {
+    kind: "MISSING";
+} | {
+    kind: "MALFORMED";
+    error: Error;
+} | {
+    kind: "VALID";
+    checkpoint: RepeatedFailureRowCheckpoint;
+};
+interface RepeatedFailureToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Readonly<Record<string, unknown>>;
+}
+interface RepeatedFailureProposedAction {
+    callId: string;
+    tool: string;
+    arguments: Readonly<Record<string, unknown>>;
+}
+interface RepeatedFailureEpisodeInput {
+    identity: RepeatedFailureRowIdentity;
+    prompt: string;
+    caps: ControlledResponsesCaps;
+    toolHost: RepeatedFailureLocalToolHost;
+    evaluator: RepeatedFailureActionEvaluator;
+    signal?: AbortSignal;
+}
+interface RepeatedFailureTokenizer {
+    readonly identity: string;
+    readonly implementation: "nfkc-whitespace-v1";
+}
+interface RepeatedFailureEpisodeDriver {
+    readonly driverKind?: "responses" | "ollama-chat" | "deterministic-fake";
+    readonly modelProfileId: string;
+    readonly modelProfileHash: string;
+    readonly modelDigest: string;
+    readonly developerInstructions: string;
+    readonly tokenizer: RepeatedFailureTokenizer;
+    preflight?(): Promise<void>;
+    runEpisode(request: RepeatedFailureEpisodeInput): Promise<ControlledResponsesEpisodeResult>;
+}
+interface RepeatedFailureSuiteManifest {
+    suiteVersion: string;
+    datasetInventoryHash: string;
+    tasks: readonly {
+        taskId: string;
+        variantIds: readonly string[];
+    }[];
+}
+interface RunRepeatedFailureSuiteOptions {
+    outputDir: string;
+    drivers: readonly RepeatedFailureEpisodeDriver[];
+    seeds: readonly number[];
+    mode: BenchmarkMode;
+    phase?: "pilot" | "main";
+    pilotRunDir?: string;
+    fixtureDir?: string;
+    runId?: string;
+    taskIds?: readonly string[];
+    variantIds?: readonly string[];
+    resume?: boolean;
+    maxHostRetries?: 0 | 1 | 2 | 3 | 4 | 5;
+    statisticsSeed?: number;
+    statisticsDraws?: number;
+    caps?: Partial<ControlledResponsesCaps>;
+    maxToolOutputChars?: number;
+    clock?: () => number;
+    now?: () => Date;
+}
+interface RepeatedFailureRunMetadata {
+    schemaVersion: 1;
+    runId: string;
+    suiteVersion: string;
+    datasetInventoryHash: string;
+    resumeContractHash: string;
+    expectedDesignHash: string;
+    decisionRuleHash: string;
+    preregistrationPath: string;
+    preregistrationHash: string;
+    analysisVersion: string;
+    harnessVersion: string;
+    harnessSourceHash: string;
+    provenanceHash: string;
+    gitSha: string;
+    gitDirty: boolean;
+    gitDirtyEntryCount: number;
+    phase: "pilot" | "main" | "unspecified";
+    pilotEvidence?: {
+        runId: string;
+        manifestArtifactHash: string;
+        powerArtifactHash: string;
+    };
+    mode: BenchmarkMode;
+    arms: readonly RepeatedFailureArm[];
+    modelProfileIds: readonly string[];
+    modelProfileHashes: readonly string[];
+    modelDigests: readonly string[];
+    modelDriverKinds: readonly ("responses" | "ollama-chat" | "deterministic-fake" | "unknown")[];
+    modelTokenizerIdentities: readonly string[];
+    modelTokenizerImplementations: readonly "nfkc-whitespace-v1"[];
+    trapAuditReceipts: readonly {
+        path: string;
+        artifactHash: string;
+        modelProfileId: string;
+        modelProfileHash: string;
+        modelDigest: string;
+        tokenizerIdentity: string;
+        tokenizerImplementation: "nfkc-whitespace-v1";
+    }[];
+    seeds: readonly number[];
+    splitTaskIds: readonly string[];
+    taskRevisions: readonly {
+        taskId: string;
+        variantId: string;
+        cleanRevisionSha: string;
+        trapRevisionSha: string;
+        rightRevisionSha: string;
+        noTrapRevisionSha: string;
+    }[];
+    caps: ControlledResponsesCaps & {
+        maxToolOutputChars: number;
+    };
+    toolLocks: {
+        allowedTools: readonly string[];
+        taskToolSchemaHashes: readonly {
+            taskId: string;
+            variantId: string;
+            sha256: string;
+        }[];
+    };
+    sandboxFlags: {
+        networkDisabled: true;
+        isolatedRepoPerArm: true;
+        isolatedMemoryPerArm: true;
+        isolatedSessionPerArm: true;
+        rejectSymlinks: true;
+    };
+    retryRule: {
+        hostApiFaultRetriesAfterFirstTry: 0 | 1 | 2 | 3 | 4 | 5;
+        rerunTaskResults: false;
+        retainAllTries: true;
+    };
+    runOrder: readonly {
+        rowKey: string;
+        analysis: "PRIMARY" | "TIMIDITY";
+        identity: RepeatedFailureRowIdentity;
+    }[];
+    expectedRowCount: number;
+    statisticsSeed: number;
+    statisticsDraws: number;
+}
+interface RunRepeatedFailureSuiteResult {
+    result: BenchmarkResult;
+    resultPath: string;
+    episodesPath: string;
+    statisticsPath: string;
+    runMetadataPath: string;
+    expectedDesignPath: string;
+    factPairAuditPath: string;
+    powerPath: string;
+    auditPath: string;
+    deviationsPath: string;
+    decisionRulePath: string;
+    manifestPath: string;
+    completed: number;
+    resumed: number;
+    invalid: number;
+}
+interface RunRepeatedFailureCliCommandInput {
+    phase: "pilot" | "main";
+    seedCount: number;
+    profilePaths: readonly string[];
+    outputDir: string;
+    fixtureDir?: string;
+    resumeRunDir?: string;
+    pilotRunDir?: string;
+    maxSteps?: number;
+    maxToolCalls?: number;
+    maxOutputChars?: number;
+    maxDurationMs?: number;
+    requestTimeoutMs?: number;
+    statisticsDraws?: number;
+    statisticsSeed?: number;
+}
+interface RepeatedFailureCliCommandResult {
+    exitCode: number;
+    output: string;
+}
+interface ReplayRepeatedFailureStatisticsOptions {
+    runDir: string;
+}
+interface RepeatedFailureExpectedDesign {
+    rows: readonly RepeatedFailureRowIdentity[];
+}
+
+/**
+ * Fetch wrapper with retry for transient failures.
+ * Retries on ECONNREFUSED, ECONNRESET, transport ETIMEDOUT, HTTP 429
+ * (rate limit), and HTTP 5xx. Per-attempt timeout aborts are not retried
+ * unless retryOnTimeout is explicitly enabled, because completion requests
+ * may keep running provider-side after client abort. 429 pauses according
+ * to the Retry-After header (or a default backoff) before retrying. When
+ * max429WaitMs is set, the same wall-clock budget also covers transient
+ * 5xx responses from throttled provider backends that surface quota resets
+ * as server errors.
+ */
+interface RetryFetchOptions {
+    maxAttempts?: number;
+    baseBackoffMs?: number;
+    timeoutMs?: number;
+    /**
+     * Retry requests that were aborted by retryFetch's own per-attempt timeout.
+     *
+     * Defaults to false so non-idempotent completion requests do not start a
+     * duplicate request while the timed-out provider-side work may still run.
+     */
+    retryOnTimeout?: boolean;
+    /**
+     * Maximum wall-clock time (ms) to keep retrying 429 responses.
+     * When set, 429s are retried with capped exponential backoff
+     * until this budget expires, regardless of maxAttempts.
+     * Useful for session-quota rate limits that take minutes to reset.
+     * Set to 0 or undefined to disable (uses maxAttempts instead).
+     */
+    max429WaitMs?: number;
+}
+
+declare const ResponseStatusSchema: z.ZodEnum<["completed", "failed", "incomplete", "cancelled", "queued", "in_progress"]>;
+interface ResponsesApiOutputItem {
+    type?: string;
+    id?: string;
+    call_id?: string;
+    name?: string;
+    arguments?: string;
+    role?: string;
+    status?: string;
+    content?: unknown;
+    [key: string]: unknown;
+}
+interface ResponsesApiUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    input_tokens_details?: {
+        cached_tokens?: number;
+        cache_write_tokens?: number;
+    };
+    output_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+}
+interface ResponsesApiResponse {
+    id?: string;
+    model?: string;
+    status?: z.infer<typeof ResponseStatusSchema>;
+    error?: {
+        code?: string;
+        message?: string;
+    } | null;
+    incomplete_details?: {
+        reason?: string;
+    } | null;
+    output?: ResponsesApiOutputItem[];
+    usage?: ResponsesApiUsage;
+}
+interface ResponsesApiRequest {
+    model: string;
+    seed?: number;
+    instructions?: string;
+    max_output_tokens?: number;
+    temperature?: 0;
+    reasoning?: {
+        effort: "low" | "medium" | "high";
+    };
+    include: readonly ["reasoning.encrypted_content"];
+    input: Array<Record<string, unknown>>;
+    tools: Array<{
+        type: "function";
+        name: string;
+        description: string;
+        parameters: Readonly<Record<string, unknown>>;
+        strict: true;
+    }>;
+    tool_choice: "auto";
+    parallel_tool_calls: false;
+    stream: false;
+    store: false;
+}
+type ControlledResponsesTransport = (url: string, init: RequestInit, options: RetryFetchOptions) => Promise<Response>;
+interface RepeatedFailureToolExecutionResult {
+    status: "completed" | "failed";
+    output: unknown;
+}
+interface RepeatedFailureFinalRepoEvidence {
+    repoHash: string;
+    checkResult: "UNFIXED" | "TRAPPED" | "FIXED" | "NO_TRAP" | "INDETERMINATE";
+    changedFiles: readonly string[];
+}
+interface ControlledResponsesToolDefinition extends RepeatedFailureToolDefinition {
+    gateEligible: boolean;
+}
+interface RepeatedFailureLocalToolHost {
+    readonly tools: readonly ControlledResponsesToolDefinition[];
+    execute(action: RepeatedFailureProposedAction, context: {
+        signal: AbortSignal;
+    }): Promise<RepeatedFailureToolExecutionResult>;
+    captureFinalEvidence(context: {
+        signal: AbortSignal;
+    }): Promise<RepeatedFailureFinalRepoEvidence>;
+}
+interface ControlledGateDecision extends RepeatedFailureGateEvent {
+    advisoryText?: string;
+    waitExpired?: boolean;
+}
+interface RepeatedFailureActionEvaluator {
+    evaluate(action: RepeatedFailureProposedAction, context: {
+        signal: AbortSignal;
+    }): Promise<ControlledGateDecision>;
+}
+interface ControlledResponsesSeedCapability {
+    readonly kind: "request_parameter";
+    readonly requestField: "seed";
+}
+interface ControlledResponsesDriverConfig {
+    model: string;
+    modelProfileId?: string;
+    modelProfileHash?: string;
+    instructions?: string;
+    seedCapability?: ControlledResponsesSeedCapability;
+    gateWaitTimeoutMs?: number;
+    maxOutputTokens?: number;
+    temperature?: 0;
+    reasoningEffort?: "low" | "medium" | "high";
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Readonly<Record<string, string>>;
+    transport?: ControlledResponsesTransport;
+    toolHost: RepeatedFailureLocalToolHost;
+    evaluator: RepeatedFailureActionEvaluator;
+}
+interface ControlledResponsesAgentDriverConfig extends Omit<ControlledResponsesDriverConfig, "toolHost" | "evaluator" | "modelProfileId" | "modelProfileHash"> {
+    modelProfileId: string;
+    modelProfileHash: string;
+    modelDigest: string;
+    developerInstructions?: string;
+    tokenizer?: RepeatedFailureTokenizer;
+}
+interface ControlledResponsesAgentDriver extends RepeatedFailureEpisodeDriver {
+    readonly driverKind: "responses";
+}
+interface ControlledResponsesCaps {
+    maxTurns: number;
+    maxToolCalls: number;
+    maxTotalTokens: number;
+    maxDurationMs: number;
+    requestTimeoutMs: number;
+}
+interface ControlledResponsesEpisodeInput {
+    prompt: string;
+    seed?: number;
+    caps: ControlledResponsesCaps;
+    signal?: AbortSignal;
+}
+interface ControlledResponsesResponseEvent {
+    turn: number;
+    responseId: string;
+    status: NonNullable<ResponsesApiResponse["status"]>;
+    model: string;
+    outputItemTypes: readonly string[];
+    usage: RepeatedFailureTokenUsage;
+}
+interface ControlledResponsesToolEvent {
+    callId: string;
+    tool: string;
+    fingerprint: string;
+    status: "completed" | "failed";
+    outputHash: string;
+}
+interface ControlledResponsesFault {
+    code: string;
+    stage: "transport" | "response" | "tool_call" | "tool" | "caps" | "evidence";
+    messageHash: string;
+}
+type ControlledResponsesDisposition = "NONE" | "EXECUTED" | "RESUBMITTED" | "CHANGED" | "ABANDONED";
+interface ControlledResponsesEpisodeResult {
+    status: "COMPLETED" | "INVALID";
+    invalidReason?: "FAULT" | "ABORTED" | "CAP_EXCEEDED";
+    disposition: ControlledResponsesDisposition;
+    outputTextHash: string;
+    outputTextBytes: number;
+    originalCallId?: string;
+    originalFingerprint?: string;
+    replacementCallId?: string;
+    replacementFingerprint?: string;
+    gate?: RepeatedFailureGateEvent;
+    gateEvents: readonly RepeatedFailureGateEvent[];
+    responses: readonly ControlledResponsesResponseEvent[];
+    tools: readonly ControlledResponsesToolEvent[];
+    usage: RepeatedFailureTokenUsage;
+    faults: readonly ControlledResponsesFault[];
+    finalRepoEvidence?: RepeatedFailureFinalRepoEvidence;
+}
+
+declare class ControlledResponsesDriver {
+    readonly modelId: string;
+    readonly modelProfileId?: string;
+    readonly modelProfileHash?: string;
+    private readonly config;
+    private readonly transport;
+    private readonly toolsByName;
+    constructor(config: ControlledResponsesDriverConfig);
+    runEpisode(input: ControlledResponsesEpisodeInput): Promise<ControlledResponsesEpisodeResult>;
+    private requestResponse;
+    private evaluateGate;
+    private executeTool;
+    private completeWithEvidence;
+    private invalidateAbort;
+    private invalidateCap;
+}
+declare function createControlledResponsesAgentDriver(config: ControlledResponsesAgentDriverConfig): ControlledResponsesAgentDriver;
+
+declare function validateOllamaChatEndpoint(endpoint: string | undefined): string;
+declare const OllamaChatResponseSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        thinking: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            }, {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }, {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role?: string | undefined;
+        content?: string | undefined;
+        thinking?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }[] | undefined;
+    }, {
+        role?: string | undefined;
+        content?: string | undefined;
+        thinking?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }[] | undefined;
+    }>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    done_reason: z.ZodOptional<z.ZodString>;
+    prompt_eval_count: z.ZodOptional<z.ZodNumber>;
+    eval_count: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    model: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        thinking: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            }, {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }, {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role?: string | undefined;
+        content?: string | undefined;
+        thinking?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }[] | undefined;
+    }, {
+        role?: string | undefined;
+        content?: string | undefined;
+        thinking?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }[] | undefined;
+    }>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    done_reason: z.ZodOptional<z.ZodString>;
+    prompt_eval_count: z.ZodOptional<z.ZodNumber>;
+    eval_count: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    model: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        thinking: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            }, {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }, {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role?: string | undefined;
+        content?: string | undefined;
+        thinking?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }[] | undefined;
+    }, {
+        role?: string | undefined;
+        content?: string | undefined;
+        thinking?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+        }[] | undefined;
+    }>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    done_reason: z.ZodOptional<z.ZodString>;
+    prompt_eval_count: z.ZodOptional<z.ZodNumber>;
+    eval_count: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+type ParsedOllamaChatResponse = z.infer<typeof OllamaChatResponseSchema>;
+interface OllamaChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content?: string;
+    tool_name?: string;
+    thinking?: string;
+    tool_calls?: Array<{
+        function: {
+            name: string;
+            arguments: Record<string, unknown> | string;
+        };
+    }>;
+}
+interface RepeatedFailureOllamaChatDriverConfig {
+    model: string;
+    modelProfileId: string;
+    modelProfileHash: string;
+    modelDigest: string;
+    developerInstructions?: string;
+    instructions?: string;
+    baseUrl?: string;
+    endpoint?: string;
+    seedCapability?: {
+        kind: "options_parameter";
+        requestField: "seed";
+    };
+    gateWaitTimeoutMs?: number;
+    maxOutputTokens?: number;
+    contextWindowTokens?: number;
+    temperature?: 0;
+    think?: boolean;
+    headers?: Readonly<Record<string, string>>;
+    requestTimeoutMs?: number;
+    transport?: ControlledResponsesTransport;
+    tokenizer?: RepeatedFailureTokenizer;
+}
+declare function createRepeatedFailureOllamaChatDriver(config: RepeatedFailureOllamaChatDriverConfig): RepeatedFailureOllamaChatDriver;
+declare class RepeatedFailureOllamaChatDriver implements RepeatedFailureEpisodeDriver {
+    readonly driverKind: "ollama-chat";
+    readonly modelProfileId: string;
+    readonly modelProfileHash: string;
+    readonly modelDigest: string;
+    readonly developerInstructions: string;
+    readonly tokenizer: RepeatedFailureTokenizer;
+    private readonly config;
+    private readonly baseUrl;
+    private readonly transport;
+    constructor(config: RepeatedFailureOllamaChatDriverConfig);
+    preflight(): Promise<void>;
+    runEpisode(input: RepeatedFailureEpisodeInput): Promise<ControlledResponsesEpisodeResult>;
+    private requestChatResponse;
+    private parseOllamaAction;
+    private evaluateGate;
+    private executeTool;
+    private captureFinalEvidence;
+    private invalidateAbort;
+    private invalidateCap;
+}
+
+/**
+ * Hard ceiling on attempts retained for one row across every resume.
+ * The frozen budget is six attempts per session; this admits four paused
+ * sessions before the row is refused outright, so a permanently broken
+ * endpoint fails loudly instead of growing a checkpoint without bound.
+ */
+declare const MAX_ROW_ATTEMPTS = 24;
+declare function buildRepeatedFailureRowKey(identity: RepeatedFailureRowIdentity): string;
+declare function parseRepeatedFailureEpisodeRow(value: unknown): RepeatedFailureEpisodeRow;
+declare function writeRepeatedFailureRunMetadata(outputDir: string, metadata: RepeatedFailureRunMetadata, fileName?: string): Promise<string>;
+
+interface RepeatedFailureRowClaim {
+    readonly schemaVersion: 1;
+    readonly rowKey: string;
+    readonly identity: RepeatedFailureRowIdentity;
+    readonly ownerToken: string;
+}
+interface RepeatedFailureRowStoreOptions {
+    readonly claimWaitTimeoutMs?: number;
+    readonly claimLeaseMs?: number;
+    readonly claimHeartbeatMs?: number;
+}
+declare class RepeatedFailureRowStore {
+    readonly outputDir: string;
+    readonly checkpointsDir: string;
+    private readonly activeClaims;
+    private readonly claimHeartbeatMs;
+    private readonly claimLeaseMs;
+    private readonly claimWaitTimeoutMs;
+    private commitTail;
+    constructor(outputDir: string, options?: RepeatedFailureRowStoreOptions);
+    private assertCheckpointsDirectorySafe;
+    checkpointPath(identity: RepeatedFailureRowIdentity): string;
+    load(identity: RepeatedFailureRowIdentity): Promise<RepeatedFailureCheckpointLoadResult>;
+    loadTerminalForResume(identity: RepeatedFailureRowIdentity): Promise<RepeatedFailureEpisodeRow | undefined>;
+    verifyAttemptTraceArtifacts(checkpoint: RepeatedFailureRowCheckpoint): Promise<void>;
+    claimRow(identity: RepeatedFailureRowIdentity): Promise<RepeatedFailureRowClaim>;
+    commitTry(claim: RepeatedFailureRowClaim, entry: RepeatedFailureTry): Promise<RepeatedFailureRowCheckpoint>;
+    releaseClaim(claim: RepeatedFailureRowClaim): Promise<void>;
+    awaitClaimsReleased(): Promise<void>;
+    private hasOnDiskClaimLocks;
+    private releaseClaimUnlocked;
+    private startHeartbeat;
+    private refreshClaim;
+    private refreshClaimOnDisk;
+    private assertClaimShape;
+    private assertDiskOwner;
+    private assertOwnerToken;
+    private refreshOwnerToken;
+    private tryReclaimExpired;
+    private acquireReclaimGuard;
+    private releaseReclaimGuard;
+    private reclaimInProgress;
+    private recoverExpiredReclaimGuard;
+    private recoverStrandedRowLock;
+    private tryReclaimExpiredPath;
+    private removeEmptyLockDirectory;
+    private readLockSnapshot;
+    private isExpired;
+    private sameLockSnapshot;
+    private claimLockPath;
+    private reclaimPath;
+    private staleLockPath;
+    private staleReclaimPath;
+    private reclaimJournalPath;
+    private commitPath;
+    private heartbeatPath;
+    private notOwnerError;
+    private commitTryUnlocked;
+    compileRows(): Promise<RepeatedFailureEpisodeRow[]>;
+    writeEpisodesJsonl(fileName?: string): Promise<string>;
+}
+
+declare const REPEATED_FAILURE_STATISTICS_DRAWS = 10000;
+declare const REPEATED_FAILURE_CONFIDENCE_LEVEL = 0.95;
+interface AnalyzeRepeatedFailureOptions {
+    expectedDesign: RepeatedFailureExpectedDesign;
+    timidityDesign?: RepeatedFailureExpectedDesign;
+    seed: number;
+    draws?: number;
+    level?: number;
+    alpha?: number;
+    timingMinimumRrr?: number;
+    timingMinimumAbsoluteBenefit?: number;
+    timingMinimumBenefitIntervalLower?: number;
+    contentMinimumRepeatedFailureBenefitIntervalLower?: number;
+    contentMinimumTaskPassBenefitIntervalLower?: number;
+    timidityPassMargin?: number;
+    timidityStepsMargin?: number;
+}
+interface RepeatedFailureInterval {
+    lower: number;
+    upper: number;
+    level: number;
+}
+interface RepeatedFailureNullableInterval {
+    lower: number | null;
+    upper: number | null;
+    level: number;
+}
+interface RepeatedFailureTaskCut {
+    hypothesis: "TIMING" | "CONTENT" | "TIMIDITY";
+    taskId: string;
+    reasons: string[];
+}
+interface RepeatedFailureEffectAnalysis {
+    taskCount: number;
+    baselineArm: RepeatedFailureArm;
+    candidateArm: RepeatedFailureArm;
+    interpretation: "CONFIRMATORY" | "EXPLORATORY_COMPLETE_TASKS";
+    repeatedFailureBenefit: number | null;
+    repeatedFailureBenefitInterval: RepeatedFailureInterval | null;
+    relativeRiskReduction: number | null;
+    relativeRiskReductionInterval: RepeatedFailureNullableInterval | null;
+    nonEstimableRrrDraws: number;
+    repeatedFailureP: number | null;
+    taskPassBenefit: number | null;
+    taskPassBenefitInterval: RepeatedFailureInterval | null;
+    taskPassP: number | null;
+}
+interface RepeatedFailureHolmResult {
+    id: "TIMING" | "CONTENT";
+    rawP: number;
+    adjustedP: number;
+    rank: number;
+}
+interface RepeatedFailureTimidityAnalysis {
+    taskCount: number;
+    intervalLevel: 0.9;
+    passRateDifference: number | null;
+    passRateInterval: RepeatedFailureInterval | null;
+    stepsDifference: number | null;
+    stepsInterval: RepeatedFailureInterval | null;
+    passMargin: number;
+    stepsMargin: number;
+    equivalent: boolean | null;
+}
+type RepeatedFailureSupportDecision = "SUPPORTED" | "REJECTED" | "NOT_ESTIMABLE";
+interface RepeatedFailureStatisticalAnalysis {
+    schemaVersion: 1;
+    seed: number;
+    draws: number;
+    level: number;
+    alpha: number;
+    cuts: RepeatedFailureTaskCut[];
+    timing: RepeatedFailureEffectAnalysis;
+    content: RepeatedFailureEffectAnalysis;
+    contentCompoundP: number | null;
+    holm: RepeatedFailureHolmResult[];
+    decisions: {
+        timing: RepeatedFailureSupportDecision;
+        content: RepeatedFailureSupportDecision;
+    };
+    studyDecision: "PASS" | "PARTIAL" | "REJECT" | "NOT_ESTIMABLE";
+    timidity: RepeatedFailureTimidityAnalysis;
+}
+declare function holmAdjust(hypotheses: readonly {
+    id: "TIMING" | "CONTENT";
+    p: number;
+}[]): RepeatedFailureHolmResult[];
+declare function decideRepeatedFailureTiming(timing: RepeatedFailureEffectAnalysis, adjustedP: number | undefined, minimumRrr: number, minimumAbsoluteBenefit: number, minimumBenefitIntervalLower: number, alpha: number): RepeatedFailureSupportDecision;
+declare function decideRepeatedFailureContent(content: RepeatedFailureEffectAnalysis, compoundP: number | null, adjustedP: number | undefined, minimumRepeatedFailureBenefitIntervalLower: number, minimumTaskPassBenefitIntervalLower: number, alpha: number): RepeatedFailureSupportDecision;
+declare function decideRepeatedFailureStudy(timing: RepeatedFailureSupportDecision, content: RepeatedFailureSupportDecision): RepeatedFailureStatisticalAnalysis["studyDecision"];
+declare function relativeRiskReduction(baselineRisk: number, candidateRisk: number): number | null;
+declare function isRepeatedFailureTimidityEquivalent(passRateInterval: RepeatedFailureInterval, stepsInterval: RepeatedFailureInterval, passMargin: number, stepsMargin: number): boolean;
+declare function analyzeRepeatedFailureRows(rows: readonly RepeatedFailureEpisodeRow[], options: AnalyzeRepeatedFailureOptions): RepeatedFailureStatisticalAnalysis;
+declare function writeRepeatedFailureStatistics(outputDir: string, analysis: RepeatedFailureStatisticalAnalysis, fileName?: string): Promise<string>;
+
+interface RepeatedFailureTrapAuditRow {
+    taskId: string;
+    variantId: string;
+    rowKey: string;
+    finalState: RepeatedFailureFinalState;
+    status: "VALID" | "INVALID";
+    invalidReason?: RepeatedFailureInvalidReason;
+    tryCount: number;
+    durationMs: number;
+    tokens: RepeatedFailureTokenUsage;
+}
+interface RepeatedFailureTrapAuditThresholds {
+    minimumTrappedRate: number;
+    minimumNonFixedRate: number;
+    maximumInvalidRows: 0;
+    requireCompleteRows: true;
+}
+interface RepeatedFailureTrapAuditMetrics {
+    totalTasks: number;
+    completedRows: number;
+    trappedCount: number;
+    trappedRate: number;
+    nonFixedCount: number;
+    nonFixedRate: number;
+    fixedCount: number;
+    unfixedCount: number;
+    invalidCount: number;
+    missingCount: number;
+    passed: boolean;
+}
+interface RepeatedFailureTrapAuditArtifact {
+    schemaVersion: 1;
+    modelProfileId: string;
+    modelProfileHash: string;
+    modelDigest: string;
+    datasetInventoryHash: string;
+    harnessSourceHash: string;
+    decisionRuleHash: string;
+    thresholds: RepeatedFailureTrapAuditThresholds;
+    passed: boolean;
+    metrics: RepeatedFailureTrapAuditMetrics;
+    rows: readonly RepeatedFailureTrapAuditRow[];
+    artifactHash: string;
+}
+interface RepeatedFailureTrapAuditRowIdentity {
+    taskId: string;
+    variantId: string;
+    rowKey: string;
+}
+interface RepeatedFailureTrapAuditExpected {
+    modelProfileId: string;
+    modelProfileHash: string;
+    modelDigest: string;
+    datasetInventoryHash: string;
+    harnessSourceHash: string;
+    decisionRuleHash: string;
+    thresholds: RepeatedFailureTrapAuditThresholds;
+    rowIdentities: readonly RepeatedFailureTrapAuditRowIdentity[];
+}
+declare function assertTrapDatasetPreflight(dataset: H6BenchmarkDataset): Promise<void>;
+declare function computeTrapAuditMetrics(rows: readonly RepeatedFailureTrapAuditRow[], totalTasks: number, thresholds: RepeatedFailureTrapAuditThresholds): RepeatedFailureTrapAuditMetrics;
+declare function computeTrapAuditArtifactHash(artifactPayload: Omit<RepeatedFailureTrapAuditArtifact, "artifactHash">): string;
+declare function verifyTrapAuditArtifact(artifact: unknown, expected: RepeatedFailureTrapAuditExpected): {
+    valid: boolean;
+    error?: string;
+};
+interface RunTrapAuditOptions {
+    driver: RepeatedFailureEpisodeDriver;
+    outputDir: string;
+    fixtureDir?: string;
+    seed?: number;
+    maxHostRetries?: 0 | 1 | 2 | 3 | 4 | 5;
+    caps?: Partial<ControlledResponsesCaps>;
+    maxToolOutputChars?: number;
+}
+declare function runTrapAudit(options: RunTrapAuditOptions): Promise<RepeatedFailureTrapAuditArtifact>;
+declare function verifyMatchingTrapAudit(profile: {
+    id: string;
+    hash: string;
+    modelDigest: string;
+}, datasetInventoryHash: string, harnessSourceHash: string, decisionRule: {
+    hash: string;
+    trapAudit: RepeatedFailureTrapAuditThresholds;
+}, searchDirs: readonly string[]): Promise<RepeatedFailureTrapAuditArtifact>;
+declare function runTrapAuditCliCommand(input: {
+    profilePaths: readonly string[];
+    outputDir: string;
+    fixtureDir?: string;
+    maxSteps?: number;
+    maxToolCalls?: number;
+    maxOutputChars?: number;
+    maxDurationMs?: number;
+    requestTimeoutMs?: number;
+}): Promise<{
+    exitCode: number;
+    output: string;
+}>;
+
+declare function runRepeatedFailureSuite(options: RunRepeatedFailureSuiteOptions): Promise<RunRepeatedFailureSuiteResult>;
+declare function replayRepeatedFailureStatistics(options: ReplayRepeatedFailureStatisticsOptions): Promise<RepeatedFailureCliCommandResult>;
+declare function runRepeatedFailureCliCommand(input: RunRepeatedFailureCliCommandInput): Promise<RepeatedFailureCliCommandResult>;
+
+interface WriteRepeatedFailurePaperArtifactsOptions {
+    runDir: string;
+    dataset?: H6BenchmarkDataset;
+}
+interface RepeatedFailurePaperArtifactsResult {
+    reportPath: string;
+    manifestPath: string;
+    artifactPaths: readonly string[];
+}
+declare function writeRepeatedFailurePaperArtifacts(options: WriteRepeatedFailurePaperArtifactsOptions): Promise<RepeatedFailurePaperArtifactsResult>;
+declare function runRepeatedFailurePaperReportCliCommand(options: {
+    runDir: string;
+}): Promise<RepeatedFailureCliCommandResult>;
+
 /**
  * @remnic/bench — Operation-Level Failure Attributor (Issue #1954)
  *
@@ -6183,4 +9612,4 @@ declare function pickOne<T>(rng: SeededRandom, items: readonly T[]): T;
 /** Deterministic Fisher-Yates shuffle returning a new array. */
 declare function shuffled<T>(rng: SeededRandom, items: readonly T[]): T[];
 
-export { AMA_BENCH_DIAGNOSTIC_VARIANTS, ASSISTANT_AGENT_CONFIG_KEY, ASSISTANT_JUDGE_CONFIG_KEY, ASSISTANT_MEETING_PREP_SCENARIOS, ASSISTANT_MEETING_PREP_SMOKE_SCENARIOS, ASSISTANT_MORNING_BRIEF_SCENARIOS, ASSISTANT_MORNING_BRIEF_SMOKE_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SMOKE_SCENARIOS, ASSISTANT_RUBRIC_DIMENSIONS, ASSISTANT_RUBRIC_ID_KEY, ASSISTANT_SEEDS_CONFIG_KEY, ASSISTANT_SPOT_CHECK_DIR_KEY, ASSISTANT_SYNTHESIS_SCENARIOS, ASSISTANT_SYNTHESIS_SMOKE_SCENARIOS, type AblationConfigOverrides, type AbstentionRetrievalCase, type AggregateMetrics, type AmaBenchDiagnosticAdapterOptions, type AmaBenchDiagnosticAnswererMode, type AmaBenchDiagnosticBreakdown, type AmaBenchDiagnosticMatrixArtifact, type AmaBenchDiagnosticRecallMode, type AmaBenchDiagnosticRunContext, type AmaBenchDiagnosticTaskEvidence, type AmaBenchDiagnosticTaskRow, type AmaBenchDiagnosticVariant, type AmaBenchDiagnosticVariantSummary, type AnthropicProviderConfig, type AssistantAgent, type AssistantMemoryFact, type AssistantMemoryGraph, type AssistantRubricDimension, type AssistantRubricRequest, type AssistantRubricScores, type AssistantRunnerOptions, type AssistantScenario, type AssistantStance, type AttackRecallOptions, type AttackRetrievalHit, type AttackerMode, type AttributeOptions, type AttributionClass, type AttributionEnvironment, type AttributionLabel, type AttributionMemory, type AttributionReport, BENCHMARK_ARTIFACT_SCHEMA_VERSION, BENCHMARK_INTEGRITY_META_SCHEMA, BENCHMARK_REPRO_MANIFEST_FILENAME, BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION, BENCHMARK_RESULT_SCHEMA, BENCHMARK_SPLIT_TYPES, BUILD_WEEK_EVIDENCE_RECEIPT_SCHEMA_VERSION, BUILD_WEEK_LIMITATIONS, type BaselineRow, type BaselineScenario, type BeamDatasetPreview, type BenchConfig, type BenchJudge, type BenchJudgeResult, type BenchMemoryAdapter, type BenchModelSource, type BenchReasoningEffort, type BenchRecallLineageStatus, type BenchRecallOptions, type BenchRecallSupportAssessment, type BenchRecallSupportRequest, type BenchRecallSupportStatus, type BenchRecallTrace, type BenchRecallTraceCoreCapture, type BenchRecallTraceLcmCandidate, type BenchRecallTraceRange, type BenchRecallTraceSection, type BenchRecallTraceSelection, type BenchRecallWithTraceResult, type BenchResponder, type BenchResponse, type BenchRuntimeProfile, type BenchTier, type BenchmarkArtifact, type BenchmarkArtifactEnvironment, type BenchmarkArtifactHardware, type BenchmarkArtifactJudgeCalibration, type BenchmarkArtifactPerTaskScore, type BenchmarkArtifactSystem, type BenchmarkArtifactTier, type BenchmarkCategory, type BenchmarkDefinition, type BenchmarkIntegrityMeta, type BenchmarkMeta, type BenchmarkMode, type BenchmarkReport, type BenchmarkReproManifest, type BenchmarkReproManifestDataset, type BenchmarkReproManifestFile, type BenchmarkReproManifestResult, type BenchmarkResult, type BenchmarkSplitType, type BenchmarkStatus, type BenchmarkSuiteResult, type BenchmarkTier, type BootstrapKappaOptions, type BootstrapKappaResult, type BuildBenchmarkArtifactInput, type BuildBenchmarkPublishFeedOptions, type BuildBenchmarkReproManifestOptions, type BuildBuildWeekEvidenceReceiptOptions, type BuildWeekEvidenceReceipt, type BuildWeekEvidenceReceiptProvider, type BuildWeekLimitationCode, type BuiltInProvider, CALIBRATION_SLICE_SIZE, CANARY_FIXED_RECALL, CANARY_SCORE_FLOOR, DEFAULT_10K_FIXTURE as CODING_GRAPH_10K_FIXTURE, CODING_GRAPH_BENCH_SCHEMA_VERSION, DEFAULT_TOLERANCE_PERCENT as CODING_GRAPH_DEFAULT_TOLERANCE, MIN_ITERATIONS as CODING_GRAPH_MIN_ITERATIONS, DEFAULT_SMOKE_FIXTURE as CODING_GRAPH_SMOKE_FIXTURE, type CalibrationAnswer, type CalibrationVerdictPair, type CanaryAdapterOptions, type CanaryFloorCheck, type CaptureLoCoMoRetrievalTraceOptions, type ClaudeCliProviderConfig, type CodexCliNativeUsage, type CodexCliProviderConfig, CodexCreditAccountingError, type CodexCreditBudgetConfig, CodexCreditDispatchError, type CodexCreditReceipt, type CodexCreditReceiptScope, type CodexCreditReconciliationReceipt, type CodingGraphBaseline, type CodingGraphBenchConfig, type CodingGraphBenchReport, type MachineFingerprint as CodingGraphMachineFingerprint, type CodingGraphMetricKey, type RegressionMetricDetail as CodingGraphRegressionDetail, type RegressionMetricKey as CodingGraphRegressionKey, type RegressionGateResult as CodingGraphRegressionResult, type CohenKappaResult, type ComparisonMetricDelta, type ComparisonResult, type CompletionOpts, type CompletionResult, type ConfidenceInterval, type ContaminationCheckResult, type ContaminationEntry, type ContaminationManifest, type CustomBenchmarkScoring, type CustomBenchmarkSpec, type CustomBenchmarkTask, DEFAULT_ABLATION_BENCHMARK, DEFAULT_ABLATION_BOOTSTRAP_SEED, DEFAULT_ASSISTANT_RUBRIC_ID, DEFAULT_BASELINE_SCENARIOS, DEFAULT_JUDGE_BINARIZATION_THRESHOLD, DEFAULT_KAPPA_BOOTSTRAP_SAMPLES, DEFAULT_KAPPA_CONFIDENCE_LEVEL, DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL, DRIFT_GEN_DEFAULTS, DRIFT_GEN_VERSION, type DatasetSource, type DiagnoseLoComoProfileDeltaOptions, type DiagnoseLoComoRecallDeltaOptions, type DiscoveredModel, type DriftGenAuditRecord, type DriftGenCorpus, type DriftGenManifest, type DriftGenOptions, type DriftGenResult, type DriftSession, type DriftSessionTurn, type DriftValidationReport, type DriftValidationStats, EMPTY_CONTAMINATION_MANIFEST, type EffectSizeInterpretation, type EffectSizeSummary, type ExplainResult, type ExtractedEntity, type ExtractedLink, type ExtractedPage, type ExtractionAttackOptions, type ExtractionAttackResult, type ExtractionAttackTarget, type FixtureGenerator, type FixtureOutput, type FixtureVariant, GENERAL_ANSWER_JUDGE_RUBRIC, type GeneratedFile, type GeneratedRepo, type GoldEntity, type GoldEntityType, type GoldFact, type GoldFactKind, type GoldGraph, type GoldLink, type GoldMemoryAttribution, type GoldPage, type GoldProbe, type GoldProbeCategory, type HarnessRng, INTEGRITY_CIPHER_ALGORITHM, INTEGRITY_HASH_ALGORITHM, INTEGRITY_META_FIELDS, type IngestionBenchAdapter, type IngestionLog, JUDGE_CALIBRATION_KAPPA_THRESHOLD, JUDGE_CALIBRATION_PROTOCOL_VERSION, type JudgeCalibrationCheckpointProvenance, type JudgeCalibrationIdentities, type JudgeCalibrationResult, type JudgeCategory, type KappaConfidenceInterval, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LOCOMO_FULL_TASK_COUNT, LOCOMO_RECALL_DIFF_LINE_LIMIT, LOCOMO_RECALL_EXCERPT_CHARS, LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION, LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, type LoCoMoCategory, type LoCoMoRetrievalMechanism, type LoCoMoRetrievalMechanismSummary, type LoCoMoRetrievalSessionReceipt, type LoCoMoRetrievalStructuralTrace, type LoCoMoRetrievalTaskDelta, type LoCoMoRetrievalTaskReceipt, type LoCoMoRetrievalTraceCoreCaptureReceipt, type LoCoMoRetrievalTraceDeltaReport, type LoCoMoRetrievalTraceProfile, type LoCoMoRetrievalTraceReceipt, type LoCoMoRetrievalTraceSelectionManifest, type LoCoMoRetrievalTraceSelector, type LoCoMoStructuralMultisetDelta, type LoComoCategoryDelta, type LoComoFinalContextRegression, type LoComoMetricDelta, type LoComoProfileArtifactEvidence, type LoComoProfileDeltaReport, type LoComoRawResultEvidence, type LoComoRecallCategoryDelta, type LoComoRecallContextSummary, type LoComoRecallDeltaReport, type LoComoRecallLineDelta, type LoComoRecallLineEvidence, type LoComoRecallMetricDelta, type LoComoRecallResultProvenance, type LoComoRecallTextDigest, type LoComoTaskRegression, type LoadDatasetOptions, type LoadSealedQrelsOptions, type LoadedDataset, type LoadedJudgeCalibrationState, type LocalLabManifest, type LocalLabManifestNotes, type LocalLabPhase, type LocalLabPhaseDescriptor, type LocalLabPhaseExecute, type LocalLabPhaseName, type LocalLabPhaseOutcome, LocalLabPreflightError, type LocalLabPreflightFailure, type LocalLabPreflightInput, type LocalLabPreflightOptions, type LocalLabPreflightResult, type LocalLabPreflightSuccess, type LocalLabProviderKind, type LocalLabRoleConfig, type LocalLlmProviderConfig, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION, MEMCORRECT_STALE_HARM_RUBRIC, MEMCORRECT_STALE_HARM_RUBRIC_VERSION, MEMORY_EVAL_DIMENSIONS, MEMORY_EVAL_PUBLIC_LINE, MIN_CALIBRATION_SOURCE_TASKS, MITIGATED_BASELINE_SCENARIOS, type McpArgumentSemantic, type McpBackendErrorCode, type McpBackendResult, type McpBenchMemoryAdapter, type McpConformanceResult, type McpHttpTransportConfig, type McpListedTool, type McpMemCorrectAdapter, type McpMemoryAdapterOptions, McpMemoryBackendError, type McpMemoryToolMapping, type McpMemoryTransportConfig, type McpStdioTransportConfig, type McpToolCallResult, type McpToolClient, type McpToolMappingEntry, type McpToolMappingValue, type McpToolOperation, type Mem0AdapterConfig, Mem0MemCorrectAdapter, type MemCorrectGeneratorOptions, type MemCorrectJudgeRequest, type MemCorrectJudgeResult, type MemCorrectSystemAdapter, type MemoryEvalCategory, type MemoryEvalDimension, type MemoryEvalDimensionId, type MemoryEvalMetric, type MemoryGraph, type MemoryStats, type MemorySystem, type Message, type MetricAggregate, type MicroMetric, MissingCredentialError, type MitigatedBaselineConfig, type MitigatedTargetConfig, type MultipleChoiceQuestion, OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION, OTHER_NAMESPACE_MEMORIES, type OllamaProviderConfig, type OpenAiCompatibleProviderConfig, OpenAiResponsesJudgeError, type OpenAiResponsesJudgeErrorCode, type OpenAiResponsesJudgeTelemetry, OpenAiResponsesProvider, type OpenAiResponsesProviderConfig, type OpenAiResponsesVerdict, type OpenAiResponsesVerdictResult, PROCEDURAL_REAL_SCENARIOS, PROCEDURAL_REAL_SCENARIOS_SMOKE, PUBLISHED_BENCHMARK_ARTIFACT_IDS, type PairedAnswerReplayCache, type PairedAnswerReplayEntry, type PersonalizationRetrievalCase, type PreflightDiscoveredModel, type ProceduralAblationArtifact, type ProceduralAblationPerCase, type ProceduralAblationScenario, type ProceduralRealScenario, type ProceduralRealScenarioCategory, type ProviderBaseConfig, type ProviderConfig, type ProviderDiscoveryResult, type ProviderFactoryConfig, type PublishSkipReason, type PublishSkipRecord, type PublishedBenchmarkFeed, type PublishedBenchmarkFeedEntry, type PublishedBenchmarkId, REQUIRED_FRONTMATTER_FIELDS, type RecallMetrics, type RecoveredMemory, type RegressionDetail, type RegressionGateResult$1 as RegressionGateResult, type RemnicAdapterOptions, type ReportCardProvenanceContext, type ResolveBenchRuntimeProfileOptions, type ResolvedBenchRuntimeProfile, type ResolvedLocalLabProfile, type ResolvedLocalLabRole, type ResolvedRunBenchmarkOptions, type RetrievalMissStage, type RotatedChoices, type RunBenchmarkOptions, type RunJudgeCalibrationOptions, type RunProceduralAblationCliArgs, type RunProceduralAblationOptions, type RunSequentialPhasesOptions, SCHEMA_TIER_FIXTURE, SCHEMA_TIER_SMOKE_FIXTURE, SEALED_PROMPT_REGISTRY, SINGLE_FLAG_ABLATION_MATRIX, SYNTHETIC_MEMORIES, type SanitizedDiagnosticProvider, type SavedBaseline, type SchemaTierCorpus, type SchemaTierFixture, type SchemaTierName, type SchemaTierPage, type SchemaTierPageFrontmatter, type SealedArtifact, type SealedJudgeDecision, type SealedJudgeInput, type SealedQrelsArtifact, type SealedQrelsHandle, type SealedRubric, type SearchResult, type SeededMemory, type SeededRandom, type SeededRng, type SequentialPhaseHooks, type SingleFlagAblationCell, type SingleFlagAblationId, type SpotCheckLogger, type StageObservation, type StageStatus, type StatisticalReport, type StructuredJudge, StructuredJudgeError, type StructuredJudgeErrorCode, type StructuredJudgeProvider, type StructuredJudgeTelemetry, type StructuredJudgeVerdict, type StructuredJudgeVerdictResult, type StructuredVerdictRequest, type SyntheticEdge, type SyntheticEmailIngestionAdapterOptions, type SyntheticFileIR, type SyntheticRepoConfig, type SyntheticSymbol, type SyntheticTargetOptions, type TaskAttribution, type TaskAttributionGoldWitnessV1, type TaskAttributionRetrievalWitnessV1, type TaskAttributionWitness, type TaskAttributionWitnessRuntimeV1, type TaskAttributionWitnessV1, type TaskResult, type TaskTokenUsage, type TemporalRetrievalCase, type ThirdPartyAdapterConfig, type TierDetail, type TimelineEntry, type TokenUsage, type WallMetric, type WriteBenchmarkArtifactResult, type ZepAdapterConfig, ZepMemCorrectAdapter, addContaminationEntry, aggregateTaskScores, answerBenchmarkQuestion, assertCanaryUnderFloor, assertIntegrityMetaPresent, assertPublishableIntegrity, assertSha256Hex, assistantMeetingPrepDefinition, assistantMorningBriefDefinition, assistantNextBestActionDefinition, assistantSynthesisDefinition, attributeGoldMemory, attributeRun, attributeTask, backlinkF1, binarizeJudgeScore, bootstrapCohensKappaConfidenceInterval, bootstrapMeanConfidenceInterval, buildAmaBenchDiagnosticMatrixArtifact, buildAmaBenchDiagnosticVariantSummary, buildAmaBenchLeaderboardRows, buildBaselineFromReport, buildBenchmarkArtifact, buildBenchmarkArtifactFilename, buildBenchmarkPublishFeed, buildBenchmarkReproManifest, buildBenchmarkRunSeeds, buildBuildWeekEvidenceReceipt, buildCodexCreditReceipt, buildDriftCorpus, buildJudgePayload, buildOracleTrajectoryRecall, buildProviderFreeLoCoMoRetrievalConfig, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calculateCodexBudgetUnits, calendarFixture, canonicalJsonStringify, captureLoCoMoRetrievalTrace, captureMachineFingerprint, chatFixture, checkCodingGraphRegression, checkDatasetContamination, checkRegression, clampScore, cohensD, compareResults, computeCohensKappa, computeSealHash, containsAnswer, createSeededRng$1 as createAdamSeededRng, createAmaBenchDiagnosticAdapter, createAnthropicProvider, createCanaryAdapter, createClaudeCliProvider, createCodexCliProvider, createSeededRng as createCodingGraphSeededRng, createDeterministicSpotCheckLogger, createGatewayResponder, createLightweightAdapter, createLiteLlmProvider, createLocalLlmProvider, createMcpDemoMemCorrectAdapter, createMcpDemoMemoryAdapter, createMcpMemCorrectAdapter, createMcpMemoryAdapter, createMitigatedTarget, createOllamaProvider, createOpenAiCompatibleProvider, createOpenAiResponsesBenchJudge, createOpenAiResponsesProvider, createSeededRandom$1 as createProceduralAblationSeededRandom, createProvider, createProviderBackedAmaBenchRecommendedJudge, createProviderBackedJudge, createProviderBackedResponder, createProviderBackedStructuredJudge, createRemnicAdapter, createResponderFromProvider, createSeededRandom, createSeededRng$2 as createSeededRng, createSpotCheckFileLogger, createStructuredBenchJudge, createStructuredJudgeFromProvider, createSyntheticEmailIngestionAdapter, createSyntheticTarget, createTimeoutGuardedAdapter, defaultBenchmarkBaselineDir, defaultBenchmarkPublishPath, deleteBenchmarkResults, diagnoseLoCoMoRetrievalTraceDelta, diagnoseLoComoProfileDelta, diagnoseLoComoRecallDelta, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, exactMatch, extractMetrics as extractCodingGraphMetrics, extractContentWords, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateDriftCorpus, generateReport, generateSyntheticRepo, getAblationCell, getBenchmark, getBenchmarkLowerIsBetter, getGitSha, getMemoryEvalDimension, getProviderBackedJudgePromptIdentity, getRemnicVersion, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, hashOrderedQuestionIds, hashString, integrityMetaIsComplete, interpretEffectSize, isAmaBenchUnknownLikeAnswer, isContaminationEntry, isContaminationManifest, isSealedQrelsArtifact, isSha256Hex, isStructuredJudgeProvider, isTaskFailed, judgeMemCorrectCorrectionAcceptance, judgeMemCorrectStaleMemoryHarm, lexicalSimilarity, linkMatches, listBenchmarkBaselines, listBenchmarkResults, listBenchmarks, listMemoryEvalBenchmarkIds, listMemoryEvalDimensions, llmJudgeScore, llmJudgeScoreDetailed, loadAblationFixture, loadBaseline, loadBeamDatasetPreview, loadBenchmarkArtifact, loadBenchmarkBaseline, loadBenchmarkReportCardProvenance, loadBenchmarkResult, loadCustomBenchmarkFile, loadJudgeCalibrationState, loadLoCoMo10, loadLocalLabManifest, loadLongMemEvalS, loadSealKeyFromEnv, loadSealedQrels, loadSealedRubric, matchEntity, mergeContaminationManifests, openSeal, orchestrateBenchmarkRuns, pairedDeltaConfidenceInterval, parseBenchmarkArtifact, parseCodexJsonlUsage, parseCustomBenchmark, parseLocalLabManifest, parseRubricResponse, parseSealedQrels, pickOne, pickStableQualifiedName, precisionAtK, preflightLoCoMoRetrievalTraceCapture, preflightLocalLabRole, projectFolderFixture, randomInt, recallAtK, reconcileCodexCreditLedger, redactBenchmarkResultSecrets, renderAttributionReportTable, renderBaselineMarkdown, renderBenchmarkResultExport, renderLoComoProfileDeltaMarkdown, renderLoComoRecallDeltaMarkdown, renderMemorySummaryForJudge, renderMemoryViewForAgent, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveCodexCreditBudgetConfig, resolveLocalLabJudgeProviderConfig, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runAttributeCliCommand, runBaseline, runBenchSuite, runBenchmark, runCodingGraphBenchmark, runCustomBenchmarkFile, runDriftGenCliCommand, runExplain, runExtractionAttack, runJudgeCalibration, runMitigatedBaseline, runProceduralAblation, runProceduralAblationCli, runSealedJudge, runSequentialPhases, runWithinCodexCreditBudget, safeHexEqual, sanitizeLoComoResultReference, saveBaseline, saveBenchmarkBaseline, schemaCompleteness, sealPayload, selectAmaBenchDiagnosticVariants, selectCalibrationSlice, selectFixtureVariant, serializeAttributionReport, serializeBenchmarkArtifact, serializeBuildWeekEvidenceReceipt, serializeJsonl, serializeLoCoMoRetrievalTraceDelta, serializeLoCoMoRetrievalTraceReceipt, serializeSealedQrels, shuffleTasks, shuffled, timed, validateDriftCorpus, verifyRubricDigest, writeBenchmarkArtifact, writeBenchmarkPublishFeed, writeBenchmarkReproManifest, writeBenchmarkResult, writeBuildWeekEvidenceReceipt, writeJudgeCalibrationState, writeLeaderboardArtifactsForResult, zeroScores };
+export { AMA_BENCH_DIAGNOSTIC_VARIANTS, ASSISTANT_AGENT_CONFIG_KEY, ASSISTANT_JUDGE_CONFIG_KEY, ASSISTANT_MEETING_PREP_SCENARIOS, ASSISTANT_MEETING_PREP_SMOKE_SCENARIOS, ASSISTANT_MORNING_BRIEF_SCENARIOS, ASSISTANT_MORNING_BRIEF_SMOKE_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SCENARIOS, ASSISTANT_NEXT_BEST_ACTION_SMOKE_SCENARIOS, ASSISTANT_RUBRIC_DIMENSIONS, ASSISTANT_RUBRIC_ID_KEY, ASSISTANT_SEEDS_CONFIG_KEY, ASSISTANT_SPOT_CHECK_DIR_KEY, ASSISTANT_SYNTHESIS_SCENARIOS, ASSISTANT_SYNTHESIS_SMOKE_SCENARIOS, type AblationConfigOverrides, type AbstentionRetrievalCase, type ActionIntentV1, ActionIntentV1Schema, type AggregateMetrics, type AmaBenchDiagnosticAdapterOptions, type AmaBenchDiagnosticAnswererMode, type AmaBenchDiagnosticBreakdown, type AmaBenchDiagnosticMatrixArtifact, type AmaBenchDiagnosticRecallMode, type AmaBenchDiagnosticRunContext, type AmaBenchDiagnosticTaskEvidence, type AmaBenchDiagnosticTaskRow, type AmaBenchDiagnosticVariant, type AmaBenchDiagnosticVariantSummary, type AnalyzeRepeatedFailureOptions, type AnthropicProviderConfig, type AssistantAgent, type AssistantMemoryFact, type AssistantMemoryGraph, type AssistantRubricDimension, type AssistantRubricRequest, type AssistantRubricScores, type AssistantRunnerOptions, type AssistantScenario, type AssistantStance, type AttackRecallOptions, type AttackRetrievalHit, type AttackerMode, type AttributeOptions, type AttributionClass, type AttributionEnvironment, type AttributionLabel, type AttributionMemory, type AttributionReport, BENCHMARK_ARTIFACT_SCHEMA_VERSION, BENCHMARK_INTEGRITY_META_SCHEMA, BENCHMARK_REPRO_MANIFEST_FILENAME, BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION, BENCHMARK_RESULT_SCHEMA, BENCHMARK_SPLIT_TYPES, BUILD_WEEK_EVIDENCE_RECEIPT_SCHEMA_VERSION, BUILD_WEEK_LIMITATIONS, type BaseTask, BaseTaskSchema, type BaselineRow, type BaselineScenario, type BeamDatasetPreview, type BenchConfig, type BenchJudge, type BenchJudgeResult, type BenchMemoryAdapter, type BenchModelSource, type BenchReasoningEffort, type BenchRecallLineageStatus, type BenchRecallOptions, type BenchRecallSupportAssessment, type BenchRecallSupportRequest, type BenchRecallSupportStatus, type BenchRecallTrace, type BenchRecallTraceCoreCapture, type BenchRecallTraceLcmCandidate, type BenchRecallTraceRange, type BenchRecallTraceSection, type BenchRecallTraceSelection, type BenchRecallWithTraceResult, type BenchResponder, type BenchResponse, type BenchRuntimeProfile, type BenchTier, type BenchmarkArtifact, type BenchmarkArtifactEnvironment, type BenchmarkArtifactHardware, type BenchmarkArtifactJudgeCalibration, type BenchmarkArtifactPerTaskScore, type BenchmarkArtifactSystem, type BenchmarkArtifactTier, type BenchmarkCategory, type BenchmarkDefinition, type BenchmarkExecutionProvenance, type BenchmarkIntegrityMeta, type BenchmarkMeta, type BenchmarkMode, type BenchmarkReport, type BenchmarkReproManifest, type BenchmarkReproManifestDataset, type BenchmarkReproManifestFile, type BenchmarkReproManifestResult, type BenchmarkReproManifestSupplementalArtifact, type BenchmarkResult, type BenchmarkSplitType, type BenchmarkStatus, type BenchmarkSuiteResult, type BenchmarkTier, type BootstrapKappaOptions, type BootstrapKappaResult, type BuildBenchmarkArtifactInput, type BuildBenchmarkPublishFeedOptions, type BuildBenchmarkReproManifestOptions, type BuildBuildWeekEvidenceReceiptOptions, type BuildWeekEvidenceReceipt, type BuildWeekEvidenceReceiptProvider, type BuildWeekLimitationCode, type BuiltInProvider, CALIBRATION_SLICE_SIZE, CANARY_FIXED_RECALL, CANARY_SCORE_FLOOR, DEFAULT_10K_FIXTURE as CODING_GRAPH_10K_FIXTURE, CODING_GRAPH_BENCH_SCHEMA_VERSION, DEFAULT_TOLERANCE_PERCENT as CODING_GRAPH_DEFAULT_TOLERANCE, MIN_ITERATIONS as CODING_GRAPH_MIN_ITERATIONS, DEFAULT_SMOKE_FIXTURE as CODING_GRAPH_SMOKE_FIXTURE, type CalibrationAnswer, type CalibrationVerdictPair, type CanaryAdapterOptions, type CanaryFloorCheck, type CaptureLoCoMoRetrievalTraceOptions, type ClaudeCliProviderConfig, type CodexCliNativeUsage, type CodexCliProviderConfig, CodexCreditAccountingError, type CodexCreditBudgetConfig, CodexCreditDispatchError, type CodexCreditReceipt, type CodexCreditReceiptScope, type CodexCreditReconciliationReceipt, type CodingGraphBaseline, type CodingGraphBenchConfig, type CodingGraphBenchReport, type MachineFingerprint as CodingGraphMachineFingerprint, type CodingGraphMetricKey, type RegressionMetricDetail as CodingGraphRegressionDetail, type RegressionMetricKey as CodingGraphRegressionKey, type RegressionGateResult as CodingGraphRegressionResult, type CohenKappaResult, type ComparisonMetricDelta, type ComparisonResult, type CompletionOpts, type CompletionResult, type ConfidenceInterval, type ContaminationCheckResult, type ContaminationEntry, type ContaminationManifest, type ControlledGateDecision, type ControlledResponsesAgentDriverConfig, type ControlledResponsesCaps, type ControlledResponsesDisposition, ControlledResponsesDriver, type ControlledResponsesDriverConfig, type ControlledResponsesEpisodeInput, type ControlledResponsesEpisodeResult, type ControlledResponsesFault, type ControlledResponsesResponseEvent, type ControlledResponsesToolDefinition, type ControlledResponsesToolEvent, type ControlledResponsesTransport, type CustomBenchmarkScoring, type CustomBenchmarkSpec, type CustomBenchmarkTask, DATASET_SPLITS, DEFAULT_ABLATION_BENCHMARK, DEFAULT_ABLATION_BOOTSTRAP_SEED, DEFAULT_ASSISTANT_RUBRIC_ID, DEFAULT_BASELINE_SCENARIOS, DEFAULT_JUDGE_BINARIZATION_THRESHOLD, DEFAULT_KAPPA_BOOTSTRAP_SAMPLES, DEFAULT_KAPPA_CONFIDENCE_LEVEL, DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL, DRIFT_GEN_DEFAULTS, DRIFT_GEN_VERSION, type DatasetSource, type DatasetSplit, type DiagnoseLoComoProfileDeltaOptions, type DiagnoseLoComoRecallDeltaOptions, type DiscoveredModel, type DriftGenAuditRecord, type DriftGenCorpus, type DriftGenManifest, type DriftGenOptions, type DriftGenResult, type DriftSession, type DriftSessionTurn, type DriftValidationReport, type DriftValidationStats, EMPTY_CONTAMINATION_MANIFEST, type EffectSizeInterpretation, type EffectSizeSummary, type EvaluateTaskStateOptions, type ExplainResult, type ExtractedEntity, type ExtractedLink, type ExtractedPage, type ExtractionAttackOptions, type ExtractionAttackResult, type ExtractionAttackTarget, type FixtureGenerator, type FixtureOutput, type FixtureVariant, GATE_STATUSES, GENERAL_ANSWER_JUDGE_RUBRIC, type GateStatus, type GeneratedFile, type GeneratedRepo, type GoldEntity, type GoldEntityType, type GoldFact, type GoldFactKind, type GoldGraph, type GoldLink, type GoldMemoryAttribution, type GoldPage, type GoldProbe, type GoldProbeCategory, type H6BenchmarkDataset, H6BenchmarkDatasetSchema, type H6TrapId, H6_ACTION_INTENT_JSON_SCHEMA, H6_ARMS, H6_DATASET_JSON_SCHEMA, H6_DECISION_RULE, H6_FROZEN_INVENTORY_HASH, H6_FROZEN_SEED, H6_FROZEN_SPLITS, H6_SUPPORT_ARTIFACT_PATHS, H6_TASK_JSON_SCHEMA, H6_TRAP_FINGERPRINT_JSON_SCHEMA, H6_TRAP_IDS, type HarnessRng, INTEGRITY_CIPHER_ALGORITHM, INTEGRITY_HASH_ALGORITHM, INTEGRITY_META_FIELDS, INVENTED_DOMAINS, type IngestionBenchAdapter, type IngestionLog, JUDGE_CALIBRATION_KAPPA_THRESHOLD, JUDGE_CALIBRATION_PROTOCOL_VERSION, type JudgeCalibrationCheckpointProvenance, type JudgeCalibrationIdentities, type JudgeCalibrationResult, type JudgeCategory, type KappaConfidenceInterval, LOCAL_LAB_PROVIDER_KINDS, LOCOMO_DATASET_FILENAMES, LOCOMO_FULL_TASK_COUNT, LOCOMO_RECALL_DIFF_LINE_LIMIT, LOCOMO_RECALL_EXCERPT_CHARS, LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION, LOCOMO_RETRIEVAL_TRACE_DELTA_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION, LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION, LONG_MEM_EVAL_DATASET_FILENAMES, type LeaderboardArtifactWrite, type LettaAdapterConfig, LettaMemCorrectAdapter, type LlmJudge, type LlmProvider, type LoCoMoCategory, type LoCoMoRetrievalMechanism, type LoCoMoRetrievalMechanismSummary, type LoCoMoRetrievalSessionReceipt, type LoCoMoRetrievalStructuralTrace, type LoCoMoRetrievalTaskDelta, type LoCoMoRetrievalTaskReceipt, type LoCoMoRetrievalTraceCoreCaptureReceipt, type LoCoMoRetrievalTraceDeltaReport, type LoCoMoRetrievalTraceProfile, type LoCoMoRetrievalTraceReceipt, type LoCoMoRetrievalTraceSelectionManifest, type LoCoMoRetrievalTraceSelector, type LoCoMoStructuralMultisetDelta, type LoComoCategoryDelta, type LoComoFinalContextRegression, type LoComoMetricDelta, type LoComoProfileArtifactEvidence, type LoComoProfileDeltaReport, type LoComoRawResultEvidence, type LoComoRecallCategoryDelta, type LoComoRecallContextSummary, type LoComoRecallDeltaReport, type LoComoRecallLineDelta, type LoComoRecallLineEvidence, type LoComoRecallMetricDelta, type LoComoRecallResultProvenance, type LoComoRecallTextDigest, type LoComoTaskRegression, type LoadDatasetOptions, type LoadSealedQrelsOptions, type LoadedDataset, type LoadedJudgeCalibrationState, type LocalLabManifest, type LocalLabManifestNotes, type LocalLabPhase, type LocalLabPhaseDescriptor, type LocalLabPhaseExecute, type LocalLabPhaseName, type LocalLabPhaseOutcome, LocalLabPreflightError, type LocalLabPreflightFailure, type LocalLabPreflightInput, type LocalLabPreflightOptions, type LocalLabPreflightResult, type LocalLabPreflightSuccess, type LocalLabProviderKind, type LocalLabRoleConfig, type LocalLlmProviderConfig, MAX_ROW_ATTEMPTS, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC, MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION, MEMCORRECT_STALE_HARM_RUBRIC, MEMCORRECT_STALE_HARM_RUBRIC_VERSION, MEMORY_EVAL_DIMENSIONS, MEMORY_EVAL_PUBLIC_LINE, MIN_CALIBRATION_SOURCE_TASKS, MITIGATED_BASELINE_SCENARIOS, type MaterializeOptions, type MaterializedRepo, type McpArgumentSemantic, type McpBackendErrorCode, type McpBackendResult, type McpBenchMemoryAdapter, type McpConformanceResult, type McpHttpTransportConfig, type McpListedTool, type McpMemCorrectAdapter, type McpMemoryAdapterOptions, McpMemoryBackendError, type McpMemoryToolMapping, type McpMemoryTransportConfig, type McpStdioTransportConfig, type McpToolCallResult, type McpToolClient, type McpToolMappingEntry, type McpToolMappingValue, type McpToolOperation, type Mem0AdapterConfig, Mem0MemCorrectAdapter, type MemCorrectGeneratorOptions, type MemCorrectJudgeRequest, type MemCorrectJudgeResult, type MemCorrectSystemAdapter, type MemoryEvalCategory, type MemoryEvalDimension, type MemoryEvalDimensionId, type MemoryEvalMetric, type MemoryGraph, type MemoryStats, type MemorySystem, type Message, type MetricAggregate, type MicroMetric, MissingCredentialError, type MitigatedBaselineConfig, type MitigatedTargetConfig, type MultipleChoiceQuestion, OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION, OTHER_NAMESPACE_MEMORIES, type OllamaChatMessage, type OllamaProviderConfig, type OpenAiCompatibleProviderConfig, OpenAiResponsesJudgeError, type OpenAiResponsesJudgeErrorCode, type OpenAiResponsesJudgeTelemetry, OpenAiResponsesProvider, type OpenAiResponsesProviderConfig, type OpenAiResponsesVerdict, type OpenAiResponsesVerdictResult, PROCEDURAL_REAL_SCENARIOS, PROCEDURAL_REAL_SCENARIOS_SMOKE, PUBLISHED_BENCHMARK_ARTIFACT_IDS, type PairedAnswerReplayCache, type PairedAnswerReplayEntry, type ParsedOllamaChatResponse, type PersonalizationRetrievalCase, type PreflightDiscoveredModel, type ProceduralAblationArtifact, type ProceduralAblationPerCase, type ProceduralAblationScenario, type ProceduralRealScenario, type ProceduralRealScenarioCategory, type ProviderBaseConfig, type ProviderConfig, type ProviderDiscoveryResult, type ProviderFactoryConfig, type PublishSkipReason, type PublishSkipRecord, type PublishedBenchmarkFeed, type PublishedBenchmarkFeedEntry, type PublishedBenchmarkId, REPEATED_FAILURE_ARMS, REPEATED_FAILURE_CONFIDENCE_LEVEL, REPEATED_FAILURE_INVALID_REASONS, REPEATED_FAILURE_STATISTICS_DRAWS, REQUIRED_FRONTMATTER_FIELDS, type RecallMetrics, type RecoveredMemory, type RegressionDetail, type RegressionGateResult$1 as RegressionGateResult, type RemnicAdapterOptions, type RepeatedFailureActionEvaluator, type RepeatedFailureArm, type RepeatedFailureCheckpointLoadResult, type RepeatedFailureCliCommandResult, type RepeatedFailureEffectAnalysis, type RepeatedFailureEpisode, type RepeatedFailureEpisodeDriver, type RepeatedFailureEpisodeEvidence, type RepeatedFailureEpisodeInput, type RepeatedFailureEpisodeRow, type RepeatedFailureExpectedDesign, type RepeatedFailureFactPairAudit, type RepeatedFailureFinalRepoEvidence, type RepeatedFailureFinalState, type RepeatedFailureGateEvent, type RepeatedFailureHolmResult, type RepeatedFailureInterval, type RepeatedFailureInvalidReason, type RepeatedFailureIsolationIdentity, type RepeatedFailureLocalToolHost, type RepeatedFailureNullableInterval, RepeatedFailureOllamaChatDriver, type RepeatedFailureOllamaChatDriverConfig, type RepeatedFailureProposedAction, type RepeatedFailureRowCheckpoint, type RepeatedFailureRowClaim, type RepeatedFailureRowIdentity, RepeatedFailureRowStore, type RepeatedFailureRowStoreOptions, type RepeatedFailureRunMetadata, type RepeatedFailureStatisticalAnalysis, type RepeatedFailureSuiteManifest, type RepeatedFailureSupportDecision, type RepeatedFailureTaskCut, type RepeatedFailureTimidityAnalysis, type RepeatedFailureTokenUsage, type RepeatedFailureTokenizer, type RepeatedFailureToolDefinition, type RepeatedFailureToolExecutionResult, type RepeatedFailureTrapAuditArtifact, type RepeatedFailureTrapAuditExpected, type RepeatedFailureTrapAuditMetrics, type RepeatedFailureTrapAuditRow, type RepeatedFailureTrapAuditRowIdentity, type RepeatedFailureTrapAuditThresholds, type RepeatedFailureTry, type ReplayRepeatedFailureStatisticsOptions, type ReportCardProvenanceContext, type ResolveBenchRuntimeProfileOptions, type ResolvedBenchRuntimeProfile, type ResolvedLocalLabProfile, type ResolvedLocalLabRole, type ResolvedRunBenchmarkOptions, type ResponsesApiOutputItem, type ResponsesApiRequest, type ResponsesApiResponse, type ResponsesApiUsage, type RetrievalMissStage, type RevisionShas, type RotatedChoices, type RunBenchmarkOptions, type RunJudgeCalibrationOptions, type RunProceduralAblationCliArgs, type RunProceduralAblationOptions, type RunRepeatedFailureCliCommandInput, type RunRepeatedFailureSuiteOptions, type RunRepeatedFailureSuiteResult, type RunSequentialPhasesOptions, type RunTrapAuditOptions, SCHEMA_TIER_FIXTURE, SCHEMA_TIER_SMOKE_FIXTURE, SEALED_PROMPT_REGISTRY, SINGLE_FLAG_ABLATION_MATRIX, STATE_CLASSIFICATIONS, SYNTHETIC_MEMORIES, type SanitizedDiagnosticProvider, type SavedBaseline, type SchemaTierCorpus, type SchemaTierFixture, type SchemaTierName, type SchemaTierPage, type SchemaTierPageFrontmatter, type SealedArtifact, type SealedJudgeDecision, type SealedJudgeInput, type SealedQrelsArtifact, type SealedQrelsHandle, type SealedRubric, type SearchResult, type SeededMemory, type SeededRandom, type SeededRng, type SequentialPhaseHooks, type SingleFlagAblationCell, type SingleFlagAblationId, type SpotCheckLogger, type StageObservation, type StageStatus, type StateClassification, type StateEvaluationResult, type StatisticalReport, type StrategyPatch, StrategyPatchSchema, type StructuredJudge, StructuredJudgeError, type StructuredJudgeErrorCode, type StructuredJudgeProvider, type StructuredJudgeTelemetry, type StructuredJudgeVerdict, type StructuredJudgeVerdictResult, type StructuredVerdictRequest, type SyntheticEdge, type SyntheticEmailIngestionAdapterOptions, type SyntheticFile, type SyntheticFileIR, SyntheticFileSchema, type SyntheticRepoConfig, type SyntheticSymbol, type SyntheticTargetOptions, TRAP_TAXONOMY, type TaskAttribution, type TaskAttributionGoldWitnessV1, type TaskAttributionRetrievalWitnessV1, type TaskAttributionWitness, type TaskAttributionWitnessRuntimeV1, type TaskAttributionWitnessV1, type TaskResult, type TaskTokenUsage, type TaskVariant, TaskVariantSchema, type TemporalRetrievalCase, type ThirdPartyAdapterConfig, type TierDetail, type TimelineEntry, type TokenUsage, type TrapFingerprintV1, TrapFingerprintV1Schema, type TrapTaxonomyItem, TrapTaxonomyItemSchema, type ValidationIssue, type ValidationReport, type WallMetric, type WriteBenchmarkArtifactResult, type ZepAdapterConfig, ZepMemCorrectAdapter, addContaminationEntry, aggregateTaskScores, analyzeRepeatedFailureRows, answerBenchmarkQuestion, applyPatchAndCommit, assertCanaryUnderFloor, assertIntegrityMetaPresent, assertPublishableIntegrity, assertSha256Hex, assertTrapDatasetPreflight, assistantMeetingPrepDefinition, assistantMorningBriefDefinition, assistantNextBestActionDefinition, assistantSynthesisDefinition, attributeGoldMemory, attributeRun, attributeTask, backlinkF1, binarizeJudgeScore, bootstrapCohensKappaConfidenceInterval, bootstrapMeanConfidenceInterval, buildAmaBenchDiagnosticMatrixArtifact, buildAmaBenchDiagnosticVariantSummary, buildAmaBenchLeaderboardRows, buildBaselineFromReport, buildBenchmarkArtifact, buildBenchmarkArtifactFilename, buildBenchmarkPublishFeed, buildBenchmarkReproManifest, buildBenchmarkRunSeeds, buildBuildWeekEvidenceReceipt, buildCodexCreditReceipt, buildDriftCorpus, buildJudgePayload, buildOracleTrajectoryRecall, buildProviderFreeLoCoMoRetrievalConfig, buildRepeatedFailureRowKey, buildSchemaTierFixture, buildSchemaTierSmokeFixture, calculateCodexBudgetUnits, calculateJaccardSimilarity, calendarFixture, canonicalJsonStringify, captureBenchmarkExecutionProvenance, captureLoCoMoRetrievalTrace, captureMachineFingerprint, chatFixture, checkCodingGraphRegression, checkDatasetContamination, checkRegression, clampScore, cohensD, compareResults, computeBenchmarkReproDatasetInventoryHash, computeBenchmarkReproManifestArtifactHash, computeCohensKappa, computeH6InventoryHash, computeH6SupportArtifactHashes, computeRevisionShas, computeSealHash, computeTrapAuditArtifactHash, computeTrapAuditMetrics, containsAnswer, createSeededRng$1 as createAdamSeededRng, createAmaBenchDiagnosticAdapter, createAnthropicProvider, createCanaryAdapter, createClaudeCliProvider, createCodexCliProvider, createSeededRng as createCodingGraphSeededRng, createControlledResponsesAgentDriver, createDeterministicSpotCheckLogger, createGatewayResponder, createLightweightAdapter, createLiteLlmProvider, createLocalLlmProvider, createMcpDemoMemCorrectAdapter, createMcpDemoMemoryAdapter, createMcpMemCorrectAdapter, createMcpMemoryAdapter, createMitigatedTarget, createOllamaProvider, createOpenAiCompatibleProvider, createOpenAiResponsesBenchJudge, createOpenAiResponsesProvider, createSeededRandom$1 as createProceduralAblationSeededRandom, createProvider, createProviderBackedAmaBenchRecommendedJudge, createProviderBackedJudge, createProviderBackedResponder, createProviderBackedStructuredJudge, createRemnicAdapter, createRepeatedFailureOllamaChatDriver, createResponderFromProvider, createSeededRandom, createSeededRng$2 as createSeededRng, createSpotCheckFileLogger, createStructuredBenchJudge, createStructuredJudgeFromProvider, createSyntheticEmailIngestionAdapter, createSyntheticTarget, createTimeoutGuardedAdapter, decideRepeatedFailureContent, decideRepeatedFailureStudy, decideRepeatedFailureTiming, defaultBenchmarkBaselineDir, defaultBenchmarkPublishPath, deleteBenchmarkResults, diagnoseLoCoMoRetrievalTraceDelta, diagnoseLoComoProfileDelta, diagnoseLoComoRecallDelta, discoverAllProviders, discoveryEndpointFor, emailFixture, entityRecall, evaluateTaskState, exactMatch, extractMetrics as extractCodingGraphMetrics, extractContentWords, extractMarkdownSectionsByTitle, f1Score, fixtureToAblationScenarios, formatHandoffNote, formatMissingDatasetError, generateDriftCorpus, generateH6BenchmarkDataset, generateReport, generateSyntheticRepo, getAblationCell, getBenchmark, getBenchmarkLowerIsBetter, getGitSha, getMemoryEvalDimension, getProviderBackedJudgePromptIdentity, getRemnicVersion, getTrapTaxonomyItem, hashBenchmarkArtifact, hashBytes, hashCanonicalJson, hashOrderedQuestionIds, hashString, holmAdjust, integrityMetaIsComplete, interpretEffectSize, isAmaBenchUnknownLikeAnswer, isContaminationEntry, isContaminationManifest, isRepeatedFailureTimidityEquivalent, isSafeSyntheticPath, isSealedQrelsArtifact, isSha256Hex, isStructuredJudgeProvider, isTaskFailed, judgeMemCorrectCorrectionAcceptance, judgeMemCorrectStaleMemoryHarm, lexicalSimilarity, linkMatches, listBenchmarkBaselines, listBenchmarkResults, listBenchmarks, listMemoryEvalBenchmarkIds, listMemoryEvalDimensions, llmJudgeScore, llmJudgeScoreDetailed, loadAblationFixture, loadBaseline, loadBeamDatasetPreview, loadBenchmarkArtifact, loadBenchmarkBaseline, loadBenchmarkReportCardProvenance, loadBenchmarkResult, loadCommittedH6BenchmarkDataset, loadCustomBenchmarkFile, loadJudgeCalibrationState, loadLoCoMo10, loadLocalLabManifest, loadLongMemEvalS, loadSealKeyFromEnv, loadSealedQrels, loadSealedRubric, matchEntity, materializeTaskRepo, mergeContaminationManifests, openSeal, orchestrateBenchmarkRuns, pairedDeltaConfidenceInterval, parseBenchmarkArtifact, parseCodexJsonlUsage, parseCustomBenchmark, parseLocalLabManifest, parseRepeatedFailureEpisodeRow, parseRubricResponse, parseSealedQrels, pickOne, pickStableQualifiedName, precisionAtK, preflightLoCoMoRetrievalTraceCapture, preflightLocalLabRole, projectFolderFixture, randomInt, recallAtK, reconcileCodexCreditLedger, redactBenchmarkResultSecrets, relativeRiskReduction, renderAttributionReportTable, renderBaselineMarkdown, renderBenchmarkResultExport, renderLoComoProfileDeltaMarkdown, renderLoComoRecallDeltaMarkdown, renderMemorySummaryForJudge, renderMemoryViewForAgent, replayRepeatedFailureStatistics, resolveAssistantAgent, resolveAssistantRubricId, resolveAssistantSeeds, resolveAssistantSpotCheckDir, resolveBenchRuntimeProfile, resolveBenchmarkPhaseTimeoutMs, resolveBenchmarkProgressLogging, resolveBenchmarkResultReference, resolveBenchmarkRunCount, resolveBenchmarkRunId, resolveCodexCreditBudgetConfig, resolveCommittedH6FixtureDirectory, resolveLocalLabJudgeProviderConfig, resolveLocalLabProfile, resolveLocalLabRole, resolveStructuredJudge, rotateDistractors, rougeL, runAssistantBenchmark, runAssistantMeetingPrepBenchmark, runAssistantMorningBriefBenchmark, runAssistantNextBestActionBenchmark, runAssistantSynthesisBenchmark, runAttributeCliCommand, runBaseline, runBenchSuite, runBenchmark, runCodingGraphBenchmark, runCustomBenchmarkFile, runDriftGenCliCommand, runExplain, runExtractionAttack, runJudgeCalibration, runMitigatedBaseline, runProceduralAblation, runProceduralAblationCli, runRepeatedFailureCliCommand, runRepeatedFailurePaperReportCliCommand, runRepeatedFailureSuite, runSealedJudge, runSequentialPhases, runTrapAudit, runTrapAuditCliCommand, runWithinCodexCreditBudget, safeHexEqual, sanitizeBenchmarkResultForJson, sanitizeLoComoResultReference, saveBaseline, saveBenchmarkBaseline, schemaCompleteness, sealPayload, selectAmaBenchDiagnosticVariants, selectCalibrationSlice, selectFixtureVariant, serializeAttributionReport, serializeBenchmarkArtifact, serializeBuildWeekEvidenceReceipt, serializeH6FixtureJson, serializeJsonl, serializeLoCoMoRetrievalTraceDelta, serializeLoCoMoRetrievalTraceReceipt, serializeSealedQrels, shuffleTasks, shuffled, timed, tokenizeContent, unresolvedHelperImports, validateDriftCorpus, validateH6Dataset, validateH6FixtureBundle, validateH6StateDefiningIndependence, validateOllamaChatEndpoint, verifyMatchingTrapAudit, verifyRubricDigest, verifyTrapAuditArtifact, writeBenchmarkArtifact, writeBenchmarkPublishFeed, writeBenchmarkReproManifest, writeBenchmarkResult, writeBuildWeekEvidenceReceipt, writeH6FixtureBundle, writeJudgeCalibrationState, writeLeaderboardArtifactsForResult, writeRepeatedFailurePaperArtifacts, writeRepeatedFailureRunMetadata, writeRepeatedFailureStatistics, zeroScores };