@vibe-agent-toolkit/agent-skills 0.2.0-rc.2 → 0.2.0-rc.4

package/dist/skill-test/baseline-delta.d.ts

@@ -0,0 +1,1575 @@
+import { z } from 'zod';
+import { type ArmEvalGrade, type BaselineArmSkew, type BaselineControlArmFailure } from './baseline-integrity.js';
+export declare const EvalDeltaSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    evalId: z.ZodString;
+    withPassed: z.ZodNumber;
+    withTotal: z.ZodNumber;
+    withoutPassed: z.ZodNumber;
+    withoutTotal: z.ZodNumber;
+    /**
+     * `withPassed − withoutPassed`, or `null` when THIS eval's two arms were graded to
+     * different depths. Signed: a negative delta means the control outscored the
+     * treatment, which is a real observed outcome and is never clamped to zero.
+     */
+    delta: z.ZodNullable<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    evalId: string;
+    withTotal: number;
+    withoutTotal: number;
+    withPassed: number;
+    withoutPassed: number;
+    delta: number | null;
+}, {
+    evalId: string;
+    withTotal: number;
+    withoutTotal: number;
+    withPassed: number;
+    withoutPassed: number;
+    delta: number | null;
+}>, {
+    evalId: string;
+    withTotal: number;
+    withoutTotal: number;
+    withPassed: number;
+    withoutPassed: number;
+    delta: number | null;
+}, {
+    evalId: string;
+    withTotal: number;
+    withoutTotal: number;
+    withPassed: number;
+    withoutPassed: number;
+    delta: number | null;
+}>, {
+    evalId: string;
+    withTotal: number;
+    withoutTotal: number;
+    withPassed: number;
+    withoutPassed: number;
+    delta: number | null;
+}, {
+    evalId: string;
+    withTotal: number;
+    withoutTotal: number;
+    withPassed: number;
+    withoutPassed: number;
+    delta: number | null;
+}>;
+export type EvalDelta = z.infer<typeof EvalDeltaSchema>;
+/**
+ * The suite the delta does NOT cover, when cost-tiered fail-fast truncated the run.
+ *
+ * `shouldGateAfterTier` stops the run the moment any WITH-arm eval in a tier does not
+ * fully pass, and it stops BOTH arms, so the arithmetic over the tiers that ran stays
+ * sound. What is not sound is reading the result as the suite's delta: a tier-0
+ * failure in an 8-eval suite printed `Baseline delta: +1 (with skill: 2/2, without
+ * skill: 1/2)`, byte-identical to a complete 2-eval suite that measured everything it
+ * declared.
+ *
+ * That is not an exotic path. `--baseline` exists to measure a skill that may not be
+ * helping, so a WITH-arm failure is the EXPECTED state of an interesting baseline run
+ * — the truncated shape is the common one, not the corner case.
+ */
+export declare const DeltaTruncationSchema: z.ZodObject<{
+    /** The (lower) tier whose gating failure stopped the run. */
+    gatedByTier: z.ZodNumber;
+    /** The lowest tier that never ran. */
+    firstSkippedTier: z.ZodNumber;
+    /** How many evals were never run on EITHER arm. */
+    totalSkipped: z.ZodNumber;
+    /** Their ids, flattened across the skipped tiers in ascending tier order. */
+    evalIds: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    gatedByTier: number;
+    firstSkippedTier: number;
+    totalSkipped: number;
+    evalIds: string[];
+}, {
+    gatedByTier: number;
+    firstSkippedTier: number;
+    totalSkipped: number;
+    evalIds: string[];
+}>;
+export type DeltaTruncation = z.infer<typeof DeltaTruncationSchema>;
+/**
+ * The run-level `baselineDelta` block, a SIBLING of `baselineIntegrity` in
+ * `baseline.json`. The two are separate on purpose: integrity says whether the
+ * comparison is trustworthy, this says what the comparison IS, and a reader who
+ * wants only the number should not have to reconstruct it from two summaries.
+ */
+export declare const BaselineDeltaSchema: z.ZodEffects<z.ZodObject<{
+    with: z.ZodEffects<z.ZodObject<{
+        passed: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        total: number;
+        passed: number;
+    }, {
+        total: number;
+        passed: number;
+    }>, {
+        total: number;
+        passed: number;
+    }, {
+        total: number;
+        passed: number;
+    }>;
+    without: z.ZodEffects<z.ZodObject<{
+        passed: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        total: number;
+        passed: number;
+    }, {
+        total: number;
+        passed: number;
+    }>, {
+        total: number;
+        passed: number;
+    }, {
+        total: number;
+        passed: number;
+    }>;
+    /**
+     * Run-level lift, or `null` when ANY eval was incomparable.
+     *
+     * Withheld for the whole run rather than computed over the comparable subset: the
+     * arm totals above include every eval, so a partial-subset delta would not be the
+     * difference between the two numbers printed beside it — which is precisely the
+     * kind of "close enough" number that gets quoted without its caveat.
+     */
+    delta: z.ZodNullable<z.ZodNumber>;
+    perEval: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        evalId: z.ZodString;
+        withPassed: z.ZodNumber;
+        withTotal: z.ZodNumber;
+        withoutPassed: z.ZodNumber;
+        withoutTotal: z.ZodNumber;
+        /**
+         * `withPassed − withoutPassed`, or `null` when THIS eval's two arms were graded to
+         * different depths. Signed: a negative delta means the control outscored the
+         * treatment, which is a real observed outcome and is never clamped to zero.
+         */
+        delta: z.ZodNullable<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }, {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }>, {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }, {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }>, {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }, {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }>, "many">;
+    /**
+     * Control-arm evals that produced no grade at all, so there was nothing to
+     * subtract for them. Carried HERE as well as on `baselineIntegrity` — it is one
+     * derivation handed to two consumers (the same arrangement as `ArmEvalGrade`
+     * feeding both the parity check and this block), never two derivations — because
+     * a reader who opens `baselineDelta` and finds `delta: null` must be able to learn
+     * WHY from the block that withheld it, without first having to know the
+     * contamination vocabulary next door.
+     */
+    controlArmFailures: z.ZodArray<z.ZodObject<{
+        evalId: z.ZodString;
+        detail: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        detail: string;
+        evalId: string;
+    }, {
+        detail: string;
+        evalId: string;
+    }>, "many">;
+    /**
+     * What the fail-fast gate cut off, or `null` when the whole declared suite ran.
+     *
+     * `null` rather than an absent key: "this delta covers everything" is a CLAIM, and
+     * the field has to be able to make it. An optional field would make a complete run
+     * and a run written before this existed indistinguishable — the same argument that
+     * makes `baselineIntegrity` unconditional.
+     */
+    truncated: z.ZodNullable<z.ZodObject<{
+        /** The (lower) tier whose gating failure stopped the run. */
+        gatedByTier: z.ZodNumber;
+        /** The lowest tier that never ran. */
+        firstSkippedTier: z.ZodNumber;
+        /** How many evals were never run on EITHER arm. */
+        totalSkipped: z.ZodNumber;
+        /** Their ids, flattened across the skipped tiers in ascending tier order. */
+        evalIds: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        gatedByTier: number;
+        firstSkippedTier: number;
+        totalSkipped: number;
+        evalIds: string[];
+    }, {
+        gatedByTier: number;
+        firstSkippedTier: number;
+        totalSkipped: number;
+        evalIds: string[];
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    with: {
+        total: number;
+        passed: number;
+    };
+    without: {
+        total: number;
+        passed: number;
+    };
+    controlArmFailures: {
+        detail: string;
+        evalId: string;
+    }[];
+    delta: number | null;
+    perEval: {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }[];
+    truncated: {
+        gatedByTier: number;
+        firstSkippedTier: number;
+        totalSkipped: number;
+        evalIds: string[];
+    } | null;
+}, {
+    with: {
+        total: number;
+        passed: number;
+    };
+    without: {
+        total: number;
+        passed: number;
+    };
+    controlArmFailures: {
+        detail: string;
+        evalId: string;
+    }[];
+    delta: number | null;
+    perEval: {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }[];
+    truncated: {
+        gatedByTier: number;
+        firstSkippedTier: number;
+        totalSkipped: number;
+        evalIds: string[];
+    } | null;
+}>, {
+    with: {
+        total: number;
+        passed: number;
+    };
+    without: {
+        total: number;
+        passed: number;
+    };
+    controlArmFailures: {
+        detail: string;
+        evalId: string;
+    }[];
+    delta: number | null;
+    perEval: {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }[];
+    truncated: {
+        gatedByTier: number;
+        firstSkippedTier: number;
+        totalSkipped: number;
+        evalIds: string[];
+    } | null;
+}, {
+    with: {
+        total: number;
+        passed: number;
+    };
+    without: {
+        total: number;
+        passed: number;
+    };
+    controlArmFailures: {
+        detail: string;
+        evalId: string;
+    }[];
+    delta: number | null;
+    perEval: {
+        evalId: string;
+        withTotal: number;
+        withoutTotal: number;
+        withPassed: number;
+        withoutPassed: number;
+        delta: number | null;
+    }[];
+    truncated: {
+        gatedByTier: number;
+        firstSkippedTier: number;
+        totalSkipped: number;
+        evalIds: string[];
+    } | null;
+}>;
+export type BaselineDelta = z.infer<typeof BaselineDeltaSchema>;
+/**
+ * `baseline.json` as a whole: a grading report (validated separately by the
+ * caller, which owns that schema) carrying vat's two extra blocks.
+ *
+ * Exists so the post-merge fail-closed gate can validate the file it just wrote.
+ * `.passthrough()` because the grading fields ride alongside and are checked by
+ * `GradingReportSchema`; the two blocks below are what THIS schema is for, and
+ * both are REQUIRED — an absent `baselineIntegrity` is precisely the "written
+ * before the check existed" state the block was made unconditional to rule out.
+ */
+export declare const BaselineArtifactSchema: z.ZodObject<{
+    baselineIntegrity: z.ZodObject<{
+        contaminated: z.ZodBoolean;
+        degraded: z.ZodArray<z.ZodObject<{
+            reason: z.ZodEnum<["transcript-unparsed", "cwd-unknown", "cwd-untracked", "transcript-malformed", "glob-unexpanded"]>;
+            detail: z.ZodString;
+            evalId: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }, {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }>, "many">;
+        comparable: z.ZodBoolean;
+        skew: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            withTotal: z.ZodNumber;
+            withoutTotal: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }>, "many">;
+        controlArmFailures: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            detail: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            evalId: string;
+        }, {
+            detail: string;
+            evalId: string;
+        }>, "many">;
+        summary: z.ZodString;
+        signals: z.ZodArray<z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>, "many">;
+        findings: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            hits: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>;
+                match: z.ZodString;
+                excerpt: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }, {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }, {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        summary: string;
+        contaminated: boolean;
+        degraded: {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }[];
+        comparable: boolean;
+        skew: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }[];
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        signals: ("harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content")[];
+        findings: {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }[];
+    }, {
+        summary: string;
+        contaminated: boolean;
+        degraded: {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }[];
+        comparable: boolean;
+        skew: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }[];
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        signals: ("harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content")[];
+        findings: {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }[];
+    }>;
+    baselineDelta: z.ZodEffects<z.ZodObject<{
+        with: z.ZodEffects<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>;
+        without: z.ZodEffects<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>;
+        /**
+         * Run-level lift, or `null` when ANY eval was incomparable.
+         *
+         * Withheld for the whole run rather than computed over the comparable subset: the
+         * arm totals above include every eval, so a partial-subset delta would not be the
+         * difference between the two numbers printed beside it — which is precisely the
+         * kind of "close enough" number that gets quoted without its caveat.
+         */
+        delta: z.ZodNullable<z.ZodNumber>;
+        perEval: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+            evalId: z.ZodString;
+            withPassed: z.ZodNumber;
+            withTotal: z.ZodNumber;
+            withoutPassed: z.ZodNumber;
+            withoutTotal: z.ZodNumber;
+            /**
+             * `withPassed − withoutPassed`, or `null` when THIS eval's two arms were graded to
+             * different depths. Signed: a negative delta means the control outscored the
+             * treatment, which is a real observed outcome and is never clamped to zero.
+             */
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, "many">;
+        /**
+         * Control-arm evals that produced no grade at all, so there was nothing to
+         * subtract for them. Carried HERE as well as on `baselineIntegrity` — it is one
+         * derivation handed to two consumers (the same arrangement as `ArmEvalGrade`
+         * feeding both the parity check and this block), never two derivations — because
+         * a reader who opens `baselineDelta` and finds `delta: null` must be able to learn
+         * WHY from the block that withheld it, without first having to know the
+         * contamination vocabulary next door.
+         */
+        controlArmFailures: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            detail: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            evalId: string;
+        }, {
+            detail: string;
+            evalId: string;
+        }>, "many">;
+        /**
+         * What the fail-fast gate cut off, or `null` when the whole declared suite ran.
+         *
+         * `null` rather than an absent key: "this delta covers everything" is a CLAIM, and
+         * the field has to be able to make it. An optional field would make a complete run
+         * and a run written before this existed indistinguishable — the same argument that
+         * makes `baselineIntegrity` unconditional.
+         */
+        truncated: z.ZodNullable<z.ZodObject<{
+            /** The (lower) tier whose gating failure stopped the run. */
+            gatedByTier: z.ZodNumber;
+            /** The lowest tier that never ran. */
+            firstSkippedTier: z.ZodNumber;
+            /** How many evals were never run on EITHER arm. */
+            totalSkipped: z.ZodNumber;
+            /** Their ids, flattened across the skipped tiers in ascending tier order. */
+            evalIds: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        }, {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }>, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    baselineIntegrity: z.ZodObject<{
+        contaminated: z.ZodBoolean;
+        degraded: z.ZodArray<z.ZodObject<{
+            reason: z.ZodEnum<["transcript-unparsed", "cwd-unknown", "cwd-untracked", "transcript-malformed", "glob-unexpanded"]>;
+            detail: z.ZodString;
+            evalId: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }, {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }>, "many">;
+        comparable: z.ZodBoolean;
+        skew: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            withTotal: z.ZodNumber;
+            withoutTotal: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }>, "many">;
+        controlArmFailures: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            detail: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            evalId: string;
+        }, {
+            detail: string;
+            evalId: string;
+        }>, "many">;
+        summary: z.ZodString;
+        signals: z.ZodArray<z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>, "many">;
+        findings: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            hits: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>;
+                match: z.ZodString;
+                excerpt: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }, {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }, {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        summary: string;
+        contaminated: boolean;
+        degraded: {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }[];
+        comparable: boolean;
+        skew: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }[];
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        signals: ("harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content")[];
+        findings: {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }[];
+    }, {
+        summary: string;
+        contaminated: boolean;
+        degraded: {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }[];
+        comparable: boolean;
+        skew: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }[];
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        signals: ("harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content")[];
+        findings: {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }[];
+    }>;
+    baselineDelta: z.ZodEffects<z.ZodObject<{
+        with: z.ZodEffects<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>;
+        without: z.ZodEffects<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>;
+        /**
+         * Run-level lift, or `null` when ANY eval was incomparable.
+         *
+         * Withheld for the whole run rather than computed over the comparable subset: the
+         * arm totals above include every eval, so a partial-subset delta would not be the
+         * difference between the two numbers printed beside it — which is precisely the
+         * kind of "close enough" number that gets quoted without its caveat.
+         */
+        delta: z.ZodNullable<z.ZodNumber>;
+        perEval: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+            evalId: z.ZodString;
+            withPassed: z.ZodNumber;
+            withTotal: z.ZodNumber;
+            withoutPassed: z.ZodNumber;
+            withoutTotal: z.ZodNumber;
+            /**
+             * `withPassed − withoutPassed`, or `null` when THIS eval's two arms were graded to
+             * different depths. Signed: a negative delta means the control outscored the
+             * treatment, which is a real observed outcome and is never clamped to zero.
+             */
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, "many">;
+        /**
+         * Control-arm evals that produced no grade at all, so there was nothing to
+         * subtract for them. Carried HERE as well as on `baselineIntegrity` — it is one
+         * derivation handed to two consumers (the same arrangement as `ArmEvalGrade`
+         * feeding both the parity check and this block), never two derivations — because
+         * a reader who opens `baselineDelta` and finds `delta: null` must be able to learn
+         * WHY from the block that withheld it, without first having to know the
+         * contamination vocabulary next door.
+         */
+        controlArmFailures: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            detail: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            evalId: string;
+        }, {
+            detail: string;
+            evalId: string;
+        }>, "many">;
+        /**
+         * What the fail-fast gate cut off, or `null` when the whole declared suite ran.
+         *
+         * `null` rather than an absent key: "this delta covers everything" is a CLAIM, and
+         * the field has to be able to make it. An optional field would make a complete run
+         * and a run written before this existed indistinguishable — the same argument that
+         * makes `baselineIntegrity` unconditional.
+         */
+        truncated: z.ZodNullable<z.ZodObject<{
+            /** The (lower) tier whose gating failure stopped the run. */
+            gatedByTier: z.ZodNumber;
+            /** The lowest tier that never ran. */
+            firstSkippedTier: z.ZodNumber;
+            /** How many evals were never run on EITHER arm. */
+            totalSkipped: z.ZodNumber;
+            /** Their ids, flattened across the skipped tiers in ascending tier order. */
+            evalIds: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        }, {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }>, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    baselineIntegrity: z.ZodObject<{
+        contaminated: z.ZodBoolean;
+        degraded: z.ZodArray<z.ZodObject<{
+            reason: z.ZodEnum<["transcript-unparsed", "cwd-unknown", "cwd-untracked", "transcript-malformed", "glob-unexpanded"]>;
+            detail: z.ZodString;
+            evalId: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }, {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }>, "many">;
+        comparable: z.ZodBoolean;
+        skew: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            withTotal: z.ZodNumber;
+            withoutTotal: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }>, "many">;
+        controlArmFailures: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            detail: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            evalId: string;
+        }, {
+            detail: string;
+            evalId: string;
+        }>, "many">;
+        summary: z.ZodString;
+        signals: z.ZodArray<z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>, "many">;
+        findings: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            hits: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>;
+                match: z.ZodString;
+                excerpt: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }, {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }, {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        summary: string;
+        contaminated: boolean;
+        degraded: {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }[];
+        comparable: boolean;
+        skew: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }[];
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        signals: ("harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content")[];
+        findings: {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }[];
+    }, {
+        summary: string;
+        contaminated: boolean;
+        degraded: {
+            detail: string;
+            reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+            evalId?: string | undefined;
+        }[];
+        comparable: boolean;
+        skew: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+        }[];
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        signals: ("harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content")[];
+        findings: {
+            evalId: string;
+            hits: {
+                match: string;
+                kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+                excerpt: string;
+            }[];
+        }[];
+    }>;
+    baselineDelta: z.ZodEffects<z.ZodObject<{
+        with: z.ZodEffects<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>;
+        without: z.ZodEffects<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>, {
+            total: number;
+            passed: number;
+        }, {
+            total: number;
+            passed: number;
+        }>;
+        /**
+         * Run-level lift, or `null` when ANY eval was incomparable.
+         *
+         * Withheld for the whole run rather than computed over the comparable subset: the
+         * arm totals above include every eval, so a partial-subset delta would not be the
+         * difference between the two numbers printed beside it — which is precisely the
+         * kind of "close enough" number that gets quoted without its caveat.
+         */
+        delta: z.ZodNullable<z.ZodNumber>;
+        perEval: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+            evalId: z.ZodString;
+            withPassed: z.ZodNumber;
+            withTotal: z.ZodNumber;
+            withoutPassed: z.ZodNumber;
+            withoutTotal: z.ZodNumber;
+            /**
+             * `withPassed − withoutPassed`, or `null` when THIS eval's two arms were graded to
+             * different depths. Signed: a negative delta means the control outscored the
+             * treatment, which is a real observed outcome and is never clamped to zero.
+             */
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }, {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }>, "many">;
+        /**
+         * Control-arm evals that produced no grade at all, so there was nothing to
+         * subtract for them. Carried HERE as well as on `baselineIntegrity` — it is one
+         * derivation handed to two consumers (the same arrangement as `ArmEvalGrade`
+         * feeding both the parity check and this block), never two derivations — because
+         * a reader who opens `baselineDelta` and finds `delta: null` must be able to learn
+         * WHY from the block that withheld it, without first having to know the
+         * contamination vocabulary next door.
+         */
+        controlArmFailures: z.ZodArray<z.ZodObject<{
+            evalId: z.ZodString;
+            detail: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            detail: string;
+            evalId: string;
+        }, {
+            detail: string;
+            evalId: string;
+        }>, "many">;
+        /**
+         * What the fail-fast gate cut off, or `null` when the whole declared suite ran.
+         *
+         * `null` rather than an absent key: "this delta covers everything" is a CLAIM, and
+         * the field has to be able to make it. An optional field would make a complete run
+         * and a run written before this existed indistinguishable — the same argument that
+         * makes `baselineIntegrity` unconditional.
+         */
+        truncated: z.ZodNullable<z.ZodObject<{
+            /** The (lower) tier whose gating failure stopped the run. */
+            gatedByTier: z.ZodNumber;
+            /** The lowest tier that never ran. */
+            firstSkippedTier: z.ZodNumber;
+            /** How many evals were never run on EITHER arm. */
+            totalSkipped: z.ZodNumber;
+            /** Their ids, flattened across the skipped tiers in ascending tier order. */
+            evalIds: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        }, {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }>, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }, {
+        with: {
+            total: number;
+            passed: number;
+        };
+        without: {
+            total: number;
+            passed: number;
+        };
+        controlArmFailures: {
+            detail: string;
+            evalId: string;
+        }[];
+        delta: number | null;
+        perEval: {
+            evalId: string;
+            withTotal: number;
+            withoutTotal: number;
+            withPassed: number;
+            withoutPassed: number;
+            delta: number | null;
+        }[];
+        truncated: {
+            gatedByTier: number;
+            firstSkippedTier: number;
+            totalSkipped: number;
+            evalIds: string[];
+        } | null;
+    }>;
+}, z.ZodTypeAny, "passthrough">>;
+/** Everything the run-level delta block is computed from. */
+export interface ComputeBaselineDeltaInput {
+    /** The treatment arm's per-eval grades. */
+    withArm: readonly ArmEvalGrade[];
+    /** The control arm's per-eval grades — evals whose control arm died are simply absent. */
+    withoutArm: readonly ArmEvalGrade[];
+    /** The SINGLE authority on which evals are incomparable. See below. */
+    skew: readonly BaselineArmSkew[];
+    /** Control-arm evals that never graded, for the block and the printed reason. */
+    controlArmFailures: readonly BaselineControlArmFailure[];
+    /** What fail-fast cut off, or `null` when the whole suite ran. */
+    truncated: DeltaTruncation | null;
+}
+/**
+ * Compute the A/B delta from the two arms' per-eval grades.
+ *
+ * `skew` is the AUTHORITY on which evals are incomparable — it is not re-derived
+ * from the counts here, and `controlArmFailures` does NOT get a second vote. Two
+ * derivations of the same judgement is how the delta block and
+ * `baselineIntegrity.skew` would end up disagreeing about one run, and a reader has
+ * no way to tell which of two contradicting blocks to believe. A dead control arm
+ * needs no second vote in any case: it leaves that eval graded on one arm only,
+ * which {@link armExpectationSkew} already reports as skew. Callers pass the output
+ * of {@link armExpectationSkew} over the SAME `ArmEvalGrade[]` values they pass here.
+ *
+ * `perEval` ordering matches {@link armExpectationSkew}: the treatment arm in its own
+ * order, then the evals only the control arm graded. An eval present on one arm only
+ * appears with the missing side reported as 0 and `delta: null`, exactly as the skew
+ * check reports it — a silently absent eval skews the run total the same way a
+ * short-graded one does, so it is surfaced rather than dropped.
+ *
+ * `truncated` does NOT withhold the delta. The tiers that ran, ran on both arms, so
+ * their subtraction is legal; what truncation changes is the SCOPE of the claim, and
+ * a scope caveat is reported (here and in the printed line), not a `null`. Spending
+ * `null` — which means "these arms cannot be subtracted" — on a run where they can be
+ * would collapse two failures with different remedies into one value.
+ *
+ * Pure.
+ */
+export declare function computeBaselineDelta(input: ComputeBaselineDeltaInput): BaselineDelta;
+/**
+ * The one line an operator actually reads about the delta.
+ *
+ * `baseline.json` holds the per-eval detail, and nobody opens it unprompted — the
+ * two rounds of integrity work before this one both ended up shipping findings that
+ * existed only inside an artifact. So this line has to be self-sufficient in BOTH
+ * states: it names each arm's passed/total (so the lift can be sanity-checked
+ * against the numbers it came from), it says what the numbers do NOT cover when the
+ * run was truncated, and when the delta is withheld it says so, says WHICH ARM broke
+ * and how, and points at the block holding the evidence.
+ *
+ * Pure, and deliberately not wired here — the caller decides where it goes.
+ */
+export declare function formatBaselineDeltaLine(delta: BaselineDelta): string;
+//# sourceMappingURL=baseline-delta.d.ts.map