@skill-harness/core 0.6.0 → 0.8.0

package/dist/instruction-coverage.js

@@ -0,0 +1,253 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, dirname, relative, isAbsolute } from "node:path";
+const FENCE = /^\s{0,3}(`{3,}|~{3,})/;
+const ATX = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+const SETEXT_H1 = /^\s{0,3}=+\s*$/;
+const SETEXT_H2 = /^\s{0,3}-+\s*$/;
+/**
+ * GitHub-style anchor slug: lowercase, drop punctuation, spaces to hyphens.
+ *
+ * Matching GitHub matters because the reference an author writes
+ * (`SKILL.md#core-principle`) is the anchor they would use in a link, so it is
+ * the one they will guess.
+ */
+export function slugify(title) {
+    return title
+        .toLowerCase()
+        .replace(/[`*_~[\]()]/g, "")
+        .replace(/[^\p{L}\p{N}\s-]/gu, "")
+        .trim()
+        .replace(/\s+/g, "-");
+}
+/**
+ * Extract heading sections from Markdown.
+ *
+ * Fenced code blocks are skipped: a shell comment (`# rebuild the bundle`) inside
+ * an example is not a section, and treating it as one both invents coverage
+ * targets and shifts every subsequent section's line range — which would then
+ * mis-map git hunks to the wrong section, silently selecting the wrong tests.
+ */
+export function parseSections(markdown) {
+    const lines = markdown.split("\n");
+    const found = [];
+    const seen = new Map();
+    let fence = null;
+    // Skip YAML frontmatter. Every SKILL.md opens with it, and its closing `---`
+    // makes the line above look exactly like a Setext h2 underline — so without
+    // this, every skill gains a phantom section named after its own `description:`
+    // line, and it lands at the top where it is most likely to be "covered" by a
+    // careless whole-file reference.
+    const start = frontmatterEnd(lines);
+    const push = (title, depth, startLine) => {
+        const base = slugify(title);
+        if (base === "")
+            return; // an empty heading is not addressable
+        const n = seen.get(base) ?? 0;
+        seen.set(base, n + 1);
+        found.push({ slug: n === 0 ? base : `${base}-${n}`, title, depth, startLine });
+    };
+    for (let i = start; i < lines.length; i++) {
+        const line = lines[i];
+        const fenceMatch = FENCE.exec(line);
+        if (fenceMatch) {
+            const marker = fenceMatch[1][0];
+            if (fence === null)
+                fence = marker;
+            else if (fence === marker)
+                fence = null;
+            continue;
+        }
+        if (fence !== null)
+            continue;
+        const atx = ATX.exec(line);
+        if (atx) {
+            push(atx[2], atx[1].length, i + 1);
+            continue;
+        }
+        // Setext: the UNDERLINE marks the heading, whose text is the line above.
+        const prev = i > start ? lines[i - 1] : "";
+        if (prev.trim() !== "" && !ATX.test(prev)) {
+            if (SETEXT_H1.test(line))
+                push(prev.trim(), 1, i);
+            else if (SETEXT_H2.test(line) && /[^-\s]/.test(prev))
+                push(prev.trim(), 2, i);
+        }
+    }
+    return found.map((s, i) => ({
+        ...s,
+        endLine: i + 1 < found.length ? found[i + 1].startLine - 1 : lines.length,
+    }));
+}
+/**
+ * Index of the first line after YAML frontmatter, or 0 when there is none.
+ *
+ * Only a `---` on line 1 opens frontmatter — a `---` further down is a horizontal
+ * rule, and treating it as a delimiter would swallow the document.
+ */
+function frontmatterEnd(lines) {
+    if (lines[0]?.trim() !== "---")
+        return 0;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === "---")
+            return i + 1;
+    }
+    return 0; // unterminated: treat the whole file as content rather than losing it
+}
+/** Section containing a 1-based line, or undefined for content before the first heading. */
+export function sectionAtLine(sections, line) {
+    return sections.find((s) => line >= s.startLine && line <= s.endLine);
+}
+/** Parse `SKILL.md#core-principle` / `../../agents/plan.md` into its parts. */
+export function parseCoversRef(raw) {
+    const hash = raw.indexOf("#");
+    if (hash < 0)
+        return { raw, file: raw.trim() };
+    return { raw, file: raw.slice(0, hash).trim(), slug: raw.slice(hash + 1).trim() || undefined };
+}
+/**
+ * Build the coverage report.
+ *
+ * Free and offline — it reads Markdown and the spec, nothing else. That is
+ * deliberate: a coverage command that spends tokens would be run once.
+ */
+export function computeCoverage(opts) {
+    const fileSections = new Map();
+    const readSections = (file) => {
+        if (fileSections.has(file))
+            return fileSections.get(file);
+        const abs = isAbsolute(file) ? file : resolve(opts.specDir, file);
+        if (!existsSync(abs))
+            return null;
+        const sections = parseSections(readFileSync(abs, "utf8"));
+        fileSections.set(file, sections);
+        return sections;
+    };
+    for (const f of opts.baseFiles ?? [])
+        readSections(f);
+    const bySection = new Map();
+    const key = (file, slug) => `${file}#${slug}`;
+    const ensure = (file, section) => {
+        const k = key(file, section.slug);
+        let entry = bySection.get(k);
+        if (!entry) {
+            entry = { file, section, scenarios: [], pendingCaptures: [] };
+            bySection.set(k, entry);
+        }
+        return entry;
+    };
+    // Seed every section of every known file, so "uncovered" is a real list rather
+    // than only what someone happened to reference.
+    for (const [file, sections] of fileSections)
+        for (const s of sections)
+            ensure(file, s);
+    const broken = [];
+    const unmapped = [];
+    const attach = (id, refs, into) => {
+        for (const raw of refs) {
+            const ref = parseCoversRef(raw);
+            const sections = readSections(ref.file);
+            if (sections === null) {
+                broken.push({ scenarioId: id, raw, reason: "file-missing", didYouMean: [] });
+                continue;
+            }
+            for (const s of sections)
+                ensure(ref.file, s);
+            if (ref.slug === undefined) {
+                // A whole-file reference covers every section in it.
+                for (const s of sections)
+                    ensure(ref.file, s)[into].push(id);
+                continue;
+            }
+            const match = sections.find((s) => s.slug === ref.slug);
+            if (!match) {
+                broken.push({
+                    scenarioId: id,
+                    raw,
+                    reason: "section-missing",
+                    didYouMean: nearest(ref.slug, sections.map((s) => s.slug)),
+                });
+                continue;
+            }
+            ensure(ref.file, match)[into].push(id);
+        }
+    };
+    for (const s of opts.scenarios) {
+        if (!s.covers || s.covers.length === 0) {
+            unmapped.push(s.id);
+            continue;
+        }
+        attach(s.id, s.covers, "scenarios");
+    }
+    for (const c of opts.pendingCaptures ?? [])
+        attach(c.id, c.covers, "pendingCaptures");
+    const sections = [...bySection.values()].sort((a, b) => a.file.localeCompare(b.file) || a.section.startLine - b.section.startLine);
+    const covered = sections.filter((s) => s.scenarios.length > 0);
+    const uncovered = sections.filter((s) => s.scenarios.length === 0);
+    return {
+        sections,
+        covered,
+        uncovered,
+        broken,
+        unmapped,
+        pct: sections.length === 0 ? 0 : Math.round((covered.length / sections.length) * 100),
+    };
+}
+/**
+ * Closest existing slugs, so a broken reference names the likely rename.
+ *
+ * A renamed heading is the common cause of a broken reference, and
+ * "section-missing: core-principle" without a suggestion sends the author
+ * hunting through a file they just edited.
+ */
+function nearest(target, candidates, limit = 3) {
+    return candidates
+        .map((c) => ({ c, d: distance(target, c) }))
+        .filter(({ c, d }) => d <= Math.max(3, Math.floor(c.length / 2)))
+        .sort((a, b) => a.d - b.d)
+        .slice(0, limit)
+        .map(({ c }) => c);
+}
+function distance(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let last = prev[0];
+        prev[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = prev[j];
+            prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, last + (a[i - 1] === b[j - 1] ? 0 : 1));
+            last = tmp;
+        }
+    }
+    return prev[b.length];
+}
+/** Render the report for a terminal. `declared` wording is deliberate throughout. */
+export function formatCoverage(report, skill) {
+    const out = [];
+    out.push(`${skill}: ${report.covered.length}/${report.sections.length} sections have a declared test (${report.pct}%)`);
+    out.push("");
+    if (report.uncovered.length) {
+        out.push("  no test declares coverage of:");
+        for (const s of report.uncovered)
+            out.push(`    ${s.file}#${s.section.slug}  (${s.section.title})`);
+        out.push("");
+    }
+    if (report.broken.length) {
+        out.push("  broken references:");
+        for (const b of report.broken) {
+            const hint = b.didYouMean.length ? ` — did you mean ${b.didYouMean.map((s) => `#${s}`).join(", ")}?` : "";
+            out.push(`    ${b.scenarioId}: ${b.raw} (${b.reason})${hint}`);
+        }
+        out.push("");
+    }
+    if (report.unmapped.length) {
+        out.push(`  scenarios with no \`covers\`: ${report.unmapped.join(", ")}`);
+        out.push("");
+    }
+    out.push("  `covers` records a declared link, not proof the behaviour is tested.");
+    return out.join("\n");
+}
+/** Path of `file` relative to `specDir`, normalized for comparison with `covers`. */
+export function relativeToSpec(specDir, file) {
+    return relative(specDir, isAbsolute(file) ? file : resolve(dirname(specDir), file)).split("\\").join("/");
+}
+//# sourceMappingURL=instruction-coverage.js.map

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,4 +1,4 @@
-export type LintCode = "spec" | "ship_bar" | "critical" | "fixture" | "fixture-marker" | "consistency" | "stale" | "stability" | "lint-error";
+export type LintCode = "spec" | "ship_bar" | "critical" | "fixture" | "fixture-marker" | "consistency" | "stale" | "stability" | "covers" | "lint-error";
 /**
  * How much a finding means.
  *
@@ -27,3 +27,10 @@ export declare function failsGate(f: LintFinding): boolean;
  * report every problem across every skill.
  */
 export declare function lintSkill(skillDir: string): LintFinding[];
+/**
+ * All committed run dirs under a skill's tests/results (<tag>/<timestamp>/results.yaml).
+ * Empty if none. Never throws: unreadable/dangling entries (e.g. a broken symlink, or a
+ * TOCTOU removal between readdir and statSync) are skipped rather than propagated, so a
+ * single bad entry can't abort lintSkill's "never throws" contract.
+ */
+export declare function enumerateRunDirs(resultsRoot: string): string[];

package/dist/lint.js

@@ -2,8 +2,9 @@ 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 { currentHashFor, describeSourceKey, isSupersededKey, 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";
@@ -140,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);
@@ -224,6 +247,12 @@ export function lintSkill(skillDir) {
             const newest = full.runDir;
             const ctx = { skillDir, specDir, scenarios: spec.scenarios, judgePersona: spec.judge_persona };
             for (const [key, recorded] of Object.entries(hashes)) {
+                // A raw-bytes key whose model-visible digest this run also recorded is not the
+                // honest comparison: it reports a `description`-reword or an `allowed-tools:`
+                // line — text no graded run could observe — as a reason to re-run. The pair is
+                // recorded together and exactly one of them is compared.
+                if (isSupersededKey(key, hashes))
+                    continue;
                 const what = describeSourceKey(key);
                 const scenario = scenarioIdForKey(key, spec.scenarios);
                 // The run itself failed to hash this source, so it was never verified and
@@ -326,7 +355,7 @@ function runDirsNewestFirst(tagDir) {
  * TOCTOU removal between readdir and statSync) are skipped rather than propagated, so a
  * single bad entry can't abort lintSkill's "never throws" contract.
  */
-function enumerateRunDirs(resultsRoot) {
+export function enumerateRunDirs(resultsRoot) {
     if (!existsSync(resultsRoot))
         return [];
     const out = [];

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,6 +14,18 @@ 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;
@@ -89,6 +101,18 @@ 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;

package/dist/report.js

@@ -52,6 +52,30 @@ export function collectReport(skillDir) {
                             },
                         }
                         : {}),
+                    // 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

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;