@skill-harness/core 0.17.0 → 0.19.0

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,18 +271,17 @@ 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);
+            const useStructured = (Boolean(ctx.structured) || needsStructuredEvidence || Boolean(ctx.adapter.preferStructured)) && Boolean(ctx.adapter.runStructured);
             // A blank assistant turn is a harness timeout, not model behavior: retry ONCE in a
             // fresh workspace (the first attempt may have half-mutated a seeded repo), and if
             // 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,
@@ -642,7 +581,9 @@ export function formatScorecard(summary, lift, stability) {
                     ? " · WARNING: subject tokens were used but the provider reported $0 cost"
                     : metrics.subject_cost_usd === null
                         ? " · subject cost unavailable"
-                        : ` · $${metrics.subject_cost_usd.toFixed(6)} provider-reported`;
+                        : metrics.cost_source === "price-table"
+                            ? ` · $${metrics.subject_cost_usd.toFixed(6)} price table`
+                            : ` · $${metrics.subject_cost_usd.toFixed(6)} provider-reported`;
         lines.push(`  COST:   ${tokens} (${metrics.subject_metrics_reps}/${metrics.total_reps} reps reported)${cost} · ${metrics.judge_calls} judge + ${metrics.judge_rejudge_calls} re-judge call(s) · ${metrics.wall_time_ms}ms · ${tools}`);
     }
     // Lift is a statement about a skill-delivered run (green or force). On a red run

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;

package/dist/spec.js

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import yaml from "js-yaml";
 import { parseTraceAssert } from "./trace-gates.js";
-import { parseTrajectoryAssert } from "./trajectory-gates.js";
 /** Thrown on any validation failure. Message always carries the spec file path. */
 export class SpecError extends Error {
     constructor(message, file) {
@@ -89,46 +88,6 @@ function resolveExtensions(env, hasSystemPrompt, id, file) {
  * with empty-git or a fixture — asking for one on a bare cwd is an authoring mistake,
  * not something to silently ignore.
  */
-function resolveEventSources(env, id, file) {
-    const raw = env && typeof env === "object" ? env.event_sources : undefined;
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw) || raw.length === 0) {
-        throw new SpecError(`scenario \`${id}\` env.event_sources must be a non-empty list`, file);
-    }
-    const allowedAdapters = new Set([
-        "normalized-v1", "principal-assurance-v1", "pi-daddy-v1", "pi-daddy-ledger-v3",
-    ]);
-    return raw.map((entry, index) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}] must be a mapping`, file);
-        }
-        const source = entry;
-        for (const key of Object.keys(source)) {
-            if (!["adapter", "path", "required"].includes(key)) {
-                throw new SpecError(`scenario \`${id}\` env.event_sources[${index}] has unknown key \`${key}\``, file);
-            }
-        }
-        if (!allowedAdapters.has(source.adapter)) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}].adapter is unsupported`, file);
-        }
-        if (typeof source.path !== "string" || !source.path.trim()) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}].path must be non-empty`, file);
-        }
-        const path = source.path.trim();
-        if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path) || path.includes("\\") || path.split("/").some((part) => part === ".." || part === "." || part === "")) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources paths must be workspace-relative without traversal (got \`${path}\`)`, file);
-        }
-        if (source.required !== undefined && typeof source.required !== "boolean") {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}].required must be true or false`, file);
-        }
-        return {
-            adapter: source.adapter,
-            path,
-            required: source.required !== false,
-        };
-    });
-}
 function resolveRemote(env, workspace, id, file) {
     const raw = env && typeof env === "object" ? env.remote : undefined;
     if (raw === undefined)
@@ -220,12 +179,12 @@ export function parseSpec(text, file) {
         // `assert.trace` is legal for inline AND seeded scenarios — it reads the
         // execution trace, which every run produces, not a staged diff.
         const rawAssert = s.assert;
+        if (rawAssert?.trajectory !== undefined) {
+            throw new SpecError(`scenario \`${id}\` uses removed \`assert.trajectory\`; delete it or replace it with an active objective gate`, file);
+        }
         if (rawAssert?.trace !== undefined) {
             scenario.traceAssert = parseTraceAssert(rawAssert.trace, `${file}: scenario \`${id}\``);
         }
-        if (rawAssert?.trajectory !== undefined) {
-            scenario.trajectoryAssert = parseTrajectoryAssert(rawAssert.trajectory, `${file}: scenario \`${id}\``);
-        }
         if (mode === "seeded") {
             if (typeof s.fixture !== "string" || s.fixture.length === 0) {
                 throw new SpecError(`seeded scenario \`${id}\` requires a \`fixture\` path`, file);
@@ -276,12 +235,11 @@ export function parseSpec(text, file) {
                 scenario.assert = assertObj;
             }
         }
+        if (s.env && typeof s.env === "object" && Object.hasOwn(s.env, "event_sources")) {
+            throw new SpecError(`scenario \`${id}\` uses removed \`env.event_sources\`; it is no longer collected`, file);
+        }
         scenario.workspace = resolveWorkspace(s.env, mode, scenario.fixture, id, file);
         scenario.remote = resolveRemote(s.env, scenario.workspace, id, file);
-        scenario.eventSources = resolveEventSources(s.env, id, file);
-        if (scenario.eventSources && !scenario.trajectoryAssert) {
-            throw new SpecError(`scenario \`${id}\` declares env.event_sources without assert.trajectory`, file);
-        }
         if (s.system_prompt_file !== undefined) {
             if (typeof s.system_prompt_file !== "string" || !s.system_prompt_file.trim()) {
                 throw new SpecError(`scenario \`${id}\` \`system_prompt_file\` must be a non-empty string`, file);

package/dist/trajectory-events.d.ts

@@ -0,0 +1,58 @@
+export declare const LEGACY_TRAJECTORY_EVENT_VERSION: "1.0";
+export declare const TRAJECTORY_EVENT_VERSION: "1.1";
+export type TrajectoryEventVersion = typeof LEGACY_TRAJECTORY_EVENT_VERSION | typeof TRAJECTORY_EVENT_VERSION;
+export interface TrajectoryEventSource {
+    adapter: "normalized-v1" | "principal-assurance-v1" | "pi-daddy-v1" | "pi-daddy-ledger-v3";
+    path: string;
+    required: boolean;
+}
+export interface TrajectoryApproval {
+    id?: string;
+    capability?: string;
+    subject?: string;
+    source?: string;
+    scope?: string;
+    approved_at?: string;
+    expires_at?: string;
+    used_at?: string;
+}
+export interface TrajectoryDigests {
+    plan?: string;
+    task?: string;
+    definition?: string;
+    head?: string;
+    tree?: string;
+    [key: string]: string | undefined;
+}
+/** Normalized pi-daddy/principal event retained by adapter consumers. */
+export interface TrajectoryEventV1 {
+    event_version: TrajectoryEventVersion;
+    seq: number;
+    type: string;
+    source: string;
+    at?: string;
+    run_id?: string;
+    task_id?: string;
+    workspace_id?: string;
+    context_id?: string;
+    finding_id?: string;
+    parent_id?: string;
+    child_id?: string;
+    execution_id?: string;
+    parent_execution_id?: string | null;
+    task_from_execution_id?: string;
+    workflow_fact_id?: string;
+    deadline_at?: string;
+    phase?: string;
+    tool?: string;
+    capability?: string;
+    requested_capabilities?: string[];
+    effective_capabilities?: string[];
+    refusal_code?: string;
+    exit_code?: number;
+    digests?: TrajectoryDigests;
+    approval?: TrajectoryApproval;
+    requirements?: string[];
+    attributes?: Record<string, unknown>;
+}
+export declare function deserializeTrajectoryEvents(text: string): TrajectoryEventV1[] | null;