@skill-harness/core 0.17.0 → 0.19.0

package/dist/qualification-validation.d.ts

@@ -1,12 +0,0 @@
-/** Canonical final validator: invocation evidence plus panel-board completeness. */
-export declare function validateQualificationRunnerSpool(spoolDir: string): {
-    derived: {
-        panels: number;
-        cells: number;
-    };
-    ok: true;
-    configuration_sha256: string;
-    invocations: number;
-    accounting: import("./qualification-store.js").QualificationAccountingReport;
-    terminal: number;
-};

package/dist/qualification-validation.js

@@ -1,8 +0,0 @@
-import { validateQualificationPanelOutputs } from "./qualification-panel-store.js";
-import { validateQualificationBaseSpool } from "./qualification-runner.js";
-/** Canonical final validator: invocation evidence plus panel-board completeness. */
-export function validateQualificationRunnerSpool(spoolDir) {
-    const base = validateQualificationBaseSpool(spoolDir);
-    return { ...base, derived: validateQualificationPanelOutputs(spoolDir) };
-}
-//# sourceMappingURL=qualification-validation.js.map

package/dist/screen.d.ts

@@ -1,31 +0,0 @@
-import { type ResultsFile } from "./results.js";
-export type ScreenClassification = "CEILING" | "FLOOR" | "INFORMATIVE" | "UNKNOWN";
-export interface ScreenRate {
-    passes: number;
-    n: number;
-}
-export interface ScreenScenario {
-    skill: string;
-    model: string;
-    id: string;
-    control: ScreenRate;
-    treatment: ScreenRate;
-    not_measured: number;
-    classification: ScreenClassification;
-}
-export interface ScreenCriterion {
-    skill: string;
-    model: string;
-    scenario_id: string;
-    criterion: number;
-    failures: number;
-    n: number;
-    fail_rate: number;
-}
-export interface ScreenReport {
-    scenarios: ScreenScenario[];
-    criteria: ScreenCriterion[];
-}
-/** Pure/offline: derive only from v3 retained invocation and vote evidence. */
-export declare function screenResults(results: ResultsFile[]): ScreenReport;
-export declare function formatScreen(report: ScreenReport): string;

package/dist/screen.js

@@ -1,105 +0,0 @@
-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/trajectory-gates.d.ts

@@ -1,137 +0,0 @@
-import { type ArgPredicate, type CountConstraint } from "./trace-gates.js";
-/** Adapter-neutral event contract used by objective trajectory assertions. */
-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;
-    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;
-}
-/**
- * One normalized workflow event. Native field names remain available in
- * `attributes`; common correlation fields are promoted so the evaluator never
- * needs to know whether the source was pi, pi-daddy, or principal assurance.
- */
-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;
-    /** 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;
-    requested_capabilities?: string[];
-    effective_capabilities?: string[];
-    refusal_code?: string;
-    exit_code?: number;
-    digests?: TrajectoryDigests;
-    approval?: TrajectoryApproval;
-    requirements?: string[];
-    attributes?: Record<string, unknown>;
-}
-export interface EventSelector {
-    event: string;
-    where?: Record<string, ArgPredicate>;
-    select?: "first" | "last" | "all";
-}
-export interface RequiredEvent extends EventSelector {
-    count?: CountConstraint;
-}
-export interface CorrelationAssert {
-    left: EventSelector;
-    right: EventSelector;
-    same?: string[];
-    different?: string[];
-    order?: "before" | "after";
-}
-export interface FreshnessAssert {
-    subject: EventSelector;
-    after: EventSelector[];
-    same?: string[];
-}
-export interface UniqueAssert {
-    events: EventSelector;
-    fields: string[];
-}
-export interface ForbidAfterAssert {
-    anchor: EventSelector;
-    forbidden: EventSelector[];
-    same?: string[];
-    anchor_optional?: boolean;
-}
-export interface ApprovalAssert {
-    grant: EventSelector;
-    use: EventSelector;
-    same?: string[];
-    scopes?: string[];
-    sources?: string[];
-    unexpired?: boolean;
-    max_uses?: number;
-}
-export interface CoverageAssert {
-    requirements: string[];
-    events?: EventSelector;
-}
-export interface TrajectoryAssert {
-    version: typeof TRAJECTORY_ASSERT_VERSION;
-    require?: RequiredEvent[];
-    forbid?: EventSelector[];
-    ordered?: EventSelector[][];
-    correlate?: CorrelationAssert[];
-    freshness?: FreshnessAssert[];
-    unique?: UniqueAssert[];
-    forbid_after?: ForbidAfterAssert[];
-    approvals?: ApprovalAssert[];
-    coverage?: CoverageAssert[];
-}
-export type TrajectoryAssertionStatus = "PASS" | "FAIL" | "ERROR";
-export interface TrajectoryAssertionResult {
-    kind: "require_event" | "forbid_event" | "ordered_events" | "correlation" | "freshness" | "unique" | "forbid_after" | "approval" | "coverage" | "evidence";
-    status: TrajectoryAssertionStatus;
-    detail: string;
-}
-export interface TrajectoryGateResult {
-    status: TrajectoryAssertionStatus;
-    event_version: typeof TRAJECTORY_EVENT_VERSION;
-    events_sha256: string;
-    assertions: TrajectoryAssertionResult[];
-}
-export declare function trajectoryEventsSha256(events: TrajectoryEventV1[]): string;
-export declare function serializeTrajectoryEvents(events: TrajectoryEventV1[]): string;
-export declare function deserializeTrajectoryEvents(text: string): TrajectoryEventV1[] | null;
-/** 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;