@skill-harness/core 0.17.0 → 0.19.0

package/dist/redaction.js

@@ -0,0 +1,55 @@
+/** Values longer than this are truncated rather than persisted whole. */
+export const MAX_VALUE_CHARS = 2000;
+const REDACTED = "[redacted]";
+const SECRET_KEY = /^(.*[-_])?(password|passwd|secret|token|api[-_]?key|apikey|auth|authorization|credential|private[-_]?key|access[-_]?key|session[-_]?key)([-_].*)?$/i;
+const SECRET_VALUE = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    /\bBearer\s+[A-Za-z0-9._~+/-]{16,}=*/g,
+    /\bsk-[A-Za-z0-9]{16,}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9]{16,}\b/g,
+    /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bey[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    /\b([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s@]+@/gi,
+];
+export function redactText(input, homeDir) {
+    let out = input;
+    out = out.replace(SECRET_VALUE[SECRET_VALUE.length - 1], `$1${REDACTED}@`);
+    for (const re of SECRET_VALUE.slice(0, -1))
+        out = out.replace(re, REDACTED);
+    if (homeDir && homeDir.length > 1)
+        out = out.split(homeDir).join("~");
+    return out;
+}
+export function truncate(input, max = MAX_VALUE_CHARS) {
+    if (input.length <= max)
+        return input;
+    return `${input.slice(0, max)}… [truncated ${input.length - max} chars]`;
+}
+export function redactArgs(args, homeDir, depth = 0) {
+    if (args === null || typeof args !== "object" || Array.isArray(args))
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (SECRET_KEY.test(key)) {
+            out[key] = REDACTED;
+            continue;
+        }
+        out[key] = redactValue(value, homeDir, depth);
+    }
+    return out;
+}
+function redactValue(value, homeDir, depth) {
+    if (typeof value === "string")
+        return truncate(redactText(value, homeDir));
+    if (typeof value === "number" || typeof value === "boolean" || value === null)
+        return value;
+    if (depth >= 3)
+        return "[nested]";
+    if (Array.isArray(value))
+        return value.slice(0, 20).map((v) => redactValue(v, homeDir, depth + 1));
+    if (typeof value === "object")
+        return redactArgs(value, homeDir, depth + 1);
+    return String(value);
+}
+//# sourceMappingURL=redaction.js.map

package/dist/regate.js

@@ -4,9 +4,8 @@ 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 { deserializeTrajectoryEvents, evaluateTrajectoryGates } from "./trajectory-gates.js";
 import { judgeOneRep } from "./regrade.js";
-import { readResults, writeResults, diffPath, transcriptPath, judgeRawPath, repIndexOf, findDiffFiles, findTraceFiles, findTrajectoryFiles, tracePath, trajectoryPath, effectiveThreshold, scoreContextFor, rebuildScenarioResult, mergeScenarioMetrics, deliveryStatusForObservations, } from "./results.js";
+import { readResults, writeResults, diffPath, transcriptPath, judgeRawPath, repIndexOf, findDiffFiles, findTraceFiles, tracePath, effectiveThreshold, scoreContextFor, rebuildScenarioResult, mergeScenarioMetrics, deliveryStatusForObservations, } from "./results.js";
 import { outcomesToResult } from "./reps.js";
 import { appendJournal } from "./journal.js";
 import { gatesDigest, GATES_PREFIX } from "./sources.js";
@@ -89,8 +88,7 @@ export async function regateRun(opts) {
         const s = specById.get(rec.id);
         const needles = hasNeedleGates(s ?? {});
         const traceGated = Boolean(s?.traceAssert);
-        const trajectoryGated = Boolean(s?.trajectoryAssert);
-        if (!s || (!needles && !traceGated && !trajectoryGated))
+        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 — ` +
@@ -112,16 +110,11 @@ export async function regateRun(opts) {
                 `(traces are gitignored, or capture failed) — it needs a re-run`);
             continue;
         }
-        if (trajectoryGated && !complete(findTrajectoryFiles(opts.runDir, s.id, mode), expectedSuffixes.map((rep) => trajectoryPath(opts.runDir, s.id, mode, rep)))) {
-            blocked.push(`${s.id}: assert.trajectory artifacts are incomplete for ${expectedReps} recorded rep(s) ` +
-                `(events are gitignored, or required native evidence was missing) — 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, assert.trace, or assert.trajectory"));
+            (blocked.length > 0 ? `:\n  ${blocked.join("\n  ")}` : " — no scenario declares diff_contains/diff_excludes or assert.trace"));
     }
     const changes = [];
     let judgeCalls = 0;
@@ -134,15 +127,9 @@ export async function regateRun(opts) {
         }
         const diffFiles = findDiffFiles(opts.runDir, scenario.id, mode);
         const traceFiles = findTraceFiles(opts.runDir, scenario.id, mode);
-        const eventFiles = findTrajectoryFiles(opts.runDir, scenario.id, mode);
-        // Reps come from whichever artifact this scenario actually has. A trajectory-only
-        // scenario has neither diff nor trace, so falling back only once would regate
-        // nothing and report success.
         const repKeys = diffFiles.length > 0
             ? diffFiles.map((f) => ({ rep: repIndexOf(f) ?? undefined, diffFile: f }))
-            : traceFiles.length > 0
-                ? traceFiles.map((f) => ({ rep: repIndexOf(f) ?? undefined, diffFile: undefined }))
-                : eventFiles.map((f) => ({ rep: repIndexOf(f) ?? undefined, diffFile: undefined }));
+            : 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.
@@ -192,61 +179,9 @@ export async function regateRun(opts) {
                     }
                 }
             }
-            // Adapter-neutral trajectory gate, replayed from the saved normalized
-            // event artifact. Native ledgers are deliberately not re-read here: the
-            // artifact is the immutable evidence this run actually captured.
-            let trajectoryFailure = null;
-            if (scenario.trajectoryAssert) {
-                const ep = trajectoryPath(opts.runDir, scenario.id, mode, rep);
-                const events = existsSync(ep) ? deserializeTrajectoryEvents(readFileSync(ep, "utf8")) : null;
-                // The normalized artifact contains only events that were successfully captured.
-                // Source-read/normalization failures are persisted on the original objective;
-                // dropping them here would let a partial ledger become PASS on replay.
-                const priorEvidenceErrors = (rec.objective?.assertions ?? [])
-                    .filter((result) => result.kind === "trajectory_evidence" && result.status === "ERROR");
-                if (!events) {
-                    trajectoryFailure = "objective: saved normalized events are missing, malformed, or from an unsupported version";
-                    objective = {
-                        ...(objective ?? { assertions: [] }),
-                        status: "ERROR",
-                        assertions: [...(objective?.assertions ?? []), { kind: "trajectory_evidence", status: "ERROR", detail: trajectoryFailure }],
-                    };
-                }
-                else {
-                    const g = evaluateTrajectoryGates(scenario.trajectoryAssert, events);
-                    const expectedHash = rec.objective?.rep_events_sha256?.[rep ?? 0] ?? (rec.reps === undefined ? rec.objective?.events_sha256 : undefined);
-                    const digestMismatch = expectedHash !== undefined && expectedHash !== g.events_sha256;
-                    const integrityAssertion = digestMismatch
-                        ? [{ kind: "trajectory_evidence", status: "ERROR", detail: "saved normalized events no longer match the hash recorded by the run" }]
-                        : [];
-                    const priorStatus = objective?.status ?? "PASS";
-                    const status = priorStatus === "ERROR" || g.status === "ERROR" || priorEvidenceErrors.length || digestMismatch
-                        ? "ERROR"
-                        : priorStatus === "NOT-MEASURED"
-                            ? "NOT-MEASURED"
-                            : priorStatus === "FAIL" || g.status === "FAIL"
-                                ? "FAIL"
-                                : "PASS";
-                    objective = {
-                        ...(objective ?? {}),
-                        status,
-                        trajectory_version: g.event_version,
-                        events_sha256: g.events_sha256,
-                        assertions: [...(objective?.assertions ?? []), ...priorEvidenceErrors, ...integrityAssertion, ...g.assertions],
-                    };
-                    if (g.status !== "PASS" || priorEvidenceErrors.length || digestMismatch) {
-                        const details = [
-                            ...priorEvidenceErrors.map((result) => result.detail),
-                            ...integrityAssertion.map((result) => result.detail),
-                            ...g.assertions.filter((result) => result.status === g.status && g.status !== "PASS").map((result) => result.detail),
-                        ];
-                        trajectoryFailure = `objective: ${details.join("; ")}`;
-                    }
-                }
-            }
             // Prompt delivery was observed during the subject invocation and cannot be
             // replayed by regate. Carry its objective finding while refreshing only
-            // trace/trajectory/needle assertions.
+            // trace/needle assertions.
             const retainedDelivery = rec.objective?.assertions.find(assertion => assertion.kind === "skill_delivered");
             const repObservations = prev.subject_invocations?.filter(observation => observation.scenario_id === scenario.id && observation.repetition === (rep ?? 0)) ?? [];
             const delivery = prev.schema === 3
@@ -259,7 +194,7 @@ export async function regateRun(opts) {
                 if (delivery.status !== "PASS")
                     traceFailure = `objective: ${delivery.detail}`;
             }
-            const gate = { lines: needleGate.lines, failure: needleGate.failure ?? traceFailure ?? trajectoryFailure };
+            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") : "";
             // Two sources, because the two gate kinds record their prior state

package/dist/regrade.d.ts

@@ -1,6 +1,6 @@
 import type { Spec, Scenario } from "./spec.js";
 import type { HarnessAdapter, ModelRef } from "./adapters/types.js";
-import { type Judgment, type ScenarioResult, type ResultsFile } from "./results.js";
+import { type ScenarioResult, type ResultsFile } from "./results.js";
 import { type RepOutcome } from "./reps.js";
 /**
  * Carry a run's recorded hashes forward, refreshing only the `rubric:` keys this
@@ -84,6 +84,4 @@ export interface RegradeRunOptions {
  * results.yaml, emits the `score` journal event, and returns the new
  * ResultsFile. Shared by `cmdGrade` and the pi-extension's `judge` command.
  */
-/** Preserve prior panel votes and append a full-cell grade without writing invalid one-vote history. */
-export declare function appendJudgeHistory(prior: ScenarioResult | undefined, priorJudge: ModelRef | undefined, fresh: Omit<Judgment, "ordinal">): Judgment[] | undefined;
 export declare function regradeRun(opts: RegradeRunOptions): Promise<ResultsFile>;

package/dist/regrade.js

@@ -113,22 +113,6 @@ export async function regradeScenario(opts) {
  * results.yaml, emits the `score` journal event, and returns the new
  * ResultsFile. Shared by `cmdGrade` and the pi-extension's `judge` command.
  */
-/** Preserve prior panel votes and append a full-cell grade without writing invalid one-vote history. */
-export function appendJudgeHistory(prior, priorJudge, fresh) {
-    const history = prior?.judge_history ?? prior?.adjudication?.judgments ?? (prior && priorJudge ? [{
-            ordinal: 1,
-            judge: priorJudge,
-            verdict: prior.judge_verdict ?? "JUDGE-AMBIGUOUS",
-            reason: prior.judge_reason ?? "prior grade",
-            suspect: prior.suspect ?? true,
-            criteria: prior.rep_judgments?.find(panel => panel.repetition === 0)?.judgments[0]?.criteria ?? [],
-        }] : []);
-    const next = [
-        ...history,
-        { ...fresh, criteria: fresh.criteria ?? [], ordinal: history.length + 1 },
-    ].slice(-3).map((judgment, index) => ({ ...judgment, ordinal: index + 1 }));
-    return next.length >= 2 ? next : undefined;
-}
 export async function regradeRun(opts) {
     const { runDir, spec, adapter, judge, specDir } = opts;
     const now = opts.now ?? (() => new Date().toISOString());
@@ -140,7 +124,7 @@ export async function regradeRun(opts) {
     //    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.
+    // than none.
     // 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.
@@ -209,10 +193,6 @@ export async function regradeRun(opts) {
             rr.criterion_count = scenario.checklist.length;
         rr.metrics = mergeScenarioMetrics(carry?.metrics, rr.metrics);
         rr.rep_judgments = carryRepObjectives(rr.rep_judgments, carry?.rep_judgments);
-        rr.judge_history = appendJudgeHistory(carry, prev?.judge, {
-            judge, verdict: rr.judge_verdict, reason: rr.judge_reason, suspect: rr.suspect,
-            criteria: rr.rep_judgments?.find(panel => panel.repetition === 0)?.judgments[0]?.criteria,
-        });
         // `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.

package/dist/report.d.ts

@@ -1,7 +1,7 @@
 import { type ShipBar } from "./spec.js";
 import { type ResultsFile } from "./results.js";
 import { type Lift } from "./lift.js";
-import { type AggregateMetrics } from "./comparison.js";
+import { type AggregateMetrics } from "./metrics.js";
 export interface RunColumn {
     index: number;
     label: string;
@@ -22,13 +22,6 @@ export interface RunColumn {
             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;
@@ -112,13 +105,6 @@ export declare function publicView(data: ReportData): {
                 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

@@ -4,7 +4,7 @@ import { loadSpec } from "./spec.js";
 import { readResults } from "./results.js";
 import { collectLift, liftHeadline } from "./lift.js";
 import { boundaryCells, collectStability, stabilityNote } from "./stability.js";
-import { aggregateMetrics } from "./comparison.js";
+import { aggregateMetrics } from "./metrics.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())
@@ -65,18 +65,6 @@ export function collectReport(skillDir) {
                             },
                         }
                         : {}),
-                    ...(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,5 +1,5 @@
 import type { Verdict } from "./score.js";
-import type { ScenarioResult, ObjectiveResult, Judgment, SubjectInvocationObservation } from "./results.js";
+import type { ScenarioResult, ObjectiveResult, Judgment } from "./results.js";
 import type { TraceMetrics } from "./capture-trace-types.js";
 /** One rep's outcome (subject run + judge). */
 export interface RepOutcome {
@@ -9,7 +9,6 @@ export interface RepOutcome {
     /** Present only when the scenario declared structured objective assertions. */
     objective?: ObjectiveResult;
     judgment?: Judgment;
-    subject_invocations?: SubjectInvocationObservation[];
     metrics?: {
         wall_time_ms: number;
         judge_calls: number;

package/dist/reps.js

@@ -15,11 +15,9 @@ export function aggregateObjective(outcomes) {
     const picked = present.find((o) => o.status === "ERROR") ?? present.find((o) => o.status === "NOT-MEASURED") ?? present.find((o) => o.status === "FAIL") ?? present[0];
     if (present.length === 1)
         return picked;
-    const eventHashes = present.map((objective) => objective.events_sha256);
     const traceHashes = present.map((objective) => objective.trace_sha256);
     return {
         ...picked,
-        ...(eventHashes.every((hash) => typeof hash === "string") ? { rep_events_sha256: eventHashes } : {}),
         ...(traceHashes.every((hash) => typeof hash === "string") ? { rep_trace_sha256: traceHashes } : {}),
     };
 }
@@ -69,17 +67,32 @@ export function outcomesToResult(id, outcomes, repCount, threshold) {
     const objectiveField = objective ? { objective } : {};
     const metrics = aggregateMetrics(outcomes);
     const metricsField = metrics ? { metrics } : {};
+    const usage = outcomes.flatMap((outcome, repetition) => {
+        const subject = outcome.metrics?.subject;
+        if (!subject)
+            return [];
+        const reported = (value) => value !== null && value > 0 ? value : null;
+        return [{
+                repetition,
+                inputTokens: reported(subject.input_tokens),
+                outputTokens: reported(subject.output_tokens),
+                cacheReadTokens: reported(subject.cache_read_tokens),
+                costUsd: reported(subject.cost_usd),
+                priceAsOf: subject.price_as_of,
+            }];
+    });
+    const usageField = usage.length ? { usage } : {};
     const repJudgments = outcomes.map((outcome, repetition) => ({ repetition, judgments: outcome.judgment ? [outcome.judgment] : [], recorded_verdict: outcome.verdict, ...(outcome.objective ? { objective: outcome.objective } : {}) }));
     const repJudgmentField = outcomes.some(outcome => outcome.judgment) ? { rep_judgments: repJudgments } : {};
     if (repCount === 1) {
         const o = outcomes[0];
-        return { id, judge_verdict: o.verdict, judge_reason: o.reason, suspect: o.suspect, ...metricsField, override: null, note: "", ...objectiveField, ...repJudgmentField };
+        return { id, judge_verdict: o.verdict, judge_reason: o.reason, suspect: o.suspect, ...metricsField, ...usageField, override: null, note: "", ...objectiveField, ...repJudgmentField };
     }
     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, ...metricsField, override: null, note: "", ...objectiveField, ...repJudgmentField,
+        pass_threshold: threshold, ...metricsField, ...usageField, override: null, note: "", ...objectiveField, ...repJudgmentField,
     };
 }
 function aggregateMetrics(outcomes) {
@@ -87,22 +100,32 @@ function aggregateMetrics(outcomes) {
     if (present.length === 0)
         return undefined;
     const subjects = present.map((metrics) => metrics.subject).filter((metrics) => metrics !== undefined);
+    const reportedSubjects = subjects.filter(metrics => metrics.input_tokens !== null || metrics.output_tokens !== null || metrics.cache_read_tokens !== null);
     const base = {
         wall_time_ms: present.reduce((sum, metrics) => sum + metrics.wall_time_ms, 0),
         judge_calls: present.reduce((sum, metrics) => sum + metrics.judge_calls, 0),
         judge_rejudge_calls: present.reduce((sum, metrics) => sum + metrics.judge_rejudge_calls, 0),
-        subject_metrics_reps: subjects.length,
+        subject_metrics_reps: reportedSubjects.length,
         total_reps: outcomes.length,
     };
     if (subjects.length === 0)
         return base;
+    const sumReported = (field) => {
+        const values = subjects.map(metrics => metrics[field]).filter((value) => value !== null && value > 0);
+        return values.length ? values.reduce((sum, value) => sum + value, 0) : undefined;
+    };
+    const inputTokens = sumReported("input_tokens");
+    const outputTokens = sumReported("output_tokens");
+    const cacheReadTokens = sumReported("cache_read_tokens");
+    const cacheWriteTokens = sumReported("cache_write_tokens");
+    const subjectCost = sumReported("cost_usd");
     return {
         ...base,
-        input_tokens: subjects.reduce((sum, metrics) => sum + metrics.input_tokens, 0),
-        output_tokens: subjects.reduce((sum, metrics) => sum + metrics.output_tokens, 0),
-        cache_read_tokens: subjects.reduce((sum, metrics) => sum + metrics.cache_read_tokens, 0),
-        cache_write_tokens: subjects.reduce((sum, metrics) => sum + metrics.cache_write_tokens, 0),
-        subject_cost_usd: subjects.reduce((sum, metrics) => sum + metrics.cost_usd, 0),
+        ...(inputTokens === undefined ? {} : { input_tokens: inputTokens }),
+        ...(outputTokens === undefined ? {} : { output_tokens: outputTokens }),
+        ...(cacheReadTokens === undefined ? {} : { cache_read_tokens: cacheReadTokens }),
+        ...(cacheWriteTokens === undefined ? {} : { cache_write_tokens: cacheWriteTokens }),
+        ...(subjectCost === undefined ? {} : { subject_cost_usd: subjectCost }),
         cost_source: subjects.every((metrics) => metrics.cost_source === subjects[0].cost_source)
             ? subjects[0].cost_source
             : "unreported",

package/dist/results.d.ts

@@ -3,6 +3,14 @@ import { type ScenarioVerdict } from "./score.js";
 import type { Verdict } from "./score.js";
 import type { ShipBar, Scenario } from "./spec.js";
 import type { CostSource } from "./capture-trace-types.js";
+export interface SubjectUsage {
+    repetition: number;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    costUsd: number | null;
+    priceAsOf: string | null;
+}
 export interface ScenarioMetrics {
     wall_time_ms: number;
     judge_calls: number;
@@ -56,6 +64,8 @@ export interface ScenarioResult {
     pass_threshold?: number;
     /** Cost/latency counters. Separate from verdicts: cheaper failure is still failure. */
     metrics?: ScenarioMetrics;
+    /** Per-repetition subject usage; null values mean Pi did not report that counter. */
+    usage?: SubjectUsage[];
     /**
      * Objective trace-gate evidence. ADDITIVE and optional.
      *
@@ -72,8 +82,6 @@ export interface ScenarioResult {
      * actually blocks SHIP; this field is the audit trail behind that flag.
      */
     adjudication?: AdjudicationResult;
-    /** Latest three full-cell grades; enables offline agreement reports with distinct judges. */
-    judge_history?: Judgment[];
     /** Initial and panel judge members, by repetition, sufficient to recompute the recorded verdict. */
     rep_judgments?: RepJudgmentPanel[];
 }
@@ -109,10 +117,7 @@ export interface ObjectiveResult {
     status: "PASS" | "FAIL" | "ERROR" | "NOT-MEASURED";
     trace_version?: number;
     trace_sha256?: string;
-    trajectory_version?: string;
-    events_sha256?: string;
     /** Per-repetition hashes retained when an aggregate has more than one rep. */
-    rep_events_sha256?: string[];
     rep_trace_sha256?: string[];
     assertions: {
         kind: string;
@@ -443,10 +448,6 @@ export declare function rebuildScenarioResult(fresh: ScenarioResult, prior: Scen
  * traces append without a wrapper.
  */
 export declare function tracePath(runDir: string, scenarioId: string, mode: string, rep?: number): string;
-/** Saved adapter-neutral workflow events for one scenario rep. */
-export declare function trajectoryPath(runDir: string, scenarioId: string, mode: string, rep?: number): string;
-/** A scenario's normalized-event files, sorted (plain first, then numeric rep). */
-export declare function findTrajectoryFiles(runDir: string, scenarioId: string, mode?: string): 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. */

package/dist/results.js

@@ -409,7 +409,7 @@ export function validateResults(raw) {
         const aggregateObjectiveStatus = objectiveStatuses.includes("ERROR") ? "ERROR" : objectiveStatuses.includes("NOT-MEASURED") ? "NOT-MEASURED" : objectiveStatuses.includes("FAIL") ? "FAIL" : "PASS";
         if (!scenario.objective || scenario.objective.status !== aggregateObjectiveStatus)
             throw new Error(`scenario objective diverges from per-repetition objectives for ${scenario.id}`);
-        for (const judgment of [...(scenario.judge_history ?? []), ...(scenario.adjudication?.judgments ?? [])])
+        for (const judgment of scenario.adjudication?.judgments ?? [])
             assertCriteria(judgment);
         let adjudicatedVerdict;
         if (scenario.adjudication) {
@@ -599,7 +599,7 @@ export function diffPath(runDir, scenarioId, mode, rep) {
 export function rebuildScenarioResult(fresh, prior, policy) {
     // Exhaustive destructure. Do not replace with a spread: the spread is what
     // allowed a new field to pass through unconsidered in the first place.
-    const { id, criterion_count: freshCriterionCount, judge_verdict, judge_reason, suspect, override: _freshOverride, note: _freshNote, reps, passes, clean, flakiness, pass_threshold, metrics: freshMetrics, objective: freshObjective, adjudication: freshAdjudication, judge_history: freshJudgeHistory, rep_judgments: freshRepJudgments, ...rest } = fresh;
+    const { id, criterion_count: freshCriterionCount, judge_verdict, judge_reason, suspect, override: _freshOverride, note: _freshNote, reps, passes, clean, flakiness, pass_threshold, metrics: freshMetrics, usage: freshUsage, objective: freshObjective, adjudication: freshAdjudication, rep_judgments: freshRepJudgments, ...rest } = fresh;
     const _exhaustive = rest;
     void _exhaustive;
     void _freshOverride;
@@ -652,6 +652,7 @@ export function rebuildScenarioResult(fresh, prior, policy) {
         ...(flakiness === undefined ? {} : { flakiness }),
         ...(pass_threshold === undefined ? {} : { pass_threshold }),
         ...((freshMetrics ?? prior?.metrics) ? { metrics: freshMetrics ?? prior.metrics } : {}),
+        ...((freshUsage ?? prior?.usage) ? { usage: freshUsage ?? prior.usage } : {}),
         // The author owns the verdict; a re-measurement never discards their call.
         override: prior?.override ?? null,
         note: prior?.note ?? "",
@@ -660,7 +661,6 @@ export function rebuildScenarioResult(fresh, prior, policy) {
         // existed.
         ...(objective ? { objective } : {}),
         ...(adjudication ? { adjudication } : {}),
-        ...((freshJudgeHistory ?? prior?.judge_history) ? { judge_history: freshJudgeHistory ?? prior.judge_history } : {}),
         ...((freshRepJudgments ?? prior?.rep_judgments) ? { rep_judgments: freshRepJudgments ?? prior.rep_judgments } : {}),
     };
 }
@@ -675,21 +675,6 @@ export function tracePath(runDir, scenarioId, mode, rep) {
     const base = rep === undefined ? `${scenarioId}.${mode}` : `${scenarioId}.${mode}.rep${rep}`;
     return join(runDir, `${base}.trace.jsonl`);
 }
-/** Saved adapter-neutral workflow events for one scenario rep. */
-export function trajectoryPath(runDir, scenarioId, mode, rep) {
-    const base = rep === undefined ? `${scenarioId}.${mode}` : `${scenarioId}.${mode}.rep${rep}`;
-    return join(runDir, `${base}.events.jsonl`);
-}
-/** A scenario's normalized-event files, sorted (plain first, then numeric rep). */
-export function findTrajectoryFiles(runDir, scenarioId, mode) {
-    if (!existsSync(runDir))
-        return [];
-    const esc = scenarioId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const re = mode === undefined
-        ? new RegExp(`^${esc}\\..*\\.events\\.jsonl$`)
-        : new RegExp(`^${esc}\\.${mode}(\\.rep\\d+)?\\.events\\.jsonl$`);
-    return sortByRep(readdirSync(runDir).filter((f) => re.test(f)));
-}
 /** A scenario's staged-diff files, sorted (plain first, then numeric rep). Mode-scoped when given. */
 export function findDiffFiles(runDir, scenarioId, mode) {
     if (!existsSync(runDir))
@@ -738,7 +723,6 @@ export function preserveTranscript(resultsRoot, runDir, scenarioId) {
         // override whose justification was gitignored, and left `regate` with nothing
         // to re-evaluate on the one cell a human had disputed.
         ...findTraceFiles(runDir, scenarioId),
-        ...findTrajectoryFiles(runDir, scenarioId),
     ];
     if (files.length === 0)
         return;