@skill-harness/core 0.10.0 → 0.12.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;
@@ -27,6 +27,17 @@ interface SeededOpts {
         scenarioId: string;
         rep: number;
     };
+    /**
+     * Absolute paths of an arm's pi extensions, merged with `scenario.extensions`
+     * when the `RunReq` is built below — the same shape the non-seeded path in
+     * `run.ts` produces, so a trace-gated seeded scenario measures the same
+     * delivery as an ungated one (the reason `runStructured` shares `skillFlags`
+     * with `run()` instead of inventing a second convention applies here too).
+     */
+    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

@@ -166,9 +166,16 @@ export async function runSeeded(scenario, opts) {
         mode: opts.mode,
         turns: scenario.turns,
         cwd: repo,
-        // Resolved against the spec dir, exactly like fixtures and post-tests.
-        extensions: scenario.extensions?.map((e) => resolve(opts.specDir, e)),
+        // Resolved against the spec dir, exactly like fixtures and post-tests —
+        // the arm's extensions (already absolute) join alongside, same as the
+        // non-seeded path in run.ts.
+        extensions: [
+            ...(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

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;

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");
@@ -434,7 +435,7 @@ export function runTrajectoryMutationSelfTest() {
     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: "add-forbidden-tool-side-effect-approval", assertion: { version: "1.0", forbid: [{ event: "tool_called", where: { tool: { equals: "rm" } } }, { event: "side_effect_approved" }] }, good: [e(1, "tool_called", { tool: "read" })], mutate: (events) => [...events, e(2, "side_effect_approved", { attributes: { action: "migration" } })] },
         { 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" })] },
@@ -447,7 +448,13 @@ export function runTrajectoryMutationSelfTest() {
         { 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) },
+        { 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", code: "OK" } }), 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) },
+        { id: "v3-blocked-critical-code", assertion: { version: "1.0", require: [{ event: "gate_evaluated", where: { "attributes.code": { equals: "BLOCKED_CRITICAL_ASSURANCE" } } }] }, good: [e(1, "gate_evaluated", { attributes: { gate: "finalize", code: "BLOCKED_CRITICAL_ASSURANCE", missing_count: 2 } })], mutate: (events) => events.map((x) => ({ ...x, attributes: { ...x.attributes, code: "OK" } })) },
+        { id: "v3-stale-gate-must-block", assertion: { version: "1.0", require: [{ event: "gate_evaluated", where: { "attributes.code": { matches: "^BLOCKED_" } } }] }, good: [e(1, "gate_evaluated", { attributes: { gate: "finalize", code: "BLOCKED_ASSURANCE" } })], mutate: (events) => events.map((x) => ({ ...x, attributes: { ...x.attributes, code: "OK" } })) },
+        { id: "v3-finalize-gate-must-be-ok", assertion: { version: "1.0", require: [{ event: "gate_evaluated", where: { "attributes.gate": { equals: "finalize" }, "attributes.code": { equals: "OK" } } }] }, good: [e(1, "gate_evaluated", { attributes: { gate: "finalize", code: "OK" } })], mutate: (events) => events.map((x) => ({ ...x, attributes: { ...x.attributes, code: "BLOCKED_ASSURANCE" } })) },
+        { id: "v3-discard-requires-explicit-request", assertion: { version: "1.0", forbid: [{ event: "finish_selected", where: { "attributes.choice": { equals: "discard" }, "attributes.explicit_request": { equals: false } } }] }, good: [e(1, "finish_selected", { attributes: { choice: "discard", explicit_request: true } })], mutate: (events) => events.map((x) => ({ ...x, attributes: { ...x.attributes, explicit_request: false } })) },
+        { id: "v3-side-effect-approval-and-gate", assertion: { version: "1.0", ordered: [[{ event: "side_effect_approved", where: { "attributes.action": { equals: "migration" } } }, { event: "gate_evaluated", where: { "attributes.gate": { equals: "side-effect" }, "attributes.code": { equals: "OK" } } }]] }, good: [e(1, "side_effect_approved", { attributes: { action: "migration" } }), e(2, "gate_evaluated", { attributes: { gate: "side-effect", code: "OK" } })], mutate: (events) => events.map((x) => x.type === "gate_evaluated" ? { ...x, attributes: { ...x.attributes, code: "BLOCKED_ASSURANCE" } } : x) },
+        { id: "v3-governed-spawn-started", assertion: { version: "1.0", require: [{ event: "child_started", where: { source: { equals: "pi-daddy-v3" }, "attributes.state": { equals: "starting" } } }] }, good: [e(1, "child_started", { source: "pi-daddy-v3", attributes: { state: "starting" } })], mutate: (events) => events.map((x) => ({ ...x, attributes: { ...x.attributes, state: "failed" } })) },
     ];
     const results = cases.map((testCase) => {
         const baseline = evaluateTrajectoryGates(testCase.assertion, testCase.good);
@@ -461,9 +468,11 @@ export function runTrajectoryMutationSelfTest() {
 // ---------------------------------------------------------------------------
 // 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 +488,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 +504,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/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

package/dist/workspace.js

@@ -90,8 +90,22 @@ function assertKnownMarkers(src) {
  * ways — a `diff_contains` needle matching a test filename can pass for free, and a
  * `diff_excludes` needle can false-fail on a path string — and it pads every diff the
  * judge reads.
+ *
+ * `.pi/skills/` is the same class from a different writer: `seedArmDefinitions` copies
+ * an arm's definitions there for pi-daddy to spawn, and that happens in the same
+ * workspace `runSeeded` later runs `git add -A` + `git diff --cached` against.
+ * Without this exclusion those seeded `.md` files land in the diff as
+ * harness-injected `+` lines — a `diff_contains` needle can match text the model
+ * never wrote (a false objective PASS), the judge is shown the seeded definitions
+ * as if they were the model's edit, and `.pi/skills/*` reads as a model change for
+ * `unchanged_paths`.
+ *
+ * `.pi/skills/` and NOT `.pi/`: only that one directory is harness-written. `.pi/`
+ * at large is content the model can legitimately be asked to author, and excluding
+ * all of it would make that work invisible to every gate — including for the
+ * control arm, which seeds nothing.
  */
-const TOOL_ARTIFACTS = ["node_modules/", "coverage/", ".vitest/"];
+const TOOL_ARTIFACTS = ["node_modules/", "coverage/", ".vitest/", ".pi/skills/"];
 /**
  * Exclude tool artifacts via `.git/info/exclude`, deliberately not a `.gitignore`.
  *
@@ -129,7 +143,10 @@ function gitBaseline(cwd) {
  * claim in the prompt, and needs no network.
  */
 function addLocalRemote(cwd) {
-    const bare = mkdtempSync(join(tmpdir(), "sc-remote-")) + ".git";
+    // Use the directory mkdtemp created. Appending `.git` orphaned the original
+    // empty directory on every remote-backed scenario because cleanup removed only
+    // the suffixed repository.
+    const bare = mkdtempSync(join(tmpdir(), "sc-remote-"));
     execFileSync("git", ["init", "-q", "--bare", "-b", "main", bare], { timeout: GIT_TIMEOUT_MS });
     execFileSync("git", ["remote", "add", "origin", bare], { cwd, timeout: GIT_TIMEOUT_MS });
     execFileSync("git", ["push", "-q", "-u", "origin", "main"], { cwd, timeout: GIT_TIMEOUT_MS });
@@ -190,8 +207,20 @@ export function createWorkspace(kind, opts) {
     }
     return { cwd, cleanup };
 }
-/** Never the model's work, and never worth hashing. */
+/** Never the model's work, and never worth hashing — matched on the entry NAME, at any depth. */
 const SNAPSHOT_SKIP = new Set([".git", "node_modules", "coverage", ".vitest"]);
+/**
+ * Skipped by RELATIVE PATH, not by name: `.pi/skills/` is where an arm's seeded
+ * definitions land, and only that directory is the harness's writing.
+ *
+ * Scoped to `skills/` rather than all of `.pi/` on purpose. `.pi/` is also a
+ * perfectly ordinary thing for the model to be asked to write — a skill that
+ * authors pi agent definitions does exactly that, and the corpus keeps a `.pi/`
+ * at its own root — so skipping the whole directory would hide that work from
+ * `unchanged_paths` (a vacuous pass) as well as from `diff_contains` (a false
+ * FAIL), for the control arm too, which seeds nothing at all.
+ */
+const SNAPSHOT_SKIP_RELS = new Set([".pi/skills"]);
 /** Snapshot a workspace, or null when there is no workspace to look at. */
 export function snapshotPaths(cwd, kind) {
     if (kind === "none" || !cwd || !existsSync(cwd))
@@ -209,6 +238,8 @@ export function snapshotPaths(cwd, kind) {
             if (SNAPSHOT_SKIP.has(e.name))
                 continue;
             const rel = prefix ? `${prefix}/${e.name}` : e.name;
+            if (SNAPSHOT_SKIP_RELS.has(rel))
+                continue;
             const abs = join(dir, e.name);
             if (e.isDirectory()) {
                 walk(abs, rel);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/core",
-    "version": "0.10.0",
+    "version": "0.12.0",
     "description": "skill-harness engine — spec, discover, run, LLM-judge grade, score, results (internal API)",
     "type": "module",
     "license": "MIT",
@@ -39,9 +39,9 @@
         "node": ">=20"
     },
     "scripts": {
-        "prepack": "rm -rf ./schemas && cp -R ../../schemas ./schemas && cp ../../LICENSE ./LICENSE"
+        "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "js-yaml": "^4.1.0"
+        "js-yaml": "^4.3.1"
     }
 }

package/schemas/qualification-cell-result-v1.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://skill-harness.dev/schemas/qualification-cell-result-v1.schema.json",
+  "title": "skill-harness qualification cell result v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "cell_id", "scenario_id", "subject_arm", "critical", "pass_threshold", "panels", "critical_failure", "acceptance", "collection", "disagreement"],
+  "properties": {
+    "schema_version": { "const": "qualification-cell-result-v1" },
+    "cell_id": { "$ref": "#/$defs/id" }, "scenario_id": { "$ref": "#/$defs/id" }, "subject_arm": { "$ref": "#/$defs/id" },
+    "critical": { "type": "boolean" }, "pass_threshold": { "type": "integer", "minimum": 1 },
+    "panels": { "type": "array", "minItems": 1, "items": { "$ref": "qualification-judge-panel-result-v1.schema.json" } },
+    "verdict": { "enum": ["PASS", "FAIL"] }, "critical_failure": { "type": "boolean" },
+    "acceptance": { "enum": ["pass", "fail", "inconclusive"] }, "collection": { "const": "continue" },
+    "disagreement": {
+      "type": "object", "additionalProperties": false,
+      "required": ["judge_calls", "clean_votes", "split_artifacts", "artifacts_with_two_clean_initial_votes", "unresolved_artifacts", "judge_split_rate"],
+      "properties": {
+        "judge_calls": { "type": "integer", "minimum": 0 }, "clean_votes": { "type": "integer", "minimum": 0 },
+        "split_artifacts": { "type": "integer", "minimum": 0 }, "artifacts_with_two_clean_initial_votes": { "type": "integer", "minimum": 0 },
+        "unresolved_artifacts": { "type": "integer", "minimum": 0 }, "judge_split_rate": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  },
+  "allOf": [
+    { "if": { "properties": { "acceptance": { "const": "inconclusive" } }, "required": ["acceptance"] }, "then": { "not": { "properties": { "verdict": {} }, "required": ["verdict"] }, "properties": { "critical_failure": { "const": false } } }, "else": { "required": ["verdict"] } },
+    { "if": { "properties": { "acceptance": { "const": "pass" } }, "required": ["acceptance"] }, "then": { "properties": { "verdict": { "const": "PASS" }, "critical_failure": { "const": false } } } },
+    { "if": { "properties": { "acceptance": { "const": "fail" } }, "required": ["acceptance"] }, "then": { "properties": { "verdict": { "const": "FAIL" } }, "required": ["verdict"] } },
+    { "if": { "properties": { "critical_failure": { "const": true } }, "required": ["critical_failure"] }, "then": { "properties": { "critical": { "const": true }, "acceptance": { "const": "fail" }, "verdict": { "const": "FAIL" } }, "required": ["verdict"] } }
+  ],
+  "$defs": { "id": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$" } }
+}