@skill-harness/core 0.16.0 → 0.18.0

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 } : {}),
     };
 }

package/dist/results.d.ts

@@ -72,8 +72,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 +107,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 +438,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, objective: freshObjective, adjudication: freshAdjudication, rep_judgments: freshRepJudgments, ...rest } = fresh;
     const _exhaustive = rest;
     void _exhaustive;
     void _freshOverride;
@@ -660,7 +660,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 +674,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 +722,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;

package/dist/run.js

@@ -1,22 +1,21 @@
 import { mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { sourceHashes, PROMPT_NORMALIZATION_SOURCE_KEY, PROMPT_NORMALIZATION_SOURCE_DIGEST } from "./sources.js";
+import { sourceHashes } from "./sources.js";
 import { judgeResemblesSubject } from "./grade.js";
 import { NONE_ARM, seedArmDefinitions } from "./arms.js";
-import { runDirFor, transcriptPath, diffPath, tracePath, trajectoryPath, writeResults, ensureResultsGitignore, scoreContextFor, effectiveThreshold, isScoredMode, deliveryStatusForObservations, } from "./results.js";
+import { runDirFor, transcriptPath, diffPath, tracePath, writeResults, ensureResultsGitignore, scoreContextFor, effectiveThreshold, isScoredMode, } from "./results.js";
 import { appendJournal } from "./journal.js";
 import { liftHeadline } from "./lift.js";
 import { runSeeded } from "./seeded.js";
 import { serializeTrace, mergeTraces, traceSha256 } from "./execution-trace.js";
 import { evaluateTraceGates } from "./trace-gates.js";
-import { evaluateTrajectoryGates, serializeTrajectoryEvents, } from "./trajectory-gates.js";
 import { snapshotPaths, diffSnapshots, createWorkspace } from "./workspace.js";
 import { runPool } from "./scheduler.js";
 import { outcomesToResult } from "./reps.js";
 import { judgeOneRep } from "./regrade.js";
 import { runDeliveryCanary, canaryFailure } from "./canary.js";
 import { boundaryCells, stabilityNote } from "./stability.js";
-import { aggregateMetrics } from "./comparison.js";
+import { aggregateMetrics } from "./metrics.js";
 import { providerFailureFromTranscript } from "./provider-failure.js";
 /**
  * The pi-daddy arm's delivery proof, by convention: `arms.yaml` points
@@ -139,20 +138,13 @@ export async function runSkillModel(opts) {
         }
     });
     const flat = await runPool(tasks, opts.concurrency ?? 1);
-    const subjectInvocations = flat.flatMap(outcome => outcome.subject_invocations ?? []);
     const grouped = scenarios.map(() => []);
     flat.forEach((outcome, i) => grouped[owners[i]].push(outcome));
     const scenarioResults = scenarios.map((scenario, si) => {
         const threshold = scenario.critical
             ? effectiveThreshold(undefined, scenario)
             : scenario.passThreshold ?? opts.passThreshold ?? 0.5;
-        const result = outcomesToResult(scenario.id, grouped[si], repCounts[si], threshold);
-        if (adapter.observesPrompts)
-            result.criterion_count = scenario.checklist.length;
-        if (adapter.observesPrompts && !result.rep_judgments) {
-            result.rep_judgments = grouped[si].map((outcome, repetition) => ({ repetition, judgments: [], recorded_verdict: outcome.verdict, ...(outcome.objective ? { objective: outcome.objective } : {}) }));
-        }
-        return result;
+        return outcomesToResult(scenario.id, grouped[si], repCounts[si], threshold);
     });
     const ctx = scoreContextFor({ mode, partial }, spec);
     const results = writeResults(runDir, {
@@ -168,12 +160,8 @@ export async function runSkillModel(opts) {
         ...(partial ? { partial: true } : {}),
         // Only the scenarios this run actually measured: a --only run must not claim
         // coverage of scenarios it skipped.
-        source_hashes: {
-            ...sourceHashes({ skillDir, specDir: dirname(opts.specPath), scenarios, judgePersona: spec.judge_persona }),
-            ...(adapter.observesPrompts ? { [PROMPT_NORMALIZATION_SOURCE_KEY]: PROMPT_NORMALIZATION_SOURCE_DIGEST } : {}),
-        },
+        source_hashes: sourceHashes({ skillDir, specDir: dirname(opts.specPath), scenarios, judgePersona: spec.judge_persona }),
         scenarios: scenarioResults,
-        ...(adapter.observesPrompts ? { schema: 3, subject_invocations: subjectInvocations } : {}),
         ...(arm.name === NONE_ARM.name ? {} : {
             arm: {
                 name: arm.name,
@@ -240,7 +228,6 @@ async function runRep(scenario, rep, repCount, ctx) {
     // produces no diff, and writing an empty artifact there would misreport "the
     // model changed nothing" for a rep that never ran.
     let stagedDiff = null;
-    const subjectInvocations = [];
     try {
         try {
             ws = createWorkspace(scenario.workspace, { specDir: dirname(ctx.specPath), remote: scenario.remote });
@@ -254,8 +241,6 @@ async function runRep(scenario, rep, repCount, ctx) {
         }
         let noResponse = false;
         let traces = [];
-        let events = [];
-        let eventErrors = [];
         let unobservablePaths = false;
         // The pre-run state, captured AFTER `createWorkspace` has applied the
         // fixture's `_staged/` and `_uncommitted/` trees. Those land after the
@@ -286,10 +271,10 @@ async function runRep(scenario, rep, repCount, ctx) {
             // used to pass `trace: {...}` unconditionally and let `runSeeded` throw
             // ``scenario `X` declares `assert.trace`…`` at a scenario that declares no
             // such thing.
-            const needsStructuredEvidence = Boolean(scenario.traceAssert || scenario.trajectoryAssert);
+            const needsStructuredEvidence = Boolean(scenario.traceAssert);
             if (needsStructuredEvidence && !ctx.adapter.runStructured) {
                 throw new Error(`scenario \`${scenario.id}\` declares structured objective assertions, but the \`${ctx.adapter.name}\` adapter` +
-                    ` cannot produce execution traces/events — the gate would have no evidence to read.`);
+                    ` cannot produce execution traces — the gate would have no evidence to read.`);
             }
             const useStructured = (Boolean(ctx.structured) || needsStructuredEvidence) && Boolean(ctx.adapter.runStructured);
             // A blank assistant turn is a harness timeout, not model behavior: retry ONCE in a
@@ -297,7 +282,6 @@ async function runRep(scenario, rep, repCount, ctx) {
             // it happens again the verdict is ERROR — never a judged FAIL on an empty reply.
             // An adapter that THREW is the same class of event and takes the same retry.
             for (let attempt = 0; attempt < 2; attempt++) {
-                const observe = (prompt) => subjectInvocations.push({ scenario_id: scenario.id, repetition: rep, attempt, prompt });
                 if (attempt > 0) {
                     const why = adapterFailure ? `adapter failed (${adapterFailure})` : "empty response";
                     appendJournal(runDir, { event: "empty-response-retry", ts: now(), id: scenario.id, attempt, reason: why, ...repField });
@@ -337,15 +321,12 @@ async function runRep(scenario, rep, repCount, ctx) {
                             // already substituted) both must reach pi.
                             armExtensions: arm.extensions,
                             ...(armEnvFor(ws.cwd) ? { armEnv: armEnvFor(ws.cwd) } : {}),
-                            ...(ctx.adapter.observesPrompts ? { onPromptObservation: observe } : {}),
                         });
                         transcript = r.transcript;
                         gatePrefix = r.gateFailure;
                         infrastructureFailure = r.gateError;
                         stagedDiff = r.diff; // a retry replaces the aborted attempt's diff, as it should
                         traces = r.traces;
-                        events = r.events;
-                        eventErrors = r.eventErrors;
                     }
                     else {
                         const req = {
@@ -361,16 +342,12 @@ async function runRep(scenario, rep, repCount, ctx) {
                                 ...(scenario.extensions?.map((e) => resolve(dirname(ctx.specPath), e)) ?? []),
                                 ...arm.extensions,
                             ],
-                            eventSources: scenario.eventSources,
                             ...(armEnvFor(ws.cwd) ? { armEnv: armEnvFor(ws.cwd) } : {}),
-                            ...(ctx.adapter.observesPrompts ? { onPromptObservation: observe } : {}),
                         };
                         if (useStructured) {
                             const structured = await ctx.adapter.runStructured({ ...req, scenarioId: scenario.id, rep });
                             transcript = structured.transcript;
                             traces = structured.traces;
-                            events = structured.events ?? [];
-                            eventErrors = structured.eventErrors ?? [];
                             if (structured.providerFailure)
                                 infrastructureFailure = `provider failure — ${structured.providerFailure}`;
                         }
@@ -399,8 +376,6 @@ async function runRep(scenario, rep, repCount, ctx) {
                     gatePrefix = null;
                     stagedDiff = null;
                     traces = [];
-                    events = [];
-                    eventErrors = [];
                 }
                 // A provider outage is infrastructure, never a model verdict. Checked on
                 // every path: the text path carries the marker in the transcript, the
@@ -457,16 +432,6 @@ async function runRep(scenario, rep, repCount, ctx) {
                 });
             }
         }
-        // Delivery is an objective gate on every Pi subject invocation. It is derived
-        // from captured provider payload bytes, never from mode/argv supplied by a caller.
-        let deliveryObjective;
-        if (ctx.adapter.observesPrompts) {
-            const statuses = subjectInvocations.map(observation => observation.prompt.status);
-            const status = deliveryStatusForObservations(subjectInvocations);
-            deliveryObjective = { status, assertions: [{ kind: "skill_delivered", status, detail: statuses.length === 0 ? "no model-visible prompt observation was retained" : `${statuses.length} provider request(s): ${statuses.join(", ")}` }] };
-            if (status !== "PASS")
-                gatePrefix = `objective: skill_delivered ${status.toLowerCase()} — ${deliveryObjective.assertions[0].detail}`;
-        }
         // Objective evidence is persisted for every rep, pass or fail — a failing gate
         // is exactly when someone wants to read what the model actually did.
         // `!adapterFailure`: a rep whose adapter threw never ran, so there is nothing
@@ -474,12 +439,11 @@ async function runRep(scenario, rep, repCount, ctx) {
         // which is the symptom — it names the missing artifact instead of the crash or
         // timeout that caused it, and it is that text, not the real reason, that would
         // reach the results record. The verdict is ERROR either way.
-        let objective = deliveryObjective;
-        if ((scenario.traceAssert || scenario.trajectoryAssert) && !adapterFailure) {
+        let objective;
+        if (scenario.traceAssert && !adapterFailure) {
             const assertionResults = [];
             let status = "PASS";
             let traceMeta = {};
-            let trajectoryMeta = {};
             if (scenario.traceAssert) {
                 if (traces.length > 0) {
                     writeFileSync(tracePath(runDir, scenario.id, mode, repSuffix), traces.map(serializeTrace).join(""), "utf8");
@@ -500,32 +464,7 @@ async function runRep(scenario, rep, repCount, ctx) {
                     traceMeta = { trace_version: merged.trace_version, trace_sha256: merged.trace_sha256 };
                 }
             }
-            if (scenario.trajectoryAssert) {
-                if (events.length > 0) {
-                    writeFileSync(trajectoryPath(runDir, scenario.id, mode, repSuffix), serializeTrajectoryEvents(events), "utf8");
-                }
-                if (eventErrors.length > 0) {
-                    status = "ERROR";
-                    assertionResults.push(...eventErrors.map((detail) => ({ kind: "trajectory_evidence", status: "ERROR", detail })));
-                }
-                else if (events.length === 0) {
-                    status = "ERROR";
-                    assertionResults.push({ kind: "trajectory_evidence", status: "ERROR", detail: "no normalized workflow events were produced" });
-                }
-                else {
-                    const gate = evaluateTrajectoryGates(scenario.trajectoryAssert, events);
-                    if (gate.status === "ERROR" || (gate.status === "FAIL" && status === "PASS"))
-                        status = gate.status;
-                    assertionResults.push(...gate.assertions);
-                    trajectoryMeta = { trajectory_version: gate.event_version, events_sha256: gate.events_sha256 };
-                }
-            }
-            if (deliveryObjective) {
-                if (deliveryObjective.status === "ERROR" || (deliveryObjective.status === "NOT-MEASURED" && status !== "ERROR") || (deliveryObjective.status === "FAIL" && status === "PASS"))
-                    status = deliveryObjective.status;
-                assertionResults.unshift(...deliveryObjective.assertions);
-            }
-            objective = { status, ...traceMeta, ...trajectoryMeta, assertions: assertionResults };
+            objective = { status, ...traceMeta, assertions: assertionResults };
             if (status !== "PASS") {
                 const details = assertionResults.filter((result) => result.status === status).map((result) => result.detail);
                 gatePrefix = `objective: ${details.join("; ") || "structured evidence could not be evaluated"}`;
@@ -580,7 +519,7 @@ async function runRep(scenario, rep, repCount, ctx) {
         log(`  → ${scenario.id}${repCount > 1 ? `#${rep}` : ""} ${verdict}${reason ? `: ${reason}` : ""}${suspect ? "  ⚠ suspect" : ""}`);
         const subject = mergeTraces(traces)?.metrics;
         return {
-            verdict, reason, suspect, objective, judgment, subject_invocations: subjectInvocations,
+            verdict, reason, suspect, objective, judgment,
             metrics: {
                 wall_time_ms: Math.max(0, Math.round(performance.now() - startedAt)),
                 judge_calls: judgeCalls,

package/dist/seeded.d.ts

@@ -1,7 +1,6 @@
 import type { Scenario } from "./spec.js";
 import type { ExecutionTraceV1 } from "./capture-trace-types.js";
-import type { TrajectoryEventV1 } from "./trajectory-gates.js";
-import type { HarnessAdapter, ModelRef, RunMode, PromptProvenance } from "./adapters/types.js";
+import type { HarnessAdapter, ModelRef, RunMode } from "./adapters/types.js";
 import { type ExecResult } from "./util/exec.js";
 interface SeededOpts {
     skillDir: string;
@@ -37,7 +36,6 @@ interface SeededOpts {
     armExtensions?: string[];
     /** The arm's env for the subject process; `<run-dir>` already substituted by the caller. */
     armEnv?: Record<string, string>;
-    onPromptObservation?: (observation: PromptProvenance) => void;
 }
 /**
  * Result of one vitest invocation — deliberately `ExecResult`, not a narrower
@@ -58,10 +56,6 @@ export interface SeededOutcome {
     diff: string;
     /** One per turn; empty unless structured execution was requested. */
     traces: ExecutionTraceV1[];
-    /** Adapter-neutral workflow/tool events for assert.trajectory. */
-    events: TrajectoryEventV1[];
-    /** Required native sources that could not be read or normalized. */
-    eventErrors: string[];
 }
 /**
  * The added/removed lines of a unified diff — what the model actually *changed*,

package/dist/seeded.js

@@ -173,17 +173,13 @@ export async function runSeeded(scenario, opts) {
             ...(scenario.extensions?.map((e) => resolve(opts.specDir, e)) ?? []),
             ...(opts.armExtensions ?? []),
         ],
-        eventSources: scenario.eventSources,
         ...(opts.armEnv ? { armEnv: opts.armEnv } : {}),
-        ...(opts.onPromptObservation ? { onPromptObservation: opts.onPromptObservation } : {}),
     };
     // A trace-gated seeded scenario runs through the structured path so the tool
     // calls are recorded; everything downstream (gates, diff, transcript) is
     // identical, because the rebuilt transcript is what print mode would have
     // emitted anyway.
     let traces = [];
-    let events = [];
-    let eventErrors = [];
     let harnessOut;
     if (opts.trace) {
         if (!opts.adapter.runStructured) {
@@ -197,8 +193,6 @@ export async function runSeeded(scenario, opts) {
         });
         harnessOut = structured.transcript;
         traces = structured.traces;
-        events = structured.events ?? [];
-        eventErrors = structured.eventErrors ?? [];
     }
     else {
         harnessOut = await opts.adapter.run(req);
@@ -227,7 +221,7 @@ export async function runSeeded(scenario, opts) {
         parts.push(`  staged diff: ERROR (${msg})`);
         gateFailure = msg;
         gateError = msg;
-        return finish(parts, gateFailure, gateError, diff, traces, events, eventErrors);
+        return finish(parts, gateFailure, gateError, diff, traces);
     }
     // BOTH needle gates read the changed lines only, never context. A unified diff
     // carries three lines of context per hunk, so an untouched symbol near the edit
@@ -301,7 +295,7 @@ export async function runSeeded(scenario, opts) {
                 if (!gateFailure)
                     gateFailure = msg;
                 gateError = msg;
-                return finish(parts, gateFailure, gateError, diff, traces, events, eventErrors);
+                return finish(parts, gateFailure, gateError, diff, traces);
             }
             const v = await runVitest([POST_TEST_BASE], repo);
             const out = `${v.stdout}\n${v.stderr}`;
@@ -358,7 +352,7 @@ export async function runSeeded(scenario, opts) {
                 gateError = problem;
         }
     }
-    return finish(parts, gateFailure, gateError, diff, traces, events, eventErrors);
+    return finish(parts, gateFailure, gateError, diff, traces);
 }
 function git(cwd, args) {
     return exec("git", args, { cwd, timeoutMs: 30_000 });
@@ -392,13 +386,13 @@ function bothStreams(v) {
     return o || e;
 }
 /** Append the staged diff and return the outcome. Every exit path goes through here, so the judge always sees the same sections in the same order. */
-function finish(parts, gateFailure, gateError, diff, traces = [], events = [], eventErrors = []) {
+function finish(parts, gateFailure, gateError, diff, traces = []) {
     // The code itself, last — the gates above only prove that keywords appeared.
     // Without this section a seeded checklist item about what the code *does* is
     // graded from the model's own description of its work.
     parts.push("", "=== STAGED DIFF ===");
     parts.push(diff.trim() === "" ? "  (empty — the model left no staged changes)" : capDiff(diff));
-    return { transcript: parts.join("\n"), gateFailure, gateError, diff, traces, events, eventErrors };
+    return { transcript: parts.join("\n"), gateFailure, gateError, diff, traces };
 }
 /**
  * Parse vitest's `Tests  N passed | M skipped (T)` summary line.

package/dist/sources.js

@@ -170,13 +170,13 @@ function walk(dir, prefix = "") {
  * transcripts are actually invalid.
  */
 function facets(s) {
-    const { id, title, critical, mode, turns, checklist, fixture, assert, traceAssert, trajectoryAssert, workspace, remote, systemPromptFile, extensions, eventSources, reps, passThreshold, covers: _coversIsMetadata, ...restScenario } = s;
+    const { id, title, critical, mode, turns, checklist, fixture, assert, traceAssert, workspace, remote, systemPromptFile, extensions, reps, passThreshold, covers: _coversIsMetadata, ...restScenario } = s;
     const _scenarioExhaustive = restScenario;
     void _scenarioExhaustive;
     // `covers` is destructured into a discard on purpose, and this comment is the
     // decision the guard demanded: it belongs to NO digest. It records which
-    // instruction sections a scenario is declared to exercise, which changes what
-    // `--affected` selects next time — not what any past run measured. Bucketing it
+    // instruction sections a scenario is declared to exercise; it does not change
+    // what any past run measured. Bucketing it
     // anywhere would charge a re-run (or at best a re-score) for editing a label,
     // which is the exact trap the facet split was built to remove.
     void _coversIsMetadata;
@@ -187,7 +187,7 @@ function facets(s) {
     // already saved, so `regate` can re-answer it without re-running the subject model.
     // Note the asymmetry with `env.extensions` in Phase 3, which IS stimulus — one
     // changes what gets executed, the other only what we conclude from it.
-    const hasGates = diff_contains !== undefined || diff_excludes !== undefined || traceAssert !== undefined || trajectoryAssert !== undefined;
+    const hasGates = diff_contains !== undefined || diff_excludes !== undefined || traceAssert !== undefined;
     return {
         // `vitest` and the `post_test` PATH are stimulus, not gates: both change what the
         // run executes in the workspace, and neither can be re-evaluated from a saved
@@ -206,10 +206,6 @@ function facets(s) {
             id, mode, turns, workspace, remote, systemPromptFile ?? null,
             fixture ?? null, vitest ?? null, post_test ?? null,
             ...(extensions ? [extensions] : []),
-            // Event-source paths choose which native ledgers are captured. A saved
-            // normalized artifact cannot answer for a source that was never collected,
-            // so changing this is stimulus and needs a re-run.
-            ...(eventSources ? [eventSources] : []),
         ]),
         rubric: JSON.stringify([id, title, checklist]),
         policy: JSON.stringify([id, critical, reps ?? null, passThreshold ?? null]),
@@ -219,7 +215,6 @@ function facets(s) {
             ? JSON.stringify([
                 id, diff_contains ?? null, diff_excludes ?? null,
                 ...(traceAssert ? [traceAssert] : []),
-                ...(trajectoryAssert ? [trajectoryAssert] : []),
             ])
             : null,
     };

package/dist/spec.d.ts

@@ -1,6 +1,5 @@
 import type { WorkspaceKind } from "./workspace.js";
 import { type TraceAssert } from "./trace-gates.js";
-import { type TrajectoryAssert } from "./trajectory-gates.js";
 export type ScenarioMode = "inline" | "seeded";
 export interface SeededAssert {
     vitest?: boolean;
@@ -21,14 +20,6 @@ export interface SeededAssert {
      */
     post_test?: string;
 }
-export interface TrajectoryEventSource {
-    /** Native format adapter registered by the harness adapter. */
-    adapter: "normalized-v1" | "principal-assurance-v1" | "pi-daddy-v1" | "pi-daddy-ledger-v3";
-    /** Workspace-relative file/glob. Never an absolute path or traversal. */
-    path: string;
-    /** Missing evidence is an error by default; false is for optional supplemental ledgers. */
-    required: boolean;
-}
 export interface Scenario {
     id: string;
     title: string;
@@ -46,10 +37,6 @@ export interface Scenario {
      * Declaring it opts the scenario into structured (`--mode json`) execution.
      */
     traceAssert?: TraceAssert;
-    /** Objective assertions over adapter-neutral, versioned workflow events. */
-    trajectoryAssert?: TrajectoryAssert;
-    /** Native event/ledger files the harness normalizes after execution. */
-    eventSources?: TrajectoryEventSource[];
     workspace: WorkspaceKind;
     remote: boolean;
     systemPromptFile?: string;