@skill-harness/core 0.6.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,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.
  *

package/dist/lint.js

@@ -2,6 +2,7 @@ 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";
@@ -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);

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;

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, {

package/dist/results.d.ts

@@ -14,6 +14,56 @@ export interface ScenarioResult {
     clean?: number;
     flakiness?: number;
     pass_threshold?: number;
+    /**
+     * Objective trace-gate evidence. ADDITIVE and optional.
+     *
+     * Absent means "the scenario declared no trace assertions" — NOT an objective
+     * pass. Anything reading this must treat the two as different; collapsing them
+     * would silently upgrade every legacy result to "objectively verified".
+     */
+    objective?: ObjectiveResult;
+    /**
+     * Confidence-aware adjudication. ADDITIVE and optional.
+     *
+     * Absent means historical single-judge behavior — NOT that judges agreed. An
+     * unresolved adjudication additionally sets `suspect: true`, which is what
+     * actually blocks SHIP; this field is the audit trail behind that flag.
+     */
+    adjudication?: AdjudicationResult;
+}
+/** One judge's answer for a cell, kept verbatim however the collapse turned out. */
+export interface Judgment {
+    /** 1-based: judgment 1 is the first-wave judge, 2 the secondary, 3 the tie-break. */
+    ordinal: number;
+    judge: {
+        provider: string;
+        model: string;
+    };
+    verdict: Verdict;
+    reason: string;
+    /** The judge misfired — recorded, never counted as a clean vote. */
+    suspect: boolean;
+}
+export interface AdjudicationResult {
+    state: "confirmed" | "tie_broken" | "unresolved";
+    /** Why the cell was re-judged. */
+    trigger: "ambiguous" | "contradictory" | "non_unanimous" | "ship_deciding";
+    /** Every judgment, in order. Never pruned — an author resolving this needs all of them. */
+    judgments: Judgment[];
+    /** The collapsed answer. Absent when unresolved. */
+    verdict?: "PASS" | "FAIL";
+}
+/** Objective gate outcome for one scenario cell. */
+export interface ObjectiveResult {
+    /** ERROR means the evidence was missing or malformed — never a pass. */
+    status: "PASS" | "FAIL" | "ERROR";
+    trace_version?: number;
+    trace_sha256?: string;
+    assertions: {
+        kind: string;
+        status: "PASS" | "FAIL" | "ERROR";
+        detail: string;
+    }[];
 }
 export interface GradeSummary {
     passed: number;
@@ -56,16 +106,23 @@ export interface ResultsFile {
     harness_cli_version?: string;
     /**
      * `pass` when this run proved, before spending the wave, that the skill body was
-     * reachable in the model's context (see canary.ts). Absent means the probe was
-     * not asked for — never that it failed, because a failed canary aborts the run
-     * and no results.yaml is written.
+     * reachable in the model's context (see canary.ts). `skipped` when the probe was
+     * asked for but could not be performed — SKILL.md has no `## ` heading to quote
+     * back, so no reply could prove anything. Absent means the probe was not asked
+     * for — never that it failed, because a failed canary aborts the run and no
+     * results.yaml is written.
+     *
+     * `skipped` exists because absent and skipped were the same value: a user who
+     * passed `--canary` precisely because pi ≥ 0.83.0 delivery is unreliable got a
+     * silently degraded probe, a fully billed wave, and a committed results.yaml
+     * byte-identical to a run where delivery was never checked at all.
      *
      * Only green runs can carry it: red delivers nothing by design and force delivers
      * through the system prompt. It is provenance for the *validity* of a green run,
      * which is why it lives here rather than only in the journal — `journal.jsonl` is
      * gitignored, and this claim has to survive a commit.
      */
-    delivery_canary?: "pass";
+    delivery_canary?: "pass" | "skipped";
     skill: string;
     harness: string;
     model: string;
@@ -152,12 +209,35 @@ export declare function runDirFor(skillDir: string, harness: string, model: Mode
 export declare function transcriptPath(runDir: string, scenarioId: string, mode: string, rep?: number): string;
 export declare function reportPath(runDir: string): string;
 export declare function resultsPath(runDir: string): string;
-/** The verdict that counts: author override when present, else the judge's. */
+/**
+ * The verdict that counts: author override when present, else the objective
+ * gate, else the judge's.
+ *
+ * **The objective gate outranks the judge.** `assert.trace` is a mechanical
+ * statement about what the model DID — it called `write`, it touched `.env`.
+ * The judge is an LLM reading prose. When they disagree, the measurement wins.
+ *
+ * This is the only place that ordering is enforced, and it has to be here.
+ * `objective` used to reach the ship decision solely through `gatePrefix` in
+ * `run.ts`, which forces a single rep's verdict — so every path that recomputed
+ * a verdict afterwards silently dropped the gate while keeping the `objective`
+ * block that claimed it was enforced. Three of them did: `--reps N` out-voted an
+ * objective FAIL 2-to-1 (100%, grade A, SHIP, on a CRITICAL scenario that called
+ * a forbidden tool), `regrade` re-judged from a transcript the tool calls are
+ * absent from, and `regate` recomputed it. `reps.ts` already states the policy —
+ * "one rep that called a forbidden tool is a real finding, not a minority draw
+ * to be voted away" — and nothing enforced it.
+ *
+ * An author override still wins, exactly as it does over `suspect`. Overriding a
+ * deterministic assertion is a deliberate, recorded human act — and the failure
+ * this guards against was never a human deciding, it was nobody deciding.
+ */
 export declare function effectiveVerdicts(scenarios: ScenarioResult[]): ScenarioVerdict[];
 /**
  * The ONLY place effective_grade is computed. Every writer goes through here,
  * so a persisted grade can never disagree with verdicts + overrides.
- * ctx is null for unscored (red/force) runs.
+ * ctx is null for unscored runs — `red` only, since 0.5.0: `force` is a real
+ * deployment and is scored (see SCORED_MODES directly above).
  */
 export declare function finalizeResults(draft: ResultsDraft, ctx: ScoreContext | null): ResultsFile;
 /** Finalize + persist results.yaml (creating the run dir). Returns what was written. */
@@ -207,8 +287,50 @@ export declare function findJudgeRawFiles(runDir: string, scenarioId: string, mo
  * generated evidence, ignored like transcripts, not committed like results.yaml.
  */
 export declare function diffPath(runDir: string, scenarioId: string, mode: string, rep?: number): string;
+/**
+ * What happens to one piece of recorded evidence when a command rebuilds a result.
+ *
+ *  - `carry` — the command did not re-measure this, so the prior value still
+ *    describes the run and must survive.
+ *  - `fresh` — the command re-measured it; take the new value.
+ *  - `drop`  — the command invalidated it; a stale value would misinform.
+ */
+export type EvidencePolicy = "carry" | "fresh" | "drop";
+export interface RebuildPolicy {
+    objective: EvidencePolicy;
+    adjudication: EvidencePolicy;
+}
+/**
+ * Rebuild a `ScenarioResult` after a command re-measured part of it.
+ *
+ * **The single choke point for every rewriter**, and exhaustive by construction:
+ * every field is destructured below, so adding one to `ScenarioResult` fails the
+ * build HERE until someone decides whether it is carried, taken fresh, or
+ * dropped. That guard is the whole point of the function.
+ *
+ * It exists because the ad-hoc version — `{ ...fresh, override: prior.override,
+ * note: prior.note }`, written independently in three places — silently dropped
+ * `objective` from `grade` and `adjudication` from `regate`. Both failures ran in
+ * the dangerous direction: a trace-gated scenario re-read as "no assertions
+ * declared", and an unresolved judge disagreement as a settled verdict. 1,036
+ * tests passed through it; a real smoke run caught it.
+ *
+ * The author's `override` and `note` are always carried and are not policy —
+ * no command re-measures a human's judgement.
+ */
+export declare function rebuildScenarioResult(fresh: ScenarioResult, prior: ScenarioResult | undefined, policy: RebuildPolicy): ScenarioResult;
+/**
+ * Where a rep's execution trace is saved: `<id>.<mode>[.rep<k>].trace.jsonl`.
+ *
+ * `.jsonl` rather than `.txt` so it is distinguishable at a glance from a
+ * transcript, and one JSON object per line so a multi-turn scenario's per-turn
+ * traces append without a wrapper.
+ */
+export declare function tracePath(runDir: string, scenarioId: string, mode: string, rep?: number): string;
 /** A scenario's staged-diff files, sorted (plain first, then numeric rep). Mode-scoped when given. */
 export declare function findDiffFiles(runDir: string, scenarioId: string, mode?: string): string[];
+/** A scenario's execution-trace files, sorted (plain first, then numeric rep). Mode-scoped when given. */
+export declare function findTraceFiles(runDir: string, scenarioId: string, mode?: string): string[];
 /** A single representative transcript file for a scenario in a run dir. Null if none. */
 export declare function findTranscriptFile(runDir: string, scenarioId: string): string | null;
 /**