opencode-swarm 7.115.0 → 7.116.1

package/dist/evaluation/contracts.d.ts

@@ -0,0 +1,545 @@
+import { z } from 'zod';
+declare const IdentifierSchema: z.ZodString;
+declare const Sha256Schema: z.ZodString;
+declare const RelativePathSchema: z.ZodString;
+export { IdentifierSchema as EvaluationIdentifierSchema };
+export { Sha256Schema as EvaluationSha256Schema };
+export { RelativePathSchema as EvaluationRelativePathSchema };
+export declare const EvaluationSplitSchema: z.ZodEnum<{
+    test: "test";
+    train: "train";
+    validation: "validation";
+}>;
+export type EvaluationSplit = z.infer<typeof EvaluationSplitSchema>;
+export declare const CostRecordSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        reported: "reported";
+        estimated: "estimated";
+        unavailable: "unavailable";
+    }>;
+    usd: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CostRecord = z.infer<typeof CostRecordSchema>;
+export declare const HumanReviewReceiptSchema: z.ZodObject<{
+    reviewer: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    instruction: z.ZodLiteral<true>;
+    fixture: z.ZodLiteral<true>;
+    scorer: z.ZodLiteral<true>;
+    secretsPrivacy: z.ZodLiteral<true>;
+    license: z.ZodLiteral<true>;
+    split: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export declare const EvaluationTaskV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    id: z.ZodString;
+    derivedFromTaskId: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        curated: "curated";
+        "trace-proposal": "trace-proposal";
+    }>;
+    split: z.ZodEnum<{
+        test: "test";
+        train: "train";
+        validation: "validation";
+    }>;
+    category: z.ZodString;
+    protected: z.ZodDefault<z.ZodBoolean>;
+    instructionPath: z.ZodString;
+    environment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"fixture">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"container">;
+        path: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    scorer: z.ZodObject<{
+        kind: z.ZodEnum<{
+            project: "project";
+            builtin: "builtin";
+        }>;
+        argv: z.ZodArray<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+        scoreRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strict>;
+    provenance: z.ZodObject<{
+        origin: z.ZodString;
+        license: z.ZodString;
+        collectedAt: z.ZodOptional<z.ZodISODateTime>;
+        review: z.ZodOptional<z.ZodObject<{
+            reviewer: z.ZodString;
+            reviewedAt: z.ZodISODateTime;
+            instruction: z.ZodLiteral<true>;
+            fixture: z.ZodLiteral<true>;
+            scorer: z.ZodLiteral<true>;
+            secretsPrivacy: z.ZodLiteral<true>;
+            license: z.ZodLiteral<true>;
+            split: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type EvaluationTaskV1 = z.infer<typeof EvaluationTaskV1Schema>;
+export declare const EvaluationCandidateV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        baseline: "baseline";
+        skill: "skill";
+        harness: "harness";
+    }>;
+    payloadPath: z.ZodString;
+    model: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type EvaluationCandidateV1 = z.infer<typeof EvaluationCandidateV1Schema>;
+export declare const EvaluationOutcomeSchema: z.ZodEnum<{
+    timeout: "timeout";
+    cancelled: "cancelled";
+    unsupported: "unsupported";
+    scored: "scored";
+    infrastructure_failure: "infrastructure_failure";
+    malformed: "malformed";
+    integrity_failure: "integrity_failure";
+}>;
+export type EvaluationOutcome = z.infer<typeof EvaluationOutcomeSchema>;
+export declare const EvaluationResultV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    taskId: z.ZodString;
+    category: z.ZodString;
+    protected: z.ZodDefault<z.ZodBoolean>;
+    repetition: z.ZodNumber;
+    candidateId: z.ZodString;
+    seed: z.ZodString;
+    outcome: z.ZodEnum<{
+        timeout: "timeout";
+        cancelled: "cancelled";
+        unsupported: "unsupported";
+        scored: "scored";
+        infrastructure_failure: "infrastructure_failure";
+        malformed: "malformed";
+        integrity_failure: "integrity_failure";
+    }>;
+    score: z.ZodOptional<z.ZodNumber>;
+    scoreRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    cost: z.ZodObject<{
+        source: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            unavailable: "unavailable";
+        }>;
+        usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    durationMs: z.ZodNumber;
+    retries: z.ZodDefault<z.ZodNumber>;
+    failureCode: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type EvaluationResultV1 = z.infer<typeof EvaluationResultV1Schema>;
+export declare const EvaluationBudgetsV1Schema: z.ZodObject<{
+    maxTasks: z.ZodNumber;
+    maxRepetitions: z.ZodNumber;
+    maxConcurrency: z.ZodNumber;
+    maxTaskTimeMs: z.ZodNumber;
+    maxRetries: z.ZodNumber;
+    maxOutputBytes: z.ZodNumber;
+    maxSpendUsd: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const EnvironmentFingerprintV1Schema: z.ZodObject<{
+    platform: z.ZodString;
+    arch: z.ZodString;
+    runtime: z.ZodString;
+    baseSha: z.ZodString;
+    activeTreeHash: z.ZodString;
+    taskSetHash: z.ZodString;
+}, z.core.$strict>;
+export declare const EvaluationRunV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        complete: "complete";
+        cancelled: "cancelled";
+        inconclusive: "inconclusive";
+    }>;
+    baseline: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            baseline: "baseline";
+            skill: "skill";
+            harness: "harness";
+        }>;
+        payloadPath: z.ZodString;
+        model: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    candidate: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            baseline: "baseline";
+            skill: "skill";
+            harness: "harness";
+        }>;
+        payloadPath: z.ZodString;
+        model: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    taskSet: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        taskIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    split: z.ZodEnum<{
+        test: "test";
+        train: "train";
+        validation: "validation";
+    }>;
+    seed: z.ZodString;
+    models: z.ZodArray<z.ZodString>;
+    environment: z.ZodObject<{
+        platform: z.ZodString;
+        arch: z.ZodString;
+        runtime: z.ZodString;
+        baseSha: z.ZodString;
+        activeTreeHash: z.ZodString;
+        taskSetHash: z.ZodString;
+    }, z.core.$strict>;
+    budgets: z.ZodObject<{
+        maxTasks: z.ZodNumber;
+        maxRepetitions: z.ZodNumber;
+        maxConcurrency: z.ZodNumber;
+        maxTaskTimeMs: z.ZodNumber;
+        maxRetries: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+        maxSpendUsd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    results: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        taskId: z.ZodString;
+        category: z.ZodString;
+        protected: z.ZodDefault<z.ZodBoolean>;
+        repetition: z.ZodNumber;
+        candidateId: z.ZodString;
+        seed: z.ZodString;
+        outcome: z.ZodEnum<{
+            timeout: "timeout";
+            cancelled: "cancelled";
+            unsupported: "unsupported";
+            scored: "scored";
+            infrastructure_failure: "infrastructure_failure";
+            malformed: "malformed";
+            integrity_failure: "integrity_failure";
+        }>;
+        score: z.ZodOptional<z.ZodNumber>;
+        scoreRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        cost: z.ZodObject<{
+            source: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                unavailable: "unavailable";
+            }>;
+            usd: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        durationMs: z.ZodNumber;
+        retries: z.ZodDefault<z.ZodNumber>;
+        failureCode: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    cost: z.ZodObject<{
+        source: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            unavailable: "unavailable";
+        }>;
+        usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    integrityHash: z.ZodString;
+}, z.core.$strict>;
+export type EvaluationRunV1 = z.infer<typeof EvaluationRunV1Schema>;
+export declare const PromotionPolicyV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    minValidPairs: z.ZodDefault<z.ZodNumber>;
+    minCoverage: z.ZodDefault<z.ZodNumber>;
+    deadband: z.ZodDefault<z.ZodNumber>;
+    confidence: z.ZodDefault<z.ZodLiteral<0.95>>;
+    bootstrapResamples: z.ZodDefault<z.ZodLiteral<10000>>;
+    requireAvailableCosts: z.ZodDefault<z.ZodBoolean>;
+    protectedCategoryTolerances: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strict>;
+export type PromotionPolicyV1 = z.infer<typeof PromotionPolicyV1Schema>;
+export declare const PromotionDecisionV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    decisionId: z.ZodString;
+    runId: z.ZodString;
+    decidedAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        inconclusive: "inconclusive";
+        accept: "accept";
+        reject: "reject";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    baseline: z.ZodObject<{
+        baselineRunId: z.ZodString;
+        baselineCandidateId: z.ZodString;
+        baselineMean: z.ZodNumber;
+        candidateMean: z.ZodNumber;
+        pairedDelta: z.ZodNumber;
+        confidenceInterval: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        validPairs: z.ZodNumber;
+        missingPairs: z.ZodNumber;
+        coverage: z.ZodNumber;
+    }, z.core.$strict>;
+    historicalBest: z.ZodObject<{
+        baselineRunId: z.ZodString;
+        baselineCandidateId: z.ZodString;
+        baselineMean: z.ZodNumber;
+        candidateMean: z.ZodNumber;
+        pairedDelta: z.ZodNumber;
+        confidenceInterval: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        validPairs: z.ZodNumber;
+        missingPairs: z.ZodNumber;
+        coverage: z.ZodNumber;
+    }, z.core.$strict>;
+    deadband: z.ZodNumber;
+    bootstrap: z.ZodObject<{
+        resamples: z.ZodLiteral<10000>;
+        confidence: z.ZodLiteral<0.95>;
+        seedHash: z.ZodString;
+    }, z.core.$strict>;
+    categories: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        protected: z.ZodBoolean;
+        tolerance: z.ZodNumber;
+        baselineMean: z.ZodNumber;
+        candidateMean: z.ZodNumber;
+        pairedDelta: z.ZodNumber;
+        regression: z.ZodBoolean;
+    }, z.core.$strict>>;
+    lineage: z.ZodObject<{
+        baselineRunId: z.ZodString;
+        historicalBestRunId: z.ZodString;
+        taskSetHash: z.ZodString;
+        baselineHash: z.ZodString;
+        candidateHash: z.ZodString;
+        historicalBestHash: z.ZodString;
+    }, z.core.$strict>;
+    policyHash: z.ZodString;
+    unavailableQualityMetrics: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        complexity_delta: "complexity_delta";
+        public_api_delta: "public_api_delta";
+    }>>>;
+}, z.core.$strict>;
+export type PromotionDecisionV1 = z.infer<typeof PromotionDecisionV1Schema>;
+export declare const GateNameSchema: z.ZodEnum<{
+    reviewer: "reviewer";
+    sast: "sast";
+    "test-engineer": "test-engineer";
+    mutation: "mutation";
+    quality: "quality";
+}>;
+export type GateName = z.infer<typeof GateNameSchema>;
+export declare const GateAuditManifestV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    id: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    taskIds: z.ZodArray<z.ZodString>;
+    gates: z.ZodArray<z.ZodEnum<{
+        reviewer: "reviewer";
+        sast: "sast";
+        "test-engineer": "test-engineer";
+        mutation: "mutation";
+        quality: "quality";
+    }>>;
+    models: z.ZodArray<z.ZodString>;
+    preferredSwarm: z.ZodOptional<z.ZodString>;
+    repetitions: z.ZodNumber;
+    seed: z.ZodString;
+    maxConcurrency: z.ZodNumber;
+    maxRetries: z.ZodNumber;
+    maxTimeMs: z.ZodNumber;
+    maxCostUsd: z.ZodOptional<z.ZodNumber>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type GateAuditManifestV1 = z.infer<typeof GateAuditManifestV1Schema>;
+export declare const GateAuditCellV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    taskId: z.ZodString;
+    candidateId: z.ZodOptional<z.ZodString>;
+    defectType: z.ZodString;
+    gate: z.ZodEnum<{
+        reviewer: "reviewer";
+        sast: "sast";
+        "test-engineer": "test-engineer";
+        mutation: "mutation";
+        quality: "quality";
+    }>;
+    model: z.ZodString;
+    repetition: z.ZodNumber;
+    outcome: z.ZodEnum<{
+        unsupported: "unsupported";
+        infrastructure_failure: "infrastructure_failure";
+        caught: "caught";
+        missed: "missed";
+        false_rejection: "false_rejection";
+    }>;
+    retries: z.ZodNumber;
+    cost: z.ZodObject<{
+        source: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            unavailable: "unavailable";
+        }>;
+        usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    durationMs: z.ZodNumber;
+    failureClassification: z.ZodOptional<z.ZodEnum<{
+        clean: "clean";
+        infrastructure_failure: "infrastructure_failure";
+        pre_existing_failure: "pre_existing_failure";
+        new_regression: "new_regression";
+        flaky_failure: "flaky_failure";
+        unknown_failure: "unknown_failure";
+    }>>;
+    failureCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type GateAuditCellV1 = z.infer<typeof GateAuditCellV1Schema>;
+export declare const GateAuditResultV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    manifestHash: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        complete: "complete";
+        cancelled: "cancelled";
+        inconclusive: "inconclusive";
+    }>;
+    cells: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        taskId: z.ZodString;
+        candidateId: z.ZodOptional<z.ZodString>;
+        defectType: z.ZodString;
+        gate: z.ZodEnum<{
+            reviewer: "reviewer";
+            sast: "sast";
+            "test-engineer": "test-engineer";
+            mutation: "mutation";
+            quality: "quality";
+        }>;
+        model: z.ZodString;
+        repetition: z.ZodNumber;
+        outcome: z.ZodEnum<{
+            unsupported: "unsupported";
+            infrastructure_failure: "infrastructure_failure";
+            caught: "caught";
+            missed: "missed";
+            false_rejection: "false_rejection";
+        }>;
+        retries: z.ZodNumber;
+        cost: z.ZodObject<{
+            source: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                unavailable: "unavailable";
+            }>;
+            usd: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        durationMs: z.ZodNumber;
+        failureClassification: z.ZodOptional<z.ZodEnum<{
+            clean: "clean";
+            infrastructure_failure: "infrastructure_failure";
+            pre_existing_failure: "pre_existing_failure";
+            new_regression: "new_regression";
+            flaky_failure: "flaky_failure";
+            unknown_failure: "unknown_failure";
+        }>>;
+        failureCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    cost: z.ZodObject<{
+        source: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            unavailable: "unavailable";
+        }>;
+        usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    qualityMetricAvailability: z.ZodObject<{
+        complexity_delta: z.ZodLiteral<"unavailable">;
+        public_api_delta: z.ZodLiteral<"unavailable">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type GateAuditResultV1 = z.infer<typeof GateAuditResultV1Schema>;
+export declare const TestConsumptionClaimV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    taskSetHash: z.ZodString;
+    baselineHash: z.ZodString;
+    candidateHash: z.ZodString;
+    claimedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type TestConsumptionClaimV1 = z.infer<typeof TestConsumptionClaimV1Schema>;
+export declare const TaskSetSnapshotV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    id: z.ZodString;
+    split: z.ZodEnum<{
+        test: "test";
+        train: "train";
+        validation: "validation";
+    }>;
+    tasks: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        id: z.ZodString;
+        derivedFromTaskId: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            curated: "curated";
+            "trace-proposal": "trace-proposal";
+        }>;
+        split: z.ZodEnum<{
+            test: "test";
+            train: "train";
+            validation: "validation";
+        }>;
+        category: z.ZodString;
+        protected: z.ZodDefault<z.ZodBoolean>;
+        instructionPath: z.ZodString;
+        environment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"fixture">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"container">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        scorer: z.ZodObject<{
+            kind: z.ZodEnum<{
+                project: "project";
+                builtin: "builtin";
+            }>;
+            argv: z.ZodArray<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            scoreRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strict>;
+        provenance: z.ZodObject<{
+            origin: z.ZodString;
+            license: z.ZodString;
+            collectedAt: z.ZodOptional<z.ZodISODateTime>;
+            review: z.ZodOptional<z.ZodObject<{
+                reviewer: z.ZodString;
+                reviewedAt: z.ZodISODateTime;
+                instruction: z.ZodLiteral<true>;
+                fixture: z.ZodLiteral<true>;
+                scorer: z.ZodLiteral<true>;
+                secretsPrivacy: z.ZodLiteral<true>;
+                license: z.ZodLiteral<true>;
+                split: z.ZodLiteral<true>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type TaskSetSnapshotV1 = z.infer<typeof TaskSetSnapshotV1Schema>;

package/dist/evaluation/disposable-worktree.d.ts

@@ -0,0 +1,38 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { resolveExecutableFromPath, runExternalTool } from '../utils/external-tool-runner.js';
+export type WorkingTreeFingerprint = {
+    head: string;
+    porcelainHash: string;
+};
+export type DisposableWorktree = {
+    path: string;
+    baseSha: string;
+};
+export declare class DisposableWorktreeCleanupError extends Error {
+    readonly worktreePath: string;
+    readonly pathPresent: boolean;
+    readonly registrationPresent: boolean | undefined;
+    readonly cleanupErrors: string[];
+    readonly code = "evaluation-worktree-cleanup-failed";
+    constructor(worktreePath: string, pathPresent: boolean, registrationPresent: boolean | undefined, cleanupErrors: string[]);
+}
+export declare function captureWorkingTreeFingerprint(projectRoot: string, abortSignal?: AbortSignal): Promise<WorkingTreeFingerprint>;
+export declare function createDisposableWorktree(projectRoot: string, baseRef: string, abortSignal?: AbortSignal): Promise<DisposableWorktree>;
+export declare function removeDisposableWorktree(projectRoot: string, worktreePath: string): Promise<void>;
+export declare function withDisposableWorktree<T>(args: {
+    projectRoot: string;
+    baseRef: string;
+    abortSignal?: AbortSignal;
+    run: (worktree: DisposableWorktree) => Promise<T>;
+}): Promise<T>;
+export declare const _internals: {
+    runExternalTool: typeof runExternalTool;
+    resolveExecutableFromPath: typeof resolveExecutableFromPath;
+    tmpdir: typeof os.tmpdir;
+    rmSync: typeof fs.rmSync;
+    existsSync: typeof fs.existsSync;
+    captureWorkingTreeFingerprint: typeof captureWorkingTreeFingerprint;
+    createDisposableWorktree: typeof createDisposableWorktree;
+    removeDisposableWorktree: typeof removeDisposableWorktree;
+};

package/dist/evaluation/fixtures.d.ts

@@ -0,0 +1,8 @@
+import { type EvaluationTaskV1 } from './contracts.js';
+export declare const TIER1_FIXTURE_IDS: readonly ["mutation-off-by-one", "null-substitution", "operator-swap", "guard-removal", "branch-swap", "side-effect-deletion", "curated-off-by-one", "missing-await", "swallowed-error", "injection-prone-string", "missing-auth-check", "boundary-error"];
+export type Tier1FixtureId = (typeof TIER1_FIXTURE_IDS)[number];
+export declare function resolveTier1FixtureRoot(packageRoot: string): string;
+export declare function resolveTier1FixtureDirectory(packageRoot: string, fixtureId: Tier1FixtureId): string;
+export declare function listTier1FixtureManifests(packageRoot: string): string[];
+/** Load packed Harbor-style manifests and rebase their package-relative paths. */
+export declare function loadTier1EvaluationTasks(packageRoot: string): Promise<EvaluationTaskV1[]>;

package/dist/evaluation/gate-audit.d.ts

@@ -0,0 +1,32 @@
+import type { GateAuditManifestV1, GateAuditResultV1 } from './contracts.js';
+import { captureWorkingTreeFingerprint } from './disposable-worktree.js';
+import type { EvaluationModelDispatcher } from './model-dispatcher.js';
+declare const CANDIDATE_VARIANTS: readonly ["defect", "clean"];
+type CandidateVariant = (typeof CANDIDATE_VARIANTS)[number];
+export type RunGateAuditOptions = {
+    projectRoot: string;
+    packageRoot: string;
+    manifest: GateAuditManifestV1;
+    dispatcher?: EvaluationModelDispatcher;
+    parentSessionId?: string;
+    abortSignal?: AbortSignal;
+};
+type MutationGateResult = {
+    outcome: 'caught' | 'missed' | 'infrastructure_failure';
+    failureCode?: string;
+};
+/** Run a green baseline first, then apply and test the reviewed real defect patch. */
+export declare function runMutationGateAdapter(args: {
+    directory: string;
+    mutationType: string;
+    timeoutMs: number;
+    variant: CandidateVariant;
+    abortSignal?: AbortSignal;
+}): Promise<MutationGateResult>;
+export declare function runGateAudit(options: RunGateAuditOptions): Promise<GateAuditResultV1>;
+export declare function createGateAuditManifest(input: Omit<GateAuditManifestV1, 'contentHash'>): GateAuditManifestV1;
+export declare function defaultGateAuditId(seed: string): string;
+export declare const _gateAuditInternals: {
+    captureWorkingTreeFingerprint: typeof captureWorkingTreeFingerprint;
+};
+export {};

package/dist/evaluation/gate-ground-truth.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const GateGroundTruthV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    taskId: z.ZodString;
+    candidateId: z.ZodString;
+    model: z.ZodString;
+    gate: z.ZodEnum<{
+        reviewer: "reviewer";
+        sast: "sast";
+        "test-engineer": "test-engineer";
+        mutation: "mutation";
+        quality: "quality";
+    }>;
+    repetition: z.ZodNumber;
+    source: z.ZodEnum<{
+        integration: "integration";
+        "test-impact": "test-impact";
+    }>;
+    classification: z.ZodEnum<{
+        unknown: "unknown";
+        clean: "clean";
+        infrastructure_failure: "infrastructure_failure";
+        new_regression: "new_regression";
+        pre_existing: "pre_existing";
+        flaky: "flaky";
+    }>;
+    observedAt: z.ZodISODateTime;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type GateGroundTruthV1 = z.infer<typeof GateGroundTruthV1Schema>;
+export type TestImpactGateGroundTruthInput = Omit<GateGroundTruthV1, 'v' | 'source'>;
+export declare function gateGroundTruthJoinKey(value: Pick<GateGroundTruthV1, 'runId' | 'taskId' | 'candidateId' | 'model' | 'gate' | 'repetition'>): string;
+/** Persist the exact offline join relation once; conflicting rewrites fail closed. */
+export declare function saveGateGroundTruth(directory: string, runId: string, input: GateGroundTruthV1[]): Promise<GateGroundTruthV1[]>;
+/** Supported ingestion adapter for exact-key test-impact/integration sidecars. */
+export declare function recordTestImpactGateGroundTruth(directory: string, runId: string, input: TestImpactGateGroundTruthInput[]): Promise<GateGroundTruthV1[]>;
+export type GateGroundTruthReadSummary = {
+    events: GateGroundTruthV1[];
+    malformed: number;
+};
+/** Read historical evidence line-by-line so one malformed record is unavailable, not trusted. */
+export declare function readGateGroundTruth(directory: string, runId: string): Promise<GateGroundTruthReadSummary>;