@skill-harness/core 0.11.0 → 0.13.0

package/dist/screen.js

@@ -0,0 +1,105 @@
+import { deliveryStatusForObservations } from "./results.js";
+import { collapseVotePanel } from "./vote-panel.js";
+function classify(rate) {
+    if (rate.n === 0)
+        return "UNKNOWN";
+    const p = rate.passes / rate.n;
+    if (p >= 0.8)
+        return "CEILING";
+    if (p <= 0.1)
+        return "FLOOR";
+    if (p >= 0.2 && p <= 0.7)
+        return "INFORMATIVE";
+    return "UNKNOWN";
+}
+/** Pure/offline: derive only from v3 retained invocation and vote evidence. */
+export function screenResults(results) {
+    const rows = new Map();
+    const criteria = new Map();
+    for (const result of results) {
+        const observations = result.schema === 3 ? result.subject_invocations : [];
+        for (const scenario of result.scenarios) {
+            const rowKey = `${result.skill}\u0000${result.model}\u0000${scenario.id}`;
+            const row = rows.get(rowKey) ?? { control: { passes: 0, n: 0 }, treatment: { passes: 0, n: 0 }, not_measured: 0 };
+            for (const rep of scenario.rep_judgments ?? []) {
+                const repObservations = observations.filter(observation => observation.scenario_id === scenario.id && observation.repetition === rep.repetition);
+                const deliveryStatus = deliveryStatusForObservations(repObservations);
+                if (deliveryStatus === "NOT-MEASURED")
+                    row.not_measured++;
+                if (deliveryStatus !== "PASS")
+                    continue;
+                const terminalAttempt = Math.max(...repObservations.map(observation => observation.attempt ?? 0));
+                const mechanisms = new Set(repObservations.filter(observation => (observation.attempt ?? 0) === terminalAttempt).map(observation => observation.prompt.mechanism));
+                if (mechanisms.size !== 1)
+                    continue;
+                const rate = mechanisms.has("none") ? row.control : row.treatment;
+                let panelVerdict = rep.recorded_verdict;
+                if (rep.judgments.length > 0) {
+                    const clean = rep.judgments.filter(judgment => !judgment.suspect && (judgment.verdict === "PASS" || judgment.verdict === "FAIL"));
+                    if (clean.length === 0)
+                        continue;
+                    panelVerdict = clean.length === 1 ? clean[0].verdict : collapseVotePanel(rep.judgments).verdict ?? "JUDGE-AMBIGUOUS";
+                }
+                else if (rep.objective?.status === "FAIL" && rep.recorded_verdict === "FAIL") {
+                    panelVerdict = "FAIL"; // objective behavioral evidence needs no prose judge
+                }
+                else
+                    continue;
+                if (scenario.adjudication?.repetition === rep.repetition) {
+                    if (scenario.adjudication.state === "unresolved" || !scenario.adjudication.verdict)
+                        continue;
+                    const adjudicated = collapseVotePanel(scenario.adjudication.judgments);
+                    if (adjudicated.state !== scenario.adjudication.state || adjudicated.verdict !== scenario.adjudication.verdict)
+                        continue;
+                    panelVerdict = adjudicated.verdict;
+                }
+                const effective = rep.objective?.status === "ERROR" ? "ERROR" : rep.objective?.status === "NOT-MEASURED" ? "NOT-MEASURED" : rep.objective?.status === "FAIL" ? "FAIL" : panelVerdict;
+                if (effective !== "PASS" && effective !== "FAIL")
+                    continue;
+                rate.n++;
+                if (effective === "PASS")
+                    rate.passes++;
+                for (const judgment of rep.judgments) {
+                    if (judgment.suspect || (judgment.verdict !== "PASS" && judgment.verdict !== "FAIL"))
+                        continue;
+                    for (const vote of judgment.criteria ?? [])
+                        addCriterion(criteria, result.skill, result.model, scenario.id, vote);
+                }
+            }
+            const adjudicatedRep = scenario.adjudication?.repetition;
+            const adjudicationDelivery = result.schema === 3 && adjudicatedRep !== undefined
+                ? deliveryStatusForObservations(observations.filter(observation => observation.scenario_id === scenario.id && observation.repetition === adjudicatedRep))
+                : "ERROR";
+            for (const judgment of adjudicationDelivery === "PASS" ? scenario.adjudication?.judgments.filter(judgment => judgment.ordinal > 1) ?? [] : []) {
+                if (judgment.suspect || (judgment.verdict !== "PASS" && judgment.verdict !== "FAIL"))
+                    continue;
+                for (const vote of judgment.criteria ?? [])
+                    addCriterion(criteria, result.skill, result.model, scenario.id, vote);
+            }
+            rows.set(rowKey, row);
+        }
+    }
+    return {
+        scenarios: [...rows.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, row]) => { const [skill, model, id] = key.split("\u0000"); return { skill, model, id, ...row, classification: classify(row.control) }; }),
+        criteria: [...criteria.values()].sort((a, b) => a.scenario_id.localeCompare(b.scenario_id) || a.criterion - b.criterion).map(x => ({ ...x, fail_rate: x.failures / x.n })),
+    };
+}
+function addCriterion(map, skill, model, id, vote) {
+    if (vote.verdict === "ERROR")
+        return;
+    const key = `${skill}\u0000${model}\u0000${id}:${vote.index}`, row = map.get(key) ?? { skill, model, scenario_id: id, criterion: vote.index, failures: 0, n: 0 };
+    row.n++;
+    if (vote.verdict === "FAIL")
+        row.failures++;
+    map.set(key, row);
+}
+export function formatScreen(report) {
+    const lines = ["skill/model/scenario  control  treatment  not-measured  class"];
+    for (const s of report.scenarios)
+        lines.push(`${s.skill}/${s.model}/${s.id}  ${s.control.passes}/${s.control.n}  ${s.treatment.passes}/${s.treatment.n}  ${s.not_measured}  ${s.classification}`);
+    lines.push("", "skill/model/criterion  failures/n  fail-rate");
+    for (const c of report.criteria)
+        lines.push(`${c.skill}/${c.model}/${c.scenario_id}.${c.criterion}  ${c.failures}/${c.n}  ${(c.fail_rate * 100).toFixed(1)}%`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=screen.js.map

package/dist/seeded.d.ts

@@ -1,7 +1,7 @@
 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 } from "./adapters/types.js";
+import type { HarnessAdapter, ModelRef, RunMode, PromptProvenance } from "./adapters/types.js";
 import { type ExecResult } from "./util/exec.js";
 interface SeededOpts {
     skillDir: string;
@@ -37,6 +37,7 @@ 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

package/dist/seeded.js

@@ -175,6 +175,7 @@ export async function runSeeded(scenario, opts) {
         ],
         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

package/dist/sources.d.ts

@@ -1,4 +1,5 @@
 import type { Scenario } from "./spec.js";
+export { PROMPT_NORMALIZATION_SOURCE_DIGEST, PROMPT_NORMALIZATION_SOURCE_KEY } from "./prompt-normalization.js";
 /**
  * What a run measured, as a map of `key -> sha256`, recorded in results.yaml so
  * lint can prove a published result still describes the current inputs.
@@ -53,7 +54,7 @@ export declare const FIXTURE_PREFIX = "fixture:";
  * | `stimulus:<id>` | mode, turns, workspace, remote, agent-file path, fixture path, `assert.vitest`, `post_test` path | the transcripts answer a different question | `run` (model + judge) |
  * | `rubric:<id>` | title, checklist | transcripts fine, verdicts wrong | `grade` (judge only) |
  * | `policy:<id>` | critical, reps, pass_threshold | only the scoring moved | `rescore` (free) |
- * | `gates:<id>` | `diff_contains`, `diff_excludes` | needle wrong, behavior fine | `regate` (free; judges only flipped reps) |
+ * | `gates:<id>` | `diff_contains`, `diff_excludes` | needle wrong, behavior fine | `regate` (no subject call; judges fail→pass reps) |
  * | `rubric:__persona` | spec-level `judge_persona` | every verdict in the skill | `grade` per model |
  *
  * Why this matters more than it looks: with one key, lint had exactly one remedy for
@@ -190,6 +191,11 @@ export declare const SKILL_KEY = "SKILL.md";
  */
 export declare const SKILL_PROMPT_KEY = "skill:prompt";
 export declare const PROMPT_PREFIX = "prompt:";
+/** A prompt document split into its frontmatter text (null when it has none) and its body. */
+export declare function splitPromptDoc(text: string): {
+    frontmatter: string | null;
+    body: string;
+};
 /**
  * The digest of a prompt document: its body verbatim, plus every frontmatter field the
  * model can actually receive.

package/dist/sources.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 import { readFileSync, readdirSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import yaml from "js-yaml";
+import { PROMPT_NORMALIZATION_SOURCE_DIGEST, PROMPT_NORMALIZATION_SOURCE_KEY } from "./prompt-normalization.js";
+export { PROMPT_NORMALIZATION_SOURCE_DIGEST, PROMPT_NORMALIZATION_SOURCE_KEY } from "./prompt-normalization.js";
 /**
  * What a run measured, as a map of `key -> sha256`, recorded in results.yaml so
  * lint can prove a published result still describes the current inputs.
@@ -56,7 +58,7 @@ export const FIXTURE_PREFIX = "fixture:";
  * | `stimulus:<id>` | mode, turns, workspace, remote, agent-file path, fixture path, `assert.vitest`, `post_test` path | the transcripts answer a different question | `run` (model + judge) |
  * | `rubric:<id>` | title, checklist | transcripts fine, verdicts wrong | `grade` (judge only) |
  * | `policy:<id>` | critical, reps, pass_threshold | only the scoring moved | `rescore` (free) |
- * | `gates:<id>` | `diff_contains`, `diff_excludes` | needle wrong, behavior fine | `regate` (free; judges only flipped reps) |
+ * | `gates:<id>` | `diff_contains`, `diff_excludes` | needle wrong, behavior fine | `regate` (no subject call; judges fail→pass reps) |
  * | `rubric:__persona` | spec-level `judge_persona` | every verdict in the skill | `grade` per model |
  *
  * Why this matters more than it looks: with one key, lint had exactly one remedy for
@@ -182,7 +184,7 @@ function facets(s) {
     const _assertExhaustive = restAssert;
     void _assertExhaustive;
     // `traceAssert` is a GATE, not stimulus: it is evaluated against a trace the run
-    // already saved, so `regate` (free) can re-answer it without re-running the model.
+    // 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;
@@ -194,7 +196,7 @@ function facets(s) {
         // below. Changing which extensions load changes what the model can DO, so the
         // old transcripts describe a different agent and only a re-run can answer.
         // Changing an assertion only changes what we conclude from evidence already on
-        // disk, which `regate` can redo for free.
+        // disk, which `regate` can redo without a subject re-run.
         // APPENDED CONDITIONALLY, never as a fixed slot. This tuple is positional and
         // its hash is stored in every published results.yaml, so adding an
         // unconditional element re-hashes every scenario that never used the field —
@@ -363,6 +365,8 @@ export function sourceHashes(ctx) {
  * from drifting: a new key kind is defined once, for both sides.
  */
 export function currentHashFor(key, ctx) {
+    if (key === PROMPT_NORMALIZATION_SOURCE_KEY)
+        return PROMPT_NORMALIZATION_SOURCE_DIGEST;
     if (key === SKILL_KEY)
         return fileSha256(resolve(ctx.skillDir, "SKILL.md"));
     if (key === SKILL_PROMPT_KEY)
@@ -408,6 +412,8 @@ export function currentHashFor(key, ctx) {
 }
 /** Human label for a recorded key, used in lint messages. */
 export function describeSourceKey(key) {
+    if (key === PROMPT_NORMALIZATION_SOURCE_KEY)
+        return "the prompt normalization rule registry";
     if (key === PERSONA_KEY)
         return "the judge persona";
     // Deliberately the same label as the raw-bytes key: only one of the pair is ever
@@ -439,6 +445,8 @@ export function describeSourceKey(key) {
  * in place. Naming the actual remedy is what converts that into a free command.
  */
 export function remedyForKey(key) {
+    if (key === PROMPT_NORMALIZATION_SOURCE_KEY)
+        return "re-run — prompt provenance cannot be recomputed without the original model-visible payload";
     if (key === PERSONA_KEY) {
         return "re-grade each model's saved transcripts (`grade <run-dir>`) — judge-only, no model spend";
     }
@@ -449,7 +457,7 @@ export function remedyForKey(key) {
         return "re-score the saved reps (`rescore <run-dir>`) — free, offline";
     }
     if (key.startsWith(GATES_PREFIX)) {
-        return "re-evaluate the needles against the saved diffs (`regate <run-dir>`) — free, and it judges only the reps whose gate verdict flipped";
+        return "re-evaluate gates against saved artifacts (`regate <run-dir>`) — no subject call; fail→pass reps require judge calls";
     }
     // A pre-split run recorded one hash over stimulus + rubric + policy + gates, so
     // which of them moved is genuinely unknowable from the record. Naming a cheap
@@ -498,7 +506,7 @@ const CAPABILITY_KEYS = new Set(["allowed-tools", "tools"]);
 /** Opening `---` on line 1 only — a `---` further down is a horizontal rule. */
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
 /** A prompt document split into its frontmatter text (null when it has none) and its body. */
-function splitPromptDoc(text) {
+export function splitPromptDoc(text) {
     const m = FRONTMATTER_RE.exec(text);
     // Unterminated frontmatter falls through to "all body", the same call
     // instruction-coverage.ts makes: treat the whole file as content rather than lose it.

package/dist/spec.d.ts

@@ -23,7 +23,7 @@ export interface SeededAssert {
 }
 export interface TrajectoryEventSource {
     /** Native format adapter registered by the harness adapter. */
-    adapter: "normalized-v1" | "principal-assurance-v1" | "pi-daddy-v1";
+    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. */

package/dist/spec.js

@@ -97,7 +97,7 @@ function resolveEventSources(env, id, file) {
         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",
+        "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)) {

package/dist/stability.js

@@ -9,7 +9,7 @@ function conclusive(v) {
     // Same rule lift.ts applies, for the same reason: ERROR is a harness failure and an
     // unresolved misfire is a judge failure. Counting either as a side of a flip would
     // report infrastructure noise as behavioural instability.
-    return !v.suspect && v.verdict !== "ERROR" && v.verdict !== "JUDGE-AMBIGUOUS";
+    return !v.suspect && v.verdict !== "ERROR" && v.verdict !== "NOT-MEASURED" && v.verdict !== "JUDGE-AMBIGUOUS";
 }
 function pointFor(r, s, verdict) {
     const reps = s.reps ?? 1;

package/dist/trajectory-gates.d.ts

@@ -1,6 +1,8 @@
 import { type ArgPredicate, type CountConstraint } from "./trace-gates.js";
 /** Adapter-neutral event contract used by objective trajectory assertions. */
-export declare const TRAJECTORY_EVENT_VERSION: "1.0";
+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 declare const TRAJECTORY_ASSERT_VERSION: "1.0";
 export interface TrajectoryApproval {
     id?: string;
@@ -26,7 +28,7 @@ export interface TrajectoryDigests {
  * needs to know whether the source was pi, pi-daddy, or principal assurance.
  */
 export interface TrajectoryEventV1 {
-    event_version: typeof TRAJECTORY_EVENT_VERSION;
+    event_version: TrajectoryEventVersion;
     seq: number;
     type: string;
     source: string;
@@ -38,6 +40,16 @@ export interface TrajectoryEventV1 {
     finding_id?: string;
     parent_id?: string;
     child_id?: string;
+    /** Unique pi-daddy v3 execution occurrence; never synthesized for v2/0.17. */
+    execution_id?: string;
+    /** Explicit v3 execution parent. Null is a meaningful root identity. */
+    parent_execution_id?: string | null;
+    /** Unique v3 occurrence whose output composed this task. */
+    task_from_execution_id?: string;
+    /** Identity of a pi-daddy v3 workflow_fact occurrence. */
+    workflow_fact_id?: string;
+    /** Immutable v3 nonterminal lifecycle deadline. */
+    deadline_at?: string;
     phase?: string;
     tool?: string;
     capability?: string;
@@ -123,15 +135,3 @@ export declare function deserializeTrajectoryEvents(text: string): TrajectoryEve
 /** Evaluate a closed, declarative assertion set over saved normalized events. */
 export declare function evaluateTrajectoryGates(assert: TrajectoryAssert, input: TrajectoryEventV1[]): TrajectoryGateResult;
 export declare function parseTrajectoryAssert(raw: unknown, ctx: string): TrajectoryAssert;
-export interface MutationSelfTestCase {
-    id: string;
-    detected: boolean;
-    status: TrajectoryAssertionStatus;
-    detail: string;
-}
-export interface MutationSelfTestReport {
-    baseline: "PASS";
-    cases: MutationSelfTestCase[];
-}
-/** Fast, deterministic proof that every trajectory assertion class can turn red. */
-export declare function runTrajectoryMutationSelfTest(): MutationSelfTestReport;

package/dist/trajectory-gates.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import { parsePredicate, testPredicate } from "./trace-gates.js";
 /** Adapter-neutral event contract used by objective trajectory assertions. */
-export const TRAJECTORY_EVENT_VERSION = "1.0";
+export const LEGACY_TRAJECTORY_EVENT_VERSION = "1.0";
+export const TRAJECTORY_EVENT_VERSION = "1.1";
 export const TRAJECTORY_ASSERT_VERSION = "1.0";
 export function trajectoryEventsSha256(events) {
     return createHash("sha256").update(stableStringify(events)).digest("hex");
@@ -428,42 +429,14 @@ function parseCount(raw, ctx) {
         throw new Error(`${ctx}.min exceeds max`);
     return out;
 }
-/** Fast, deterministic proof that every trajectory assertion class can turn red. */
-export function runTrajectoryMutationSelfTest() {
-    const e = (seq, type, extra = {}) => ({ event_version: TRAJECTORY_EVENT_VERSION, seq, type, source: "mutation-self-test", at: `2026-01-01T00:00:${String(seq).padStart(2, "0")}Z`, ...extra });
-    const h = "a".repeat(40), t = "b".repeat(40), p = "1".repeat(64);
-    const cases = [
-        { id: "remove-required-event", assertion: { version: "1.0", require: [{ event: "risk_classified" }] }, good: [e(1, "risk_classified")], mutate: () => [e(1, "unrelated")] },
-        { id: "add-forbidden-tool-side-effect", assertion: { version: "1.0", forbid: [{ event: "tool_called", where: { tool: { equals: "rm" } } }, { event: "side_effect_performed" }] }, good: [e(1, "tool_called", { tool: "read" })], mutate: (events) => [...events, e(2, "side_effect_performed", { attributes: { destructive: true } })] },
-        { id: "reorder-transition", assertion: { version: "1.0", ordered: [[{ event: "phase_started" }, { event: "phase_completed" }]] }, good: [e(1, "phase_started"), e(2, "phase_completed")], mutate: () => [e(2, "phase_started"), e(1, "phase_completed")] },
-        { id: "substitute-workspace-id", assertion: { version: "1.0", correlate: [{ left: { event: "code_changed" }, right: { event: "evidence_recorded" }, same: ["workspace_id"] }] }, good: [e(1, "code_changed", { workspace_id: "ws-1" }), e(2, "evidence_recorded", { workspace_id: "ws-1" })], mutate: (events) => events.map((x) => x.type === "evidence_recorded" ? { ...x, workspace_id: "ws-2" } : x) },
-        { id: "concurrent-writer", assertion: { version: "1.0", forbid: [{ event: "writer_lease_conflict" }] }, good: [e(1, "writer_lease_acquired", { workspace_id: "ws-1" })], mutate: (events) => [...events, e(2, "writer_lease_conflict", { workspace_id: "ws-1" })] },
-        { id: "approval-expired-or-mismatched", assertion: { version: "1.0", approvals: [{ grant: { event: "approval_granted" }, use: { event: "approval_used" }, same: ["approval.id", "approval.capability"], unexpired: true }] }, good: [e(1, "approval_granted", { approval: { id: "a1", capability: "push", expires_at: "2026-01-01T01:00:00Z" } }), e(2, "approval_used", { approval: { id: "a1", capability: "push", used_at: "2026-01-01T00:01:00Z" } })], mutate: (events) => events.map((x) => x.type === "approval_used" ? { ...x, approval: { ...x.approval, used_at: "2026-01-01T02:00:00Z" } } : x) },
-        { id: "evidence-before-change", assertion: { version: "1.0", freshness: [{ subject: { event: "evidence_recorded" }, after: [{ event: "code_changed" }] }] }, good: [e(1, "code_changed"), e(2, "evidence_recorded")], mutate: () => [e(2, "code_changed"), e(1, "evidence_recorded")] },
-        { id: "evidence-before-authority", assertion: { version: "1.0", freshness: [{ subject: { event: "evidence_recorded" }, after: [{ event: "plan_recorded" }] }] }, good: [e(1, "plan_recorded", { digests: { plan: p } }), e(2, "evidence_recorded")], mutate: () => [e(2, "plan_recorded", { digests: { plan: p } }), e(1, "evidence_recorded")] },
-        { id: "evidence-before-build-completion", assertion: { version: "1.0", freshness: [{ subject: { event: "evidence_recorded" }, after: [{ event: "phase_completed", where: { phase: { equals: "build" } } }] }] }, good: [e(1, "phase_completed", { phase: "build" }), e(2, "evidence_recorded")], mutate: () => [e(2, "phase_completed", { phase: "build" }), e(1, "evidence_recorded")] },
-        { id: "head-equal-tree-different", assertion: { version: "1.0", correlate: [{ left: { event: "code_changed" }, right: { event: "evidence_recorded" }, same: ["digests.head", "digests.tree"] }] }, good: [e(1, "code_changed", { digests: { head: h, tree: t } }), e(2, "evidence_recorded", { digests: { head: h, tree: t } })], mutate: (events) => events.map((x) => x.type === "evidence_recorded" ? { ...x, digests: { head: h, tree: "c".repeat(40) } } : x) },
-        { id: "command-receipt-nonzero", assertion: { version: "1.0", require: [{ event: "evidence_recorded", where: { exit_code: { equals: 0 } } }] }, good: [e(1, "evidence_recorded", { exit_code: 0 })], mutate: (events) => events.map((x) => ({ ...x, exit_code: 1 })) },
-        { id: "remove-requirement-coverage", assertion: { version: "1.0", coverage: [{ requirements: ["AUTH-7"], events: { event: "evidence_recorded" } }] }, good: [e(1, "evidence_recorded", { requirements: ["AUTH-7"] })], mutate: (events) => events.map((x) => ({ ...x, requirements: [] })) },
-        { id: "mutate-superseded-task", assertion: { version: "1.0", forbid_after: [{ anchor: { event: "task_packet_superseded" }, forbidden: [{ event: "code_changed" }, { event: "repair_started" }], same: ["task_id"] }] }, good: [e(1, "task_packet_superseded", { task_id: "old" }), e(2, "code_changed", { task_id: "new" })], mutate: (events) => events.map((x) => x.type === "code_changed" ? { ...x, task_id: "old" } : x) },
-        { id: "reuse-context-id", assertion: { version: "1.0", unique: [{ events: { event: "review_recorded" }, fields: ["context_id"] }] }, good: [e(1, "review_recorded", { context_id: "c1" }), e(2, "review_recorded", { context_id: "c2" })], mutate: (events) => events.map((x) => x.seq === 2 ? { ...x, context_id: "c1" } : x) },
-        { id: "mismatch-finalization-identity", assertion: { version: "1.0", correlate: [{ left: { event: "gate_evaluated", where: { "attributes.gate": { equals: "finalize" } } }, right: { event: "finalization_completed" }, same: ["digests.head", "digests.tree"], order: "before" }] }, good: [e(1, "gate_evaluated", { digests: { head: h, tree: t }, attributes: { gate: "finalize", result: "pass" } }), e(2, "finalization_completed", { digests: { head: h, tree: t } })], mutate: (events) => events.map((x) => x.type === "finalization_completed" ? { ...x, digests: { head: h, tree: "d".repeat(40) } } : x) },
-    ];
-    const results = cases.map((testCase) => {
-        const baseline = evaluateTrajectoryGates(testCase.assertion, testCase.good);
-        if (baseline.status !== "PASS")
-            throw new Error(`mutation self-test baseline ${testCase.id} is ${baseline.status}`);
-        const mutated = evaluateTrajectoryGates(testCase.assertion, testCase.mutate(structuredClone(testCase.good)));
-        return { id: testCase.id, detected: mutated.status !== "PASS", status: mutated.status, detail: mutated.assertions.find((result) => result.status !== "PASS")?.detail ?? "mutation was not detected" };
-    });
-    return { baseline: "PASS", cases: results };
-}
 // ---------------------------------------------------------------------------
 // Internals
 // ---------------------------------------------------------------------------
+const V11_EVENT_KEYS = new Set(["execution_id", "parent_execution_id", "task_from_execution_id", "workflow_fact_id", "deadline_at"]);
 const EVENT_KEYS = new Set([
     "event_version", "seq", "type", "source", "at", "run_id", "task_id", "workspace_id", "context_id", "finding_id",
-    "parent_id", "child_id", "phase", "tool", "capability", "requested_capabilities", "effective_capabilities", "refusal_code",
+    "parent_id", "child_id", ...V11_EVENT_KEYS,
+    "phase", "tool", "capability", "requested_capabilities", "effective_capabilities", "refusal_code",
     "exit_code", "digests", "approval", "requirements", "attributes",
 ]);
 const APPROVAL_KEYS = new Set(["id", "capability", "subject", "source", "scope", "approved_at", "expires_at", "used_at"]);
@@ -479,8 +452,14 @@ function validateEvent(event) {
     const unknown = Object.keys(object).find((key) => !EVENT_KEYS.has(key));
     if (unknown)
         return `unknown field ${unknown}`;
-    if (event.event_version !== TRAJECTORY_EVENT_VERSION)
+    if (event.event_version !== LEGACY_TRAJECTORY_EVENT_VERSION && event.event_version !== TRAJECTORY_EVENT_VERSION) {
         return `unsupported event_version ${String(event.event_version)}`;
+    }
+    if (event.event_version === LEGACY_TRAJECTORY_EVENT_VERSION) {
+        const versionedField = Object.keys(object).find((key) => V11_EVENT_KEYS.has(key));
+        if (versionedField)
+            return `${versionedField} requires event_version ${TRAJECTORY_EVENT_VERSION}`;
+    }
     if (!Number.isInteger(event.seq) || event.seq < 1)
         return "seq must be a positive integer";
     if (typeof event.type !== "string" || !event.type)
@@ -489,10 +468,15 @@ function validateEvent(event) {
         return "source must be a non-empty string";
     if (event.at !== undefined && !validDate(event.at))
         return "at must be an RFC 3339 date-time";
-    for (const field of ["run_id", "task_id", "workspace_id", "context_id", "finding_id", "parent_id", "child_id"]) {
+    for (const field of ["run_id", "task_id", "workspace_id", "context_id", "finding_id", "parent_id", "child_id", "execution_id", "task_from_execution_id", "workflow_fact_id"]) {
         if (event[field] !== undefined && (typeof event[field] !== "string" || !ID_RE.test(event[field])))
             return `${field} is not a valid bounded identifier`;
     }
+    if (event.parent_execution_id !== undefined && event.parent_execution_id !== null &&
+        (typeof event.parent_execution_id !== "string" || !ID_RE.test(event.parent_execution_id)))
+        return "parent_execution_id is not a valid bounded identifier or null";
+    if (event.deadline_at !== undefined && !validDate(event.deadline_at))
+        return "deadline_at must be an RFC 3339 date-time";
     for (const field of ["phase", "tool", "capability"]) {
         if (event[field] !== undefined && (typeof event[field] !== "string" || !event[field]))
             return `${field} must be a non-empty string`;

package/dist/trusted-host-supervision.d.ts

@@ -0,0 +1,25 @@
+import type { ChildProcess } from 'node:child_process';
+import { type QualificationProcessIdentity } from './qualification-process.js';
+export interface TrustedHostSupervisionLimits {
+    wallMs: number;
+    settlementMs: number;
+    maxOutputBytes: number;
+    signal: AbortSignal;
+}
+export interface TrustedHostProcessObservation {
+    outcome: 'completed' | 'failed' | 'aborted' | 'timed-out' | 'output-limit' | 'unknown';
+    identity: QualificationProcessIdentity;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdoutBytes: number;
+    stderrBytes: number;
+    truncated: boolean;
+    cleanupAttempted: boolean;
+    acceptance: 'not-assessed';
+}
+/** Observe an ALREADY admitted, caller-owned detached Linux child, after its spawn event.
+ * No spawn/authorization/accounting/retry is performed here. The parent event loop must
+ * remain responsive. Occurrence-safe same-group cleanup is not hostile-code containment,
+ * survivor/crash recovery, hard aggregate RAM/CPU, or proof of remote provider termination.
+ * Bytes are discarded, not retained or hashed; the existing worker journal owns artifacts. */
+export declare function superviseTrustedHost(child: ChildProcess, limits: TrustedHostSupervisionLimits): Promise<TrustedHostProcessObservation>;

package/dist/trusted-host-supervision.js

@@ -0,0 +1,94 @@
+import { readFileSync } from 'node:fs';
+import { qualificationProcessIdentity, cleanupQualificationProcessGroupAfterLeaderExit, terminateQualificationProcess } from './qualification-process.js';
+const monitored = new WeakSet();
+/** Observe an ALREADY admitted, caller-owned detached Linux child, after its spawn event.
+ * No spawn/authorization/accounting/retry is performed here. The parent event loop must
+ * remain responsive. Occurrence-safe same-group cleanup is not hostile-code containment,
+ * survivor/crash recovery, hard aggregate RAM/CPU, or proof of remote provider termination.
+ * Bytes are discarded, not retained or hashed; the existing worker journal owns artifacts. */
+export async function superviseTrustedHost(child, limits) {
+    if (process.platform !== 'linux')
+        throw Error('trusted host supervision requires Linux occurrence identity');
+    if (!(limits.signal instanceof AbortSignal) || !Number.isSafeInteger(limits.wallMs) || limits.wallMs < 1 || limits.wallMs > 150000 || !Number.isSafeInteger(limits.settlementMs) || limits.settlementMs < 100 || limits.settlementMs > 5000 || !Number.isSafeInteger(limits.maxOutputBytes) || limits.maxOutputBytes < 1 || limits.maxOutputBytes > 1048576)
+        throw Error('bounded trusted host limits required');
+    if (monitored.has(child))
+        throw Error('original child already monitored; no retry');
+    if (!child.pid || !child.stdout || !child.stderr || child.exitCode !== null || child.signalCode !== null)
+        throw Error('live caller-owned child with output pipes required');
+    const identity = qualificationProcessIdentity(child.pid), stat = readFileSync(`/proc/${child.pid}/stat`, 'utf8'), fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+    if (Number(fields[2]) !== child.pid || fields[19] !== identity.start_ticks)
+        throw Error('original detached process group required');
+    monitored.add(child);
+    const stdout = child.stdout, stderr = child.stderr;
+    return new Promise(resolve => {
+        let reason = null, done = false, exited = false, closed = false, exitCode = null, signal = null, stdoutBytes = 0, stderrBytes = 0, cleanupAttempted = false;
+        let settling, cleanup = null;
+        const finish = (outcome) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(wall);
+            clearTimeout(settling);
+            limits.signal.removeEventListener('abort', abort);
+            stdout.off('data', out);
+            stderr.off('data', err);
+            stdout.resume();
+            stderr.resume();
+            child.off('exit', exit);
+            child.off('close', close);
+            child.off('error', error);
+            // On unknown, the caller still owns this child and occurrence. Never claim settlement.
+            resolve({ outcome, identity, exitCode, signal, stdoutBytes, stderrBytes, truncated: stdoutBytes + stderrBytes > limits.maxOutputBytes, cleanupAttempted, acceptance: 'not-assessed' });
+        };
+        const boundSettlement = () => { settling ??= setTimeout(() => finish('unknown'), limits.settlementMs); };
+        const stop = (why) => {
+            if (done)
+                return;
+            reason ??= why;
+            boundSettlement();
+            if (cleanupAttempted)
+                return;
+            cleanupAttempted = true;
+            try {
+                terminateQualificationProcess(child, identity);
+            }
+            catch {
+                finish('unknown');
+            }
+        };
+        const out = (b) => { stdoutBytes += b.length; if (stdoutBytes + stderrBytes > limits.maxOutputBytes)
+            stop('output-limit'); };
+        const err = (b) => { stderrBytes += b.length; if (stdoutBytes + stderrBytes > limits.maxOutputBytes)
+            stop('output-limit'); };
+        const abort = () => stop('aborted');
+        const error = () => stop('failed');
+        const complete = () => {
+            if (!exited || !closed || done)
+                return;
+            void (cleanup ?? Promise.resolve()).then(() => finish(reason ?? (exitCode === 0 ? 'completed' : 'failed')), () => finish('unknown'));
+        };
+        const exit = (code, sig) => {
+            exited = true;
+            exitCode = code;
+            signal = sig;
+            clearTimeout(wall);
+            boundSettlement();
+            cleanupAttempted = true;
+            cleanup = cleanupQualificationProcessGroupAfterLeaderExit(child.pid, identity);
+            // Attach rejection handling immediately, even if descendant-held pipes never close.
+            void cleanup.catch(() => finish('unknown'));
+            complete();
+        };
+        const close = () => { closed = true; complete(); };
+        const wall = setTimeout(() => stop('timed-out'), limits.wallMs);
+        stdout.on('data', out);
+        stderr.on('data', err);
+        child.once('error', error);
+        child.once('exit', exit);
+        child.once('close', close);
+        limits.signal.addEventListener('abort', abort, { once: true });
+        if (limits.signal.aborted)
+            abort();
+    });
+}
+//# sourceMappingURL=trusted-host-supervision.js.map

package/dist/vote-panel.d.ts

@@ -0,0 +1,33 @@
+import type { Verdict } from "./score.js";
+/** Domain-neutral vote shape shared by ordinary adjudication and qualification panels. */
+export interface PanelVote {
+    ordinal: number;
+    verdict: Verdict;
+    suspect: boolean;
+}
+export interface VotePanelCollapse {
+    state: "confirmed" | "tie_broken" | "unresolved";
+    verdict?: "PASS" | "FAIL";
+    clean_votes: number;
+    pass_votes: number;
+    fail_votes: number;
+    /** True only when the first two answers are both clean and oppose one another. */
+    split: boolean;
+    /** Minority clean votes / all clean votes; zero when there is no minority. */
+    minority_rate: number;
+}
+export declare function isCleanPanelVote(vote: PanelVote): vote is PanelVote & {
+    verdict: "PASS" | "FAIL";
+};
+/**
+ * One collapse rule for both skill-harness adjudication and qualification.
+ * Invalid, ambiguous, and suspect answers remain evidence but are never votes.
+ */
+export declare function collapseVotePanel(votes: readonly PanelVote[]): VotePanelCollapse;
+export declare function runVotePanel<T extends PanelVote>(options: {
+    cast: (ordinal: 1 | 2 | 3) => Promise<T>;
+}): Promise<{
+    votes: T[];
+    collapse: VotePanelCollapse;
+    calls_made: number;
+}>;

package/dist/vote-panel.js

@@ -0,0 +1,41 @@
+export function isCleanPanelVote(vote) {
+    return !vote.suspect && (vote.verdict === "PASS" || vote.verdict === "FAIL");
+}
+/**
+ * One collapse rule for both skill-harness adjudication and qualification.
+ * Invalid, ambiguous, and suspect answers remain evidence but are never votes.
+ */
+export function collapseVotePanel(votes) {
+    const clean = votes.filter(isCleanPanelVote);
+    const passVotes = clean.filter((vote) => vote.verdict === "PASS").length;
+    const failVotes = clean.length - passVotes;
+    const firstTwo = votes.filter((vote) => vote.ordinal === 1 || vote.ordinal === 2);
+    const split = firstTwo.length === 2 && firstTwo.every(isCleanPanelVote) && firstTwo[0].verdict !== firstTwo[1].verdict;
+    const minority = Math.min(passVotes, failVotes);
+    const base = {
+        clean_votes: clean.length,
+        pass_votes: passVotes,
+        fail_votes: failVotes,
+        split,
+        minority_rate: clean.length === 0 ? 0 : minority / clean.length,
+    };
+    if (clean.length < 2)
+        return { ...base, state: "unresolved" };
+    if (passVotes === 0 || failVotes === 0)
+        return { ...base, state: "confirmed", verdict: clean[0].verdict };
+    if (passVotes > failVotes)
+        return { ...base, state: "tie_broken", verdict: "PASS" };
+    if (failVotes > passVotes)
+        return { ...base, state: "tie_broken", verdict: "FAIL" };
+    return { ...base, state: "unresolved" };
+}
+export async function runVotePanel(options) {
+    const votes = [await options.cast(1), await options.cast(2)];
+    let collapse = collapseVotePanel(votes);
+    if (collapse.split) {
+        votes.push(await options.cast(3));
+        collapse = collapseVotePanel(votes);
+    }
+    return { votes, collapse, calls_made: votes.length };
+}
+//# sourceMappingURL=vote-panel.js.map