@skill-harness/core 0.5.0 → 0.7.0

package/dist/journal.d.ts

@@ -54,6 +54,23 @@ export type JournalEvent = {
     ok: boolean;
     detail: string;
     rep?: number;
+}
+/** Trace-gate outcome. Separate from `gate-result`, which is the seeded diff/vitest gates. */
+ | {
+    event: "objective-result";
+    ts: string;
+    id: string;
+    ok: boolean;
+    detail: string;
+    rep?: number;
+}
+/** One adjudication pass: which cells were re-judged, what it cost in CALLS, what stayed unresolved. */
+ | {
+    event: "adjudication";
+    ts: string;
+    triggered: string[];
+    judge_calls: number;
+    unresolved: string[];
 } | {
     event: "judge-verdict";
     ts: string;

package/dist/lint.d.ts

@@ -1,10 +1,25 @@
-export type LintCode = "spec" | "ship_bar" | "critical" | "fixture" | "fixture-marker" | "consistency" | "stale" | "lint-error";
+export type LintCode = "spec" | "ship_bar" | "critical" | "fixture" | "fixture-marker" | "consistency" | "stale" | "stability" | "covers" | "lint-error";
+/**
+ * How much a finding means.
+ *
+ * `error` (the default, and every code that existed through 0.5.0) fails the gate.
+ * `info` reports something a reader should know that is NOT a defect: a boundary cell
+ * is a statement about how much one run of a scenario is worth, not a broken spec, and
+ * turning it red would make "this cell needs more reps" indistinguishable from "your
+ * fixture is missing". Omitted rather than written on every finding so the shape stays
+ * backward-compatible for anything already reading this list.
+ */
+export type LintSeverity = "error" | "info";
 export interface LintFinding {
     readonly skill: string;
     readonly scenario?: string;
     readonly code: LintCode;
     readonly message: string;
+    /** Absent means `error` — only findings that must not fail CI carry this. */
+    readonly severity?: LintSeverity;
 }
+/** True when a finding fails the gate. The single place the exit-code rule lives. */
+export declare function failsGate(f: LintFinding): boolean;
 /**
  * Validate one skill's spec + fixtures statically (and results-consistency when
  * committed results exist — see the consistency block). Never throws: a bad spec

package/dist/lint.js

@@ -2,10 +2,17 @@ import { existsSync, statSync, readdirSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import yaml from "js-yaml";
 import { loadSpec, SpecError } from "./spec.js";
+import { computeCoverage } from "./instruction-coverage.js";
 import { readResults, finalizeResults, findTranscriptFiles, resultsPath, scoreContextFor } from "./results.js";
 import { currentHashFor, describeSourceKey, remedyForKey, scenarioIdForKey, effectiveFixture, SCENARIO_PREFIX, STIMULUS_PREFIX, UNREADABLE } from "./sources.js";
 import { downgradeWarning } from "./downgrade.js";
+import { collectScoredRuns } from "./trends.js";
+import { boundaryCells, stabilityFrom, stabilityNote } from "./stability.js";
 import { MARKERS, unknownMarkerDirs, suggestMarker } from "./workspace.js";
+/** True when a finding fails the gate. The single place the exit-code rule lives. */
+export function failsGate(f) {
+    return (f.severity ?? "error") === "error";
+}
 /** True if `p` exists and is a directory. Never throws (TOCTOU-safe: a race or dangling
  * symlink between the check and the stat is treated as "not a directory", not an error). */
 function isDir(p) {
@@ -134,6 +141,28 @@ export function lintSkill(skillDir) {
     // system_prompt_file must exist — an agent-file scenario silently falling back to
     // skill activation would measure the wrong artifact entirely.
     for (const s of spec.scenarios) {
+        // A `covers` reference that names a section which does not exist is a WRONG
+        // STATEMENT in the spec, not a coverage gap — so it fails the gate, while an
+        // uncovered section is only reported by `coverage --strict`. Renaming a heading
+        // is the usual cause, so the finding names the near-misses.
+        if (s.covers?.length) {
+            const report = computeCoverage({ specDir, scenarios: [s] });
+            for (const b of report.broken) {
+                const hint = b.didYouMean.length ? ` — did you mean ${b.didYouMean.map((x) => `#${x}`).join(", ")}?` : "";
+                findings.push({
+                    skill, scenario: s.id, code: "covers",
+                    message: `covers reference \`${b.raw}\` is broken (${b.reason})${hint}`,
+                });
+            }
+        }
+        // Extension paths, checked statically so a typo is a free CI failure rather
+        // than a wave that ran with no subagent tool and graded the absence.
+        for (const ext of s.extensions ?? []) {
+            const extAbs = isAbsolute(ext) ? ext : resolve(specDir, ext);
+            if (!existsSync(extAbs)) {
+                findings.push({ skill, scenario: s.id, code: "fixture", message: `env.extensions not found: ${ext}` });
+            }
+        }
         if (!s.systemPromptFile)
             continue;
         const abs = isAbsolute(s.systemPromptFile) ? s.systemPromptFile : resolve(specDir, s.systemPromptFile);
@@ -265,6 +294,29 @@ export function lintSkill(skillDir) {
             }
         }
     }
+    // Run-over-run stability — INFO, never a gate failure. Derived from committed
+    // history at zero cost, and it answers a question no single results.yaml can: a
+    // scenario can be internally unanimous in every run and still land on a different
+    // side each time. Measured in the reference corpus: two consecutive full runs, one
+    // 3/3 PASS and the next 0/3 FAIL, each `flakiness 0.00`.
+    //
+    // In lint because that is where a repo already looks, and free because it reads what
+    // is on disk. Wrapped: lintSkill must never throw, and a stability read touches every
+    // run file in the tree.
+    try {
+        for (const cell of boundaryCells(stabilityFrom(collectScoredRuns(skillDir), spec))) {
+            findings.push({
+                skill, scenario: cell.id, code: "stability", severity: "info",
+                message: `${cell.tag} mode=${cell.mode}: ${stabilityNote(cell)}`,
+            });
+        }
+    }
+    catch (e) {
+        findings.push({
+            skill, code: "stability", severity: "info",
+            message: `run-over-run stability could not be derived: ${e instanceof Error ? e.message : String(e)}`,
+        });
+    }
     return findings;
 }
 /** Model-tag dirs under tests/results (each holds timestamped run dirs). */

package/dist/regate.js

@@ -2,8 +2,10 @@ import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseVerdict, detectMisfire } from "./grade.js";
 import { evaluateNeedleGates, hasNeedleGates } from "./seeded.js";
+import { evaluateTraceGates } from "./trace-gates.js";
+import { mergeTraces, deserializeTrace } from "./execution-trace.js";
 import { judgeOneRep } from "./regrade.js";
-import { readResults, writeResults, transcriptPath, judgeRawPath, repIndexOf, findDiffFiles, effectiveThreshold, scoreContextFor, } from "./results.js";
+import { readResults, writeResults, transcriptPath, judgeRawPath, repIndexOf, findDiffFiles, findTraceFiles, tracePath, effectiveThreshold, scoreContextFor, rebuildScenarioResult, } from "./results.js";
 import { outcomesToResult } from "./reps.js";
 import { appendJournal } from "./journal.js";
 import { gatesDigest, GATES_PREFIX } from "./sources.js";
@@ -84,22 +86,32 @@ export async function regateRun(opts) {
     const targets = [];
     for (const rec of prev.scenarios) {
         const s = specById.get(rec.id);
-        if (!s || !hasNeedleGates(s))
+        const needles = hasNeedleGates(s ?? {});
+        const traceGated = Boolean(s?.traceAssert);
+        if (!s || (!needles && !traceGated))
             continue; // nothing for regate to re-decide
         if (s.assert?.vitest || s.assert?.post_test) {
             blocked.push(`${s.id}: declares ${s.assert.vitest ? "assert.vitest" : "assert.post_test"}, which needs the workspace — ` +
                 `no saved artifact can stand in for it, so this scenario needs a re-run`);
             continue;
         }
-        if (findDiffFiles(opts.runDir, s.id, mode).length === 0) {
+        if (needles && findDiffFiles(opts.runDir, s.id, mode).length === 0) {
             blocked.push(`${s.id}: no staged-diff artifact on disk (\`.diff.txt\` is gitignored — regate needs the run dir that produced it)`);
             continue;
         }
+        // A trace gate is only re-decidable from a saved trace. A run recorded before
+        // traces existed has none, and saying so is the whole point — pretending
+        // regate can answer would report a verdict derived from no evidence.
+        if (traceGated && findTraceFiles(opts.runDir, s.id, mode).length === 0) {
+            blocked.push(`${s.id}: declares assert.trace but this run saved no \`.trace.jsonl\` artifact ` +
+                `(it predates trace capture, or the trace was not persisted) — it needs a re-run`);
+            continue;
+        }
         targets.push(s);
     }
     if (targets.length === 0) {
         throw new Error(`nothing to regate in ${opts.runDir}` +
-            (blocked.length > 0 ? `:\n  ${blocked.join("\n  ")}` : " — no scenario declares diff_contains/diff_excludes"));
+            (blocked.length > 0 ? `:\n  ${blocked.join("\n  ")}` : " — no scenario declares diff_contains/diff_excludes or assert.trace"));
     }
     const changes = [];
     let judgeCalls = 0;
@@ -111,18 +123,66 @@ export async function regateRun(opts) {
             continue;
         }
         const diffFiles = findDiffFiles(opts.runDir, scenario.id, mode);
+        const traceFiles = findTraceFiles(opts.runDir, scenario.id, mode);
+        // Reps come from whichever artifact this scenario actually has. A trace-only
+        // scenario has no `.diff.txt` at all, so iterating diffs would silently
+        // regate nothing and report success.
+        const repKeys = diffFiles.length > 0
+            ? diffFiles.map((f) => ({ rep: repIndexOf(f) ?? undefined, diffFile: f }))
+            : traceFiles.map((f) => ({ rep: repIndexOf(f) ?? undefined, diffFile: undefined }));
         const outcomes = [];
         // Per scenario, not run-wide: with several regated scenarios, a global counter
         // would report every change as "re-judged" because some other scenario was.
         let judgedHere = 0;
         let gateFailedHere = false;
-        for (const file of diffFiles) {
-            const rep = repIndexOf(file) ?? undefined;
-            const diff = readFileSync(join(opts.runDir, file), "utf8");
-            const gate = evaluateNeedleGates(scenario, diff);
+        for (const { rep, diffFile } of repKeys) {
+            const diff = diffFile ? readFileSync(join(opts.runDir, diffFile), "utf8") : "";
+            const needleGate = diffFile ? evaluateNeedleGates(scenario, diff) : { lines: [], failure: null };
+            // Trace gate, re-decided from the saved trace. Free: no model, no judge.
+            let traceFailure = null;
+            let objective;
+            if (scenario.traceAssert) {
+                const tp = tracePath(opts.runDir, scenario.id, mode, rep);
+                // A PARTIAL read is refused, not graded. `deserializeTrace` returns null
+                // for a malformed line and for a version it declines, and dropping those
+                // silently graded whatever survived: a 3-turn trace with a torn middle
+                // line reported `forbid_calls: [bash] → PASS` when the lost turn was the
+                // one that called bash. The write side already refuses an incomplete
+                // stream (`pi.ts` throws on no terminal event) precisely so "called
+                // nothing" and "recorded nothing" cannot look the same; the read side
+                // has to hold the same line.
+                const lines = existsSync(tp)
+                    ? readFileSync(tp, "utf8").split("\n").filter((l) => l.trim())
+                    : [];
+                const parsed = lines.map((l) => deserializeTrace(l));
+                const usable = parsed.filter((t) => t !== null);
+                const merged = usable.length === lines.length ? mergeTraces(usable) : null;
+                if (merged === null) {
+                    traceFailure =
+                        usable.length === lines.length
+                            ? "objective: saved trace is missing or unreadable — cannot re-evaluate assert.trace"
+                            : `objective: saved trace is incomplete (${usable.length}/${lines.length} turns readable) — cannot re-evaluate assert.trace`;
+                    objective = { status: "ERROR", assertions: [] };
+                }
+                else {
+                    const g = evaluateTraceGates(scenario.traceAssert, merged);
+                    objective = { status: g.status, trace_version: merged.trace_version, trace_sha256: merged.trace_sha256, assertions: g.assertions };
+                    if (g.status === "FAIL" || g.status === "ERROR") {
+                        const bad = g.assertions.filter((x) => x.status === g.status).map((x) => x.detail);
+                        traceFailure = `objective: ${bad.join("; ")}`;
+                    }
+                }
+            }
+            const gate = { lines: needleGate.lines, failure: needleGate.failure ?? traceFailure };
             const tPath = transcriptPath(opts.runDir, scenario.id, mode, rep);
             const before = existsSync(tPath) ? readFileSync(tPath, "utf8") : "";
-            const oldGateFailed = GATE_FAILED_RE.test(before.slice(before.indexOf(TRAILER)));
+            // Two sources, because the two gate kinds record their prior state
+            // differently: a seeded needle gate leaves a trailer in the transcript, a
+            // trace gate leaves an `objective` block on the result. Reading only the
+            // trailer meant a trace gate flipping to PASS never triggered the re-judge
+            // it needs, leaving a stale FAIL verdict beside a PASS objective.
+            const oldObjectiveFailed = rec.objective?.status === "FAIL" || rec.objective?.status === "ERROR";
+            const oldGateFailed = GATE_FAILED_RE.test(before.slice(before.indexOf(TRAILER))) || oldObjectiveFailed;
             // The trailer is regenerated whatever the outcome: leaving a stale
             // `MISSING` note beside a corrected verdict would misinform the next reader
             // (and the next judge, which reads this transcript).
@@ -130,23 +190,23 @@ export async function regateRun(opts) {
                 rewriteTranscript(tPath, gate.lines);
             if (gate.failure) {
                 gateFailedHere = true;
-                outcomes.push({ verdict: "FAIL", reason: gate.failure, suspect: false });
+                outcomes.push({ verdict: "FAIL", reason: gate.failure, suspect: false, objective });
                 continue;
             }
             if (!oldGateFailed) {
                 // The judge already saw this rep. Its verdict is on disk — re-read it rather
                 // than paying to ask the same question again.
                 const saved = verdictFromSavedJudgement(opts.runDir, scenario.id, mode, rep);
-                outcomes.push(saved ?? { verdict: rec.judge_verdict, reason: rec.judge_reason, suspect: rec.suspect });
+                outcomes.push({ ...(saved ?? { verdict: rec.judge_verdict, reason: rec.judge_reason, suspect: rec.suspect }), objective });
                 continue;
             }
             // The gate blocked this rep before, so no judgement of it exists anywhere.
             const transcript = readFileSync(tPath, "utf8");
-            outcomes.push(await judgeOneRep({
-                runDir: opts.runDir, spec: opts.spec, scenario, transcript,
-                adapter: opts.adapter, judge: opts.judge, specDir: opts.specDir,
-                mode, rep, now,
-            }));
+            outcomes.push({ ...(await judgeOneRep({
+                    runDir: opts.runDir, spec: opts.spec, scenario, transcript,
+                    adapter: opts.adapter, judge: opts.judge, specDir: opts.specDir,
+                    mode, rep, now,
+                })), objective });
             judgeCalls++;
             judgedHere++;
         }
@@ -154,7 +214,10 @@ export async function regateRun(opts) {
         const next = outcomesToResult(scenario.id, outcomes, outcomes.length, threshold);
         // Overrides and their notes survive: a regate re-decides the gate, and an author
         // override is a statement about the judge, not about the needle.
-        scenarios.push({ ...next, override: rec.override, note: rec.note });
+        // `regate` re-evaluates gates from saved artifacts and asks no judge anything:
+        // `objective` is freshly recomputed above, and the recorded judge panel still
+        // describes the current judgments.
+        scenarios.push(rebuildScenarioResult(next, rec, { objective: "fresh", adjudication: "carry" }));
         const to = next.judge_verdict;
         if (to !== rec.judge_verdict) {
             changes.push({

package/dist/regrade.js

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { buildJudgePrompt, judgeInWorkspace } from "./grade.js";
-import { findTranscriptFiles, judgeRawPath, repIndexOf, readResults, writeResults, effectiveThreshold, scoreContextFor, } from "./results.js";
+import { findTranscriptFiles, judgeRawPath, repIndexOf, readResults, writeResults, effectiveThreshold, scoreContextFor, rebuildScenarioResult, } from "./results.js";
 import { outcomesToResult } from "./reps.js";
 import { appendJournal } from "./journal.js";
 import { rubricDigest, personaDigest, RUBRIC_PREFIX, PERSONA_KEY } from "./sources.js";
@@ -85,7 +85,18 @@ export async function regradeRun(opts) {
     const { runDir, spec, adapter, judge, specDir } = opts;
     const now = opts.now ?? (() => new Date().toISOString());
     const prev = existsSync(join(runDir, "results.yaml")) ? readResults(runDir) : null;
-    const overrides = new Map((prev?.scenarios ?? []).map((s) => [s.id, { override: s.override, note: s.note }]));
+    // Carried across a re-judge, per field, because the right answer differs:
+    //  - `override`/`note`  — the author's, never the judge's to discard.
+    //  - `objective`        — a re-judge does NOT re-evaluate trace gates (that is
+    //    `regate`), so the recorded evidence still describes this run. Dropping it
+    //    silently downgraded a gated scenario to "no assertions declared".
+    // `adjudication` is deliberately NOT carried: it describes the judgments this
+    // re-grade just replaced, and a stale panel beside a fresh verdict is worse
+    // than none. `grade --auto-rejudge` recomputes it.
+    // The whole prior result per id — `rebuildScenarioResult` decides, field by
+    // field, what survives. Passing a hand-picked subset here is how fields got
+    // dropped before.
+    const overrides = new Map((prev?.scenarios ?? []).map((s) => [s.id, s]));
     const mode = prev?.mode ?? "green";
     // Re-grading rewrites the WHOLE results.yaml, so re-judge exactly the
     // scenarios the run recorded (falling back to the spec for a run with no
@@ -131,7 +142,10 @@ export async function regradeRun(opts) {
             runDir, spec, scenario, adapter, judge, specDir, threshold, mode, now,
         });
         const carry = overrides.get(id);
-        scenarioResults.push({ ...rr, override: carry?.override ?? null, note: carry?.note ?? "" });
+        // `grade` re-judges the saved transcript. It does not re-evaluate trace gates
+        // (that is `regate`), so `objective` still describes this run; and it replaced
+        // the judgments a prior adjudication described, so that panel must go.
+        scenarioResults.push(rebuildScenarioResult(rr, carry, { objective: "carry", adjudication: "drop" }));
     }
     const ctx = scoreContextFor({ mode, partial: prev?.partial }, spec);
     const results = writeResults(runDir, {

package/dist/report.d.ts

@@ -14,12 +14,36 @@ export interface RunColumn {
         judge_verdict: string;
         judge_reason: string;
         suspect: boolean;
+        /** Objective trace-gate outcome, when the scenario declared `assert.trace`. */
+        objective?: {
+            status: string;
+            detail: string;
+        };
+        /** Adjudication outcome, when the cell was re-judged. */
+        adjudication?: {
+            state: string;
+            trigger: string;
+            count: number;
+            detail: string;
+        };
         reps?: number;
         passes?: number;
         clean?: number;
         flakiness?: number;
         override: string | null;
         note: string;
+        /**
+         * Run-over-run history for this cell, derived from the tag's other runs in the
+         * SAME mode. Present only for a cell that flipped (`state: "boundary"`) — a
+         * marker on every cell would bury the one signal it exists to show, and the
+         * per-cell `flakiness` beside it is a within-run number that cannot see this.
+         */
+        stability?: {
+            flips: number;
+            compared: number;
+            volatility: number | null;
+            note: string;
+        };
     }>;
     /**
      * Baseline-vs-skill lift for this model, when the tag has both a red baseline and
@@ -77,12 +101,36 @@ export declare function publicView(data: ReportData): {
             judge_verdict: string;
             judge_reason: string;
             suspect: boolean;
+            /** Objective trace-gate outcome, when the scenario declared `assert.trace`. */
+            objective?: {
+                status: string;
+                detail: string;
+            };
+            /** Adjudication outcome, when the cell was re-judged. */
+            adjudication?: {
+                state: string;
+                trigger: string;
+                count: number;
+                detail: string;
+            };
             reps?: number;
             passes?: number;
             clean?: number;
             flakiness?: number;
             override: string | null;
             note: string;
+            /**
+             * Run-over-run history for this cell, derived from the tag's other runs in the
+             * SAME mode. Present only for a cell that flipped (`state: "boundary"`) — a
+             * marker on every cell would bury the one signal it exists to show, and the
+             * per-cell `flakiness` beside it is a within-run number that cannot see this.
+             */
+            stability?: {
+                flips: number;
+                compared: number;
+                volatility: number | null;
+                note: string;
+            };
         }>;
     }[];
 };

package/dist/report.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { loadSpec } from "./spec.js";
 import { readResults } from "./results.js";
 import { collectLift, liftHeadline } from "./lift.js";
+import { boundaryCells, collectStability, stabilityNote } from "./stability.js";
 /** Most-recent run dir (by name, which is an ISO-ish slug) under a model-tag dir. */
 function latestRunDir(tagDir) {
     if (!statSync(tagDir).isDirectory())
@@ -24,6 +25,9 @@ export function collectReport(skillDir) {
     const resultsRoot = join(skillDir, "tests", "results");
     // Lift is keyed by model tag, the same key columns are built from.
     const liftByTag = new Map(collectLift(skillDir).map((l) => [l.tag, l]));
+    // Stability is keyed by tag + mode + scenario: a column shows one delivery mode, and
+    // green and force histories are never one series (placement moves verdicts).
+    const boundaryByCell = new Map(boundaryCells(collectStability(skillDir)).map((c) => [`${c.tag}\u0000${c.mode}\u0000${c.id}`, c]));
     const columns = [];
     if (existsSync(resultsRoot)) {
         const tags = readdirSync(resultsRoot)
@@ -35,9 +39,43 @@ export function collectReport(skillDir) {
             if (!runDir)
                 continue;
             const r = readResults(runDir);
+            const tagName = tagDir.split("/").pop();
             const cells = {};
             for (const s of r.scenarios) {
+                const boundary = boundaryByCell.get(`${tagName}\u0000${r.mode}\u0000${s.id}`);
                 cells[s.id] = {
+                    ...(boundary
+                        ? {
+                            stability: {
+                                flips: boundary.flips, compared: boundary.compared,
+                                volatility: boundary.volatility, note: stabilityNote(boundary),
+                            },
+                        }
+                        : {}),
+                    // Same optional-spread shape as `stability`: absent means "not declared"
+                    // / "single judge", and the UI must not render either as a clean result.
+                    ...(s.objective
+                        ? {
+                            objective: {
+                                status: s.objective.status,
+                                detail: s.objective.assertions.length
+                                    ? s.objective.assertions.map((a) => `${a.status} ${a.detail}`).join(" · ")
+                                    : "no assertion evidence recorded",
+                            },
+                        }
+                        : {}),
+                    ...(s.adjudication
+                        ? {
+                            adjudication: {
+                                state: s.adjudication.state,
+                                trigger: s.adjudication.trigger,
+                                count: s.adjudication.judgments.length,
+                                detail: s.adjudication.judgments
+                                    .map((j) => `#${j.ordinal} ${j.judge.provider}:${j.judge.model} ${j.verdict}${j.suspect ? " (misfired, not counted)" : ""}`)
+                                    .join(" · "),
+                            },
+                        }
+                        : {}),
                     judge_verdict: s.judge_verdict,
                     judge_reason: s.judge_reason,
                     suspect: s.suspect ?? false, // suspect defaults false for older results that predate the field
@@ -49,7 +87,7 @@ export function collectReport(skillDir) {
                     note: s.note,
                 };
             }
-            const tag = tagDir.split("/").pop();
+            const tag = tagName;
             // A column is the tag's LATEST run, which is not necessarily the skill-side
             // one — record a red baseline after a green run and the newest run in the tag
             // is red. The review UI recomputes lift from `cells` (so author overrides move

package/dist/reps.d.ts

@@ -1,11 +1,24 @@
 import type { Verdict } from "./score.js";
-import type { ScenarioResult } from "./results.js";
+import type { ScenarioResult, ObjectiveResult } from "./results.js";
 /** One rep's outcome (subject run + judge). */
 export interface RepOutcome {
     verdict: Verdict;
     reason: string;
     suspect: boolean;
+    /** Present only when the scenario declared `assert.trace`. */
+    objective?: ObjectiveResult;
 }
+/**
+ * Collapse per-rep objective results.
+ *
+ * Strict on purpose, and deliberately NOT the same policy as the judge's
+ * pass-threshold aggregation: an objective assertion is a statement about what
+ * the model DID, so one rep that called a forbidden tool is a real finding, not
+ * a minority draw to be voted away. ERROR dominates (missing evidence is never a
+ * pass), then FAIL, then PASS. The retained assertion detail comes from the
+ * first non-passing rep, since that is the one worth reading.
+ */
+export declare function aggregateObjective(outcomes: RepOutcome[]): ObjectiveResult | undefined;
 /** A scenario's aggregated result over N reps. */
 export interface RepAggregate {
     verdict: Verdict;

package/dist/reps.js

@@ -1,3 +1,25 @@
+/**
+ * Collapse per-rep objective results.
+ *
+ * Strict on purpose, and deliberately NOT the same policy as the judge's
+ * pass-threshold aggregation: an objective assertion is a statement about what
+ * the model DID, so one rep that called a forbidden tool is a real finding, not
+ * a minority draw to be voted away. ERROR dominates (missing evidence is never a
+ * pass), then FAIL, then PASS. The retained assertion detail comes from the
+ * first non-passing rep, since that is the one worth reading.
+ */
+export function aggregateObjective(outcomes) {
+    const present = outcomes.map((o) => o.objective).filter((o) => o !== undefined);
+    if (present.length === 0)
+        return undefined;
+    const errored = present.find((o) => o.status === "ERROR");
+    if (errored)
+        return errored;
+    const failed = present.find((o) => o.status === "FAIL");
+    if (failed)
+        return failed;
+    return present[0];
+}
 /**
  * Collapse N rep outcomes into one scenario verdict. A rep is "clean" when its
  * judge did not misfire. If fewer than half the reps are clean the scenario is
@@ -31,15 +53,19 @@ export function aggregateReps(outcomes, threshold) {
  * caller to merge.
  */
 export function outcomesToResult(id, outcomes, repCount, threshold) {
+    // Spread rather than always-set: a scenario with no trace assertions must
+    // produce a result byte-identical to one from before this field existed.
+    const objective = aggregateObjective(outcomes);
+    const objectiveField = objective ? { objective } : {};
     if (repCount === 1) {
         const o = outcomes[0];
-        return { id, judge_verdict: o.verdict, judge_reason: o.reason, suspect: o.suspect, override: null, note: "" };
+        return { id, judge_verdict: o.verdict, judge_reason: o.reason, suspect: o.suspect, override: null, note: "", ...objectiveField };
     }
     const agg = aggregateReps(outcomes, threshold);
     return {
         id, judge_verdict: agg.verdict, judge_reason: agg.reason, suspect: agg.suspect,
         reps: agg.reps, passes: agg.passes, clean: agg.clean, flakiness: agg.flakiness,
-        pass_threshold: threshold, override: null, note: "",
+        pass_threshold: threshold, override: null, note: "", ...objectiveField,
     };
 }
 //# sourceMappingURL=reps.js.map

package/dist/rescore.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { readResults, writeResults, scoreContextFor } from "./results.js";
+import { readResults, writeResults, scoreContextFor, rebuildScenarioResult } from "./results.js";
 import { appendJournal } from "./journal.js";
 import { policyDigest, POLICY_PREFIX } from "./sources.js";
 /**
@@ -65,7 +65,16 @@ export function rescoreRun(opts) {
         if (verdict !== s.judge_verdict) {
             changes.push({ id: s.id, from: s.judge_verdict, to: verdict, passes: s.passes, clean: s.clean, fromThreshold, toThreshold });
         }
-        return { ...s, judge_verdict: verdict, pass_threshold: toThreshold };
+        // Through the choke point, not a spread. This was the FIFTH rewriter of a
+        // `ScenarioResult` and the only one still using `{ ...s }` — so it inherited
+        // none of the invariants the others get, and adding `objective` and
+        // `adjudication` to the type did not fail the build here. Concretely: a cell
+        // that adjudication settled FAIL reverted to PASS when a threshold change
+        // recomputed it from rep counters that adjudication never updated.
+        //
+        // Both blocks are CARRIED: a rescore re-applies a threshold to reps that were
+        // already measured. It re-measures nothing, so it may discard nothing.
+        return rebuildScenarioResult({ ...s, judge_verdict: verdict, pass_threshold: toThreshold }, s, { objective: "carry", adjudication: "carry" });
     });
     const ctx = scoreContextFor(prev, opts.spec);
     const results = writeResults(opts.runDir, {