@vibe-agent-toolkit/agent-skills 0.2.0-rc.1 → 0.2.0-rc.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"baseline-delta.d.ts","sourceRoot":"","sources":["../../src/skill-test/baseline-delta.ts"],"names":[],"mappings":"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"}

package/dist/skill-test/baseline-delta.js

@@ -0,0 +1,272 @@
+import { z } from 'zod';
+import { BaselineControlArmFailureSchema, BaselineIntegritySchema, } from './baseline-integrity.js';
+/**
+ * The A/B DELTA of a `--baseline` run — the thing the command actually sells.
+ *
+ * WHY THIS EXISTS. `--baseline` runs every eval twice, writes the treatment arm to
+ * `results/grading.json` and the control arm to `results/baseline.json`, and — until
+ * this module — computed no delta anywhere. The shipped docs said `--baseline`
+ * "reports the delta"; what it reported was two files and an invitation to subtract
+ * by hand. A product whose entire output is a comparison must do the comparison, or
+ * the number that gets quoted is whichever one the operator worked out in their head
+ * and wrote down without the caveats.
+ *
+ * WHY `null` IS THE POINT. Subtracting is only legal when both arms were graded
+ * against the same expectations, and {@link armExpectationSkew} is what decides that
+ * (see its docblock for how a grader emitting fewer entries on one arm produces two
+ * internally-consistent summaries with different denominators). When it is NOT legal,
+ * a number here would lie, and it lies in the most damaging direction: a
+ * short-graded control reads as "100% without the skill", i.e. "the skill did
+ * nothing". So the delta is WITHHELD rather than fudged, clamped, or normalised into
+ * a rate. `null` means "no delta exists here"; `0` means "measured, and the skill
+ * lifted nothing" — a completely different and perfectly valid finding, and the two
+ * must never collapse into one another.
+ *
+ * The withholding is per-eval as well as run-level: one incomparable eval poisons
+ * the run TOTAL (the summaries it feeds have mismatched denominators), but the
+ * evals either side of it were measured fine and keep their numbers.
+ */
+/**
+ * One arm's graded totals — `passed` of `total` expectations.
+ *
+ * The refine is the same one `GradingSummarySchema` carries next door, and it was
+ * missing here for exactly as long as this block has existed. `{passed: 9, total: 3}`
+ * for the control arm parsed clean, rendered as `without skill: 9/3`, and produced
+ * `delta: -8` — a confident negative lift out of a count that cannot happen. Both
+ * halves of `baseline.json` now reject it, so no reader has to decide which of two
+ * blocks to believe.
+ */
+const ArmTotalsSchema = z.object({
+    passed: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+}).strict().refine((s) => s.passed <= s.total, {
+    message: 'passed cannot exceed total — a count above its own denominator is a grader or merge bug',
+});
+export const EvalDeltaSchema = z.object({
+    evalId: z.string().min(1),
+    withPassed: z.number().int().nonnegative(),
+    withTotal: z.number().int().nonnegative(),
+    withoutPassed: z.number().int().nonnegative(),
+    withoutTotal: z.number().int().nonnegative(),
+    /**
+     * `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.number().int().nullable(),
+}).strict()
+    .refine((e) => e.withPassed <= e.withTotal && e.withoutPassed <= e.withoutTotal, {
+    message: 'passed cannot exceed total on either arm',
+})
+    // The ARITHMETIC, checked rather than assumed. Nothing else in the codebase
+    // asserts that the number in this field is the subtraction the field's own name
+    // claims: the schema accepted any integer, and the strongest end-to-end test that
+    // reads the artifact only ever asserted the arms. A future refactor of
+    // `evalDelta` that returned the wrong difference would have been invisible to
+    // both. `null` is exempt — it means "not subtractable", not "subtracted wrong".
+    .refine((e) => e.delta === null || e.delta === e.withPassed - e.withoutPassed, {
+    message: 'delta must equal withPassed − withoutPassed (or be null when the arms are not comparable)',
+});
+/**
+ * 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 const DeltaTruncationSchema = z.object({
+    /** The (lower) tier whose gating failure stopped the run. */
+    gatedByTier: z.number().int(),
+    /** The lowest tier that never ran. */
+    firstSkippedTier: z.number().int(),
+    /** How many evals were never run on EITHER arm. */
+    totalSkipped: z.number().int().positive(),
+    /** Their ids, flattened across the skipped tiers in ascending tier order. */
+    evalIds: z.array(z.string().min(1)),
+}).strict();
+/**
+ * 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 const BaselineDeltaSchema = z.object({
+    with: ArmTotalsSchema,
+    without: ArmTotalsSchema,
+    /**
+     * 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.number().int().nullable(),
+    perEval: z.array(EvalDeltaSchema),
+    /**
+     * 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.array(BaselineControlArmFailureSchema),
+    /**
+     * 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: DeltaTruncationSchema.nullable(),
+}).strict()
+    // Same arithmetic check as {@link EvalDeltaSchema}, at the level the operator
+    // actually quotes. `formatBaselineDeltaLine` prints the lift and the two arms
+    // side by side, so a `delta` that is not their difference is a self-contradicting
+    // sentence on stderr — and the schema was the only place that could have said so.
+    .refine((d) => d.delta === null || d.delta === d.with.passed - d.without.passed, {
+    message: 'delta must equal with.passed − without.passed (or be null when the arms are not comparable)',
+});
+/**
+ * `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 const BaselineArtifactSchema = z.object({
+    baselineIntegrity: BaselineIntegritySchema,
+    baselineDelta: BaselineDeltaSchema,
+}).passthrough();
+/** Sum one arm's per-eval grades into the totals that arm's summary reports. */
+function armTotals(arm) {
+    return arm.reduce((acc, grade) => ({ passed: acc.passed + grade.passed, total: acc.total + grade.total }), { passed: 0, total: 0 });
+}
+/** The zeroed side of an eval only one arm graded. */
+const MISSING_ARM = { passed: 0, total: 0 };
+/**
+ * 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 function computeBaselineDelta(input) {
+    const { withArm, withoutArm, skew } = input;
+    const incomparable = new Set(skew.map((s) => s.evalId));
+    const withoutById = new Map(withoutArm.map((g) => [g.evalId, g]));
+    const withIds = new Set(withArm.map((g) => g.evalId));
+    const perEval = withArm.map((graded) => evalDelta(graded, withoutById.get(graded.evalId) ?? MISSING_ARM, incomparable.has(graded.evalId)));
+    for (const graded of withoutArm) {
+        if (withIds.has(graded.evalId))
+            continue;
+        perEval.push(evalDelta({ evalId: graded.evalId, ...MISSING_ARM }, graded, incomparable.has(graded.evalId)));
+    }
+    const withTotals = armTotals(withArm);
+    const withoutTotals = armTotals(withoutArm);
+    return {
+        with: withTotals,
+        without: withoutTotals,
+        delta: skew.length > 0 ? null : withTotals.passed - withoutTotals.passed,
+        perEval,
+        controlArmFailures: [...input.controlArmFailures],
+        truncated: input.truncated,
+    };
+}
+function evalDelta(graded, without, isIncomparable) {
+    return {
+        evalId: graded.evalId,
+        withPassed: graded.passed,
+        withTotal: graded.total,
+        withoutPassed: without.passed,
+        withoutTotal: without.total,
+        delta: isIncomparable ? null : graded.passed - without.passed,
+    };
+}
+/** `+3` / `-2` / `+0` — a bare `3` is a count, a signed `+3` is a direction. */
+function signed(delta) {
+    return delta < 0 ? String(delta) : `+${delta}`;
+}
+/**
+ * The SCOPE clause: what this delta does not cover.
+ *
+ * Appended in BOTH states — a truncated run that still produced a number is the
+ * dangerous one, because `+1 (with skill: 2/2, without skill: 1/2)` is a complete,
+ * confident, quotable sentence about two of the eight evals the suite declares.
+ */
+function truncationClause(truncated) {
+    if (truncated === null)
+        return '';
+    const ids = truncated.evalIds.length === 0 ? '' : ` [${truncated.evalIds.join(', ')}]`;
+    return (` PARTIAL SUITE: fail-fast gated on tier ${truncated.gatedByTier}, so tier ` +
+        `${truncated.firstSkippedTier} and above never ran on EITHER arm — ${truncated.totalSkipped} ` +
+        `eval(s)${ids} are absent from both totals above. This is the delta over the tiers that ran, ` +
+        'not over the suite.');
+}
+/** Why the delta was withheld — the control arm dying is a different failure from the arms disagreeing. */
+function withheldClause(delta) {
+    if (delta.controlArmFailures.length > 0) {
+        const ids = delta.controlArmFailures.map((f) => f.evalId).join(', ');
+        return (`the CONTROL arm (skill withheld) produced no grade for ${delta.controlArmFailures.length} ` +
+            `eval(s) [${ids}], so there is nothing to subtract from the treatment arm. The treatment ` +
+            'arm ran and its grading.json/tool-eval.json are complete and trustworthy — only the ' +
+            'comparison is missing. See baselineIntegrity.controlArmFailures in baseline.json.');
+    }
+    const withheld = delta.perEval.filter((e) => e.delta === null).length;
+    return (`${withheld} eval(s) were graded against a different number of expectations on each arm, ` +
+        'so the two totals have different denominators and subtracting them would not be a delta. ' +
+        'See baselineIntegrity.skew in baseline.json.');
+}
+/**
+ * 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 function formatBaselineDeltaLine(delta) {
+    const arms = `with skill: ${delta.with.passed}/${delta.with.total}, without skill: ${delta.without.passed}/${delta.without.total}`;
+    const scope = truncationClause(delta.truncated);
+    if (delta.delta !== null)
+        return `Baseline delta: ${signed(delta.delta)} (${arms}).${scope}`;
+    return `Baseline delta: unavailable (${arms}) — ${withheldClause(delta)}${scope}`;
+}
+//# sourceMappingURL=baseline-delta.js.map

package/dist/skill-test/baseline-delta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline-delta.js","sourceRoot":"","sources":["../../src/skill-test/baseline-delta.ts"],"names":[],"mappings":"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"}