@skill-harness/core 0.17.0 → 0.18.0

package/dist/trusted-host-supervision.js

@@ -1,94 +0,0 @@
-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/work-capture-schema.d.ts

@@ -1,38 +0,0 @@
-export declare const WORK_CAPTURE_SCHEMA: {
-    oneOf: ({
-        properties: {
-            reason: {
-                const: string;
-            };
-            classification: {
-                const: string;
-            };
-            metrics: {
-                required: string[];
-            };
-        };
-    } | {
-        properties: {
-            reason: {
-                const: string;
-            };
-            classification: {
-                const: string;
-            };
-            metrics?: undefined;
-        };
-    })[];
-    type: string;
-    properties: Record<string, object>;
-    required: string[];
-    additionalProperties: boolean;
-    $schema: string;
-    $id: string;
-};
-export declare const WORK_CASE_REVIEW_REQUEST_SCHEMA: {
-    type: string;
-    properties: Record<string, object>;
-    required: string[];
-    additionalProperties: boolean;
-    $schema: string;
-};

package/dist/work-capture-schema.js

@@ -1,33 +0,0 @@
-const text = { type: "string", minLength: 1, maxLength: 512, pattern: "^[^\\u0000-\\u001f\\u007f]+$" };
-const hash = { type: "string", pattern: "^[a-f0-9]{64}$" };
-const closed = (properties, required = Object.keys(properties)) => ({ type: "object", properties, required, additionalProperties: false });
-const evidence = { type: "array", items: hash, minItems: 1, maxItems: 256, uniqueItems: true };
-const metric = { type: "number", minimum: 0 };
-function freeze(value) { if (value && typeof value === "object") {
-    Object.values(value).forEach(freeze);
-    Object.freeze(value);
-} return value; }
-export const WORK_CAPTURE_SCHEMA = freeze({
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://github.com/mojomanyana/skill-harness/contracts/work-capture/v2/work-case.schema.json",
-    ...closed({ capture_schema: { const: 2 }, id: hash,
-        detector: closed({ id: text, version: text, population: text }),
-        target: closed({ kind: { const: "work" }, snapshotDigest: hash, obligationId: text, obligationDigest: hash }),
-        classification: { enum: ["candidate_defect", "candidate_exemplar", "coverage_issue"] },
-        reason: { enum: ["repeat_without_progress", "economical_exemplar", "coverage_gap"] }, evidence,
-        metrics: closed({ equivalentAttempts: { type: "integer", minimum: 2, maximum: Number.MAX_SAFE_INTEGER }, measuredCost: metric,
-            costLimit: metric, costUnit: { enum: ["wall_ms", "tool_calls", "usd"] } }, []),
-        status: { const: "unresolved" }, visibility: { const: "silent" }, causalAttribution: { const: "not-established" },
-    }),
-    oneOf: [
-        { properties: { reason: { const: "repeat_without_progress" }, classification: { const: "candidate_defect" }, metrics: { required: ["equivalentAttempts"] } } },
-        { properties: { reason: { const: "economical_exemplar" }, classification: { const: "candidate_exemplar" }, metrics: { required: ["measuredCost", "costLimit", "costUnit"] } } },
-        { properties: { reason: { const: "coverage_gap" }, classification: { const: "coverage_issue" } } },
-    ],
-});
-export const WORK_CASE_REVIEW_REQUEST_SCHEMA = freeze({
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    ...closed({ caseManifestId: hash, priorDecisionId: { anyOf: [hash, { type: "null" }] },
-        disposition: { enum: ["confirmed_defect", "expected_behavior", "exemplar", "uncertain", "skip"] }, note: { type: "string", maxLength: 4000 } }),
-});
-//# sourceMappingURL=work-capture-schema.js.map

package/dist/work-capture.d.ts

@@ -1,43 +0,0 @@
-/** Separate from human-authored capture_schema1; a nomination is not a test, verdict or promotion. */
-export interface WorkCaptureCaseV2 {
-    capture_schema: 2;
-    id: string;
-    detector: {
-        id: string;
-        version: string;
-        population: string;
-    };
-    target: {
-        kind: "work";
-        snapshotDigest: string;
-        obligationId: string;
-        obligationDigest: string;
-    };
-    classification: "candidate_defect" | "candidate_exemplar" | "coverage_issue";
-    reason: "repeat_without_progress" | "economical_exemplar" | "coverage_gap";
-    evidence: string[];
-    metrics: {
-        equivalentAttempts?: number;
-        measuredCost?: number;
-        costLimit?: number;
-        costUnit?: "wall_ms" | "tool_calls" | "usd";
-    };
-    status: "unresolved";
-    visibility: "silent";
-    causalAttribution: "not-established";
-}
-export type WorkCaseDisposition = "confirmed_defect" | "expected_behavior" | "exemplar" | "uncertain" | "skip";
-export interface WorkCaseDecision {
-    decision_schema: 1;
-    id: string;
-    caseId: string;
-    priorDecisionId: string | null;
-    disposition: WorkCaseDisposition;
-    /** Attributable controller-supplied author, never filled from a nominator's hypothesis. */
-    author: string;
-    evidence: string[];
-    note: string;
-}
-export declare function buildWorkCapture(input: Omit<WorkCaptureCaseV2, "capture_schema" | "id" | "status" | "visibility" | "causalAttribution">): WorkCaptureCaseV2;
-/** Immutable correction chain. Calling code must establish the registered case and authorized author. */
-export declare function appendWorkCaseDecision(history: readonly WorkCaseDecision[], input: Omit<WorkCaseDecision, "decision_schema" | "id">): WorkCaseDecision[];

package/dist/work-capture.js

@@ -1,81 +0,0 @@
-import { createHash } from "node:crypto";
-const canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(",")}]`
-    : value !== null && typeof value === "object" ? `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`
-        : JSON.stringify(value);
-const sha = (value) => createHash("sha256").update(canonical(value)).digest("hex");
-function closed(value, names) {
-    if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
-        return false;
-    const fields = Object.getOwnPropertyDescriptors(value);
-    return Reflect.ownKeys(fields).length === names.length && Reflect.ownKeys(fields).every(key => typeof key === "string" && names.includes(key) && fields[key].enumerable && Object.hasOwn(fields[key], "value"));
-}
-const hash = /^[a-f0-9]{64}$/;
-const text = (s) => typeof s === "string" && s.length > 0 && s.length <= 512 && !/[\u0000-\u001f\u007f]/.test(s);
-export function buildWorkCapture(input) {
-    if (!closed(input, ["detector", "target", "classification", "reason", "evidence", "metrics"])
-        || !closed(input.detector, ["id", "version", "population"]) || !closed(input.target, ["kind", "snapshotDigest", "obligationId", "obligationDigest"])
-        || !input.metrics || typeof input.metrics !== "object" || !closed(input.metrics, Object.keys(input.metrics))
-        || !Array.isArray(input.evidence) || input.evidence.length < 1 || input.evidence.length > 256
-        || Array.from({ length: input.evidence.length }, (_, i) => i).some(i => !Object.hasOwn(input.evidence, i)))
-        throw new Error("invalid work capture fields");
-    if (![input.detector.id, input.detector.version, input.detector.population, input.target.obligationId].every(text)
-        || input.target.kind !== "work" || !hash.test(input.target.snapshotDigest) || !hash.test(input.target.obligationDigest)
-        || input.evidence.length > 256 || input.evidence.some(e => !hash.test(e))
-        || !["candidate_defect", "candidate_exemplar", "coverage_issue"].includes(input.classification)
-        || !["repeat_without_progress", "economical_exemplar", "coverage_gap"].includes(input.reason)
-        || Object.keys(input.metrics).some(k => !["equivalentAttempts", "measuredCost", "costLimit", "costUnit"].includes(k))
-        || Object.entries(input.metrics).some(([key, n]) => key === "costUnit" ? !["wall_ms", "tool_calls", "usd"].includes(String(n)) : typeof n !== "number" || !Number.isFinite(n) || n < 0)
-        || (input.reason === "repeat_without_progress" && (input.metrics.equivalentAttempts === undefined || input.metrics.equivalentAttempts < 2))
-        || (input.reason === "economical_exemplar" && (input.metrics.measuredCost === undefined || input.metrics.costLimit === undefined || input.metrics.costUnit === undefined || input.metrics.measuredCost > input.metrics.costLimit))
-        || (input.metrics.equivalentAttempts !== undefined && !Number.isSafeInteger(input.metrics.equivalentAttempts)))
-        throw new Error("invalid work capture nomination");
-    const expected = { repeat_without_progress: "candidate_defect", economical_exemplar: "candidate_exemplar", coverage_gap: "coverage_issue" };
-    if (input.classification !== expected[input.reason])
-        throw new Error("work capture classification mismatch");
-    const detector = { id: input.detector.id, version: input.detector.version, population: input.detector.population };
-    const target = { kind: "work", snapshotDigest: input.target.snapshotDigest, obligationId: input.target.obligationId, obligationDigest: input.target.obligationDigest };
-    return { capture_schema: 2, id: sha({ detector, target, reason: input.reason }), detector, target,
-        classification: input.classification, reason: input.reason, evidence: [...new Set(input.evidence)].sort(), metrics: Object.fromEntries(Object.entries(input.metrics).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)),
-        status: "unresolved", visibility: "silent", causalAttribution: "not-established" };
-}
-function validDecision(value) {
-    return closed(value, ["caseId", "priorDecisionId", "disposition", "author", "evidence", "note"])
-        && typeof value.caseId === "string" && hash.test(value.caseId)
-        && (value.priorDecisionId === null || (typeof value.priorDecisionId === "string" && hash.test(value.priorDecisionId)))
-        && text(value.author) && typeof value.note === "string" && value.note.length <= 4000
-        && Array.isArray(value.evidence) && value.evidence.length <= 256
-        && Array.from({ length: value.evidence.length }, (_, i) => i).every(i => Object.hasOwn(value.evidence, i) && typeof value.evidence[i] === "string" && hash.test(value.evidence[i]))
-        && ["confirmed_defect", "expected_behavior", "exemplar", "uncertain", "skip"].includes(value.disposition);
-}
-/** Immutable correction chain. Calling code must establish the registered case and authorized author. */
-export function appendWorkCaseDecision(history, input) {
-    if (!validDecision(input))
-        throw new Error("invalid case decision");
-    if (history.length > 4096)
-        throw new Error("case decision history exceeds bound");
-    const heads = new Map();
-    const seen = new Set();
-    for (const decision of history) {
-        if (!closed(decision, ["decision_schema", "id", "caseId", "priorDecisionId", "disposition", "author", "evidence", "note"]) || decision.decision_schema !== 1)
-            throw new Error("invalid case decision history");
-        const { decision_schema: _schema, id: recordedId, ...prior } = decision;
-        if (!validDecision(prior) || sha(prior) !== recordedId)
-            throw new Error("case decision history identity mismatch");
-        if (seen.has(recordedId))
-            continue;
-        if ((heads.get(decision.caseId) ?? null) !== decision.priorDecisionId)
-            throw new Error("case decision history fork or missing parent");
-        seen.add(recordedId);
-        heads.set(decision.caseId, recordedId);
-    }
-    const body = { ...input, evidence: [...new Set(input.evidence)].sort() };
-    const id = sha(body);
-    if (history.some(d => d.id === id))
-        return [...history];
-    const own = history.filter(d => d.caseId === input.caseId);
-    const last = own.at(-1)?.id ?? null;
-    if (last !== input.priorDecisionId)
-        throw new Error("stale case decision");
-    return [...history, { decision_schema: 1, id, ...body }];
-}
-//# sourceMappingURL=work-capture.js.map

package/dist/work-signals.d.ts

@@ -1,55 +0,0 @@
-import { type WorkCaptureCaseV2 } from "./work-capture.js";
-export interface WorkSignalSnapshot {
-    snapshotDigest: string;
-    scopeValid: boolean;
-    obligations: Array<{
-        id: string;
-        digest: string;
-        intentDigest: string;
-        policyDigest: string;
-        artifactDigest: string | null;
-        acceptance: "accepted-under-supplied-authority" | "unaccepted" | "unresolved";
-        coverage: "available" | "unknown" | "unavailable" | "conflicted";
-    }>;
-}
-export interface WorkSignalFacts {
-    scopeDigest: string;
-    version: string;
-    population: string;
-    expectedWaits: string[];
-    /** Frozen host facts, not inferred from absence in a display or from worker prose. */
-    checkpoints: Array<{
-        obligationDigest: string;
-        deadlineMs: number;
-        observedAt: number;
-        status: "met" | "pending" | "unknown";
-        evidence: string;
-    }>;
-    violations: Array<{
-        obligationDigest: string;
-        status: "FAIL" | "ERROR";
-        evidence: string;
-    }>;
-    priorAccepted: Array<{
-        obligationDigest: string;
-        intentDigest: string;
-        policyDigest: string;
-        artifactDigest: string;
-        acceptanceEvidence: string;
-    }>;
-}
-export interface WorkCaptureCaseV3 extends Omit<WorkCaptureCaseV2, "capture_schema" | "reason" | "metrics"> {
-    capture_schema: 3;
-    reason: "overdue_checkpoint" | "reopened_acceptance" | "intent_conflict";
-    metrics: {
-        deadlineMs?: number;
-        observedAt?: number;
-        failedChecks?: number;
-    };
-}
-/** Additional rules use an explicit new case version; the already-pinned capture_schema2 contract is unchanged. */
-export declare function detectAdditionalWorkCases(snapshot: WorkSignalSnapshot, facts: WorkSignalFacts): {
-    version: "work-signals-v1";
-    cases: (WorkCaptureCaseV2 | WorkCaptureCaseV3)[];
-    issues: string[];
-};

package/dist/work-signals.js

@@ -1,71 +0,0 @@
-import { createHash } from "node:crypto";
-import { buildWorkCapture } from "./work-capture.js";
-const hash = (x) => typeof x === "string" && /^[a-f0-9]{64}$/.test(x);
-const text = (x) => typeof x === "string" && x.length > 0 && x.length <= 512 && !/[\u0000-\u001f\u007f]/.test(x);
-function signal(base, reason, metrics, evidence) {
-    const target = base.target, detector = { id: reason, version: base.detector.version, population: base.detector.population };
-    const id = createHash("sha256").update(JSON.stringify({ capture_schema: 3, detector, target, reason, metrics, evidence: [...new Set(evidence)].sort() })).digest("hex");
-    return Object.freeze({ ...base, capture_schema: 3, id, detector: Object.freeze(detector), reason, classification: "candidate_defect", metrics: Object.freeze(metrics), evidence: Object.freeze([...new Set(evidence)].sort()) });
-}
-/** Additional rules use an explicit new case version; the already-pinned capture_schema2 contract is unchanged. */
-export function detectAdditionalWorkCases(snapshot, facts) {
-    if (!hash(snapshot.snapshotDigest) || !hash(facts.scopeDigest) || snapshot.snapshotDigest !== facts.scopeDigest)
-        throw new Error("work signal scope mismatch");
-    if (!text(facts.version) || facts.version.length > 128 || !text(facts.population) || !Array.isArray(snapshot.obligations) || snapshot.obligations.length > 256
-        || ![facts.expectedWaits, facts.checkpoints, facts.violations, facts.priorAccepted].every(a => Array.isArray(a) && a.length <= 256)
-        || facts.expectedWaits.some(d => !hash(d)))
-        throw new Error("invalid work signal bounds");
-    for (const o of snapshot.obligations)
-        if (!text(o.id) || ![o.digest, o.intentDigest, o.policyDigest].every(hash) || !(o.artifactDigest === null || hash(o.artifactDigest))
-            || !["accepted-under-supplied-authority", "unaccepted", "unresolved"].includes(o.acceptance) || !["available", "unknown", "unavailable", "conflicted"].includes(o.coverage))
-            throw new Error("invalid work signal obligation");
-    for (const c of facts.checkpoints)
-        if (!hash(c.obligationDigest) || !hash(c.evidence) || !["met", "pending", "unknown"].includes(c.status)
-            || ![c.deadlineMs, c.observedAt].every(n => Number.isSafeInteger(n) && n >= 0))
-            throw new Error("invalid declared checkpoint fact");
-    for (const v of facts.violations)
-        if (!hash(v.obligationDigest) || !hash(v.evidence) || !["FAIL", "ERROR"].includes(v.status))
-            throw new Error("invalid objective intent fact");
-    for (const p of facts.priorAccepted)
-        if (![p.obligationDigest, p.intentDigest, p.policyDigest, p.artifactDigest, p.acceptanceEvidence].every(hash))
-            throw new Error("invalid prior acceptance fact");
-    const cases = [];
-    if (snapshot.scopeValid !== true)
-        return { version: "work-signals-v1", cases, issues: ["scope-unresolved"] };
-    for (const o of snapshot.obligations) {
-        const base = buildWorkCapture({ detector: { id: "coverage_gap", version: `work-signals-v1:${facts.version}`, population: facts.population },
-            target: { kind: "work", snapshotDigest: snapshot.snapshotDigest, obligationId: o.id, obligationDigest: o.digest },
-            classification: "coverage_issue", reason: "coverage_gap", metrics: {}, evidence: [snapshot.snapshotDigest, o.digest] });
-        const violations = facts.violations.filter(v => v.obligationDigest === o.digest);
-        const checkpointFacts = facts.checkpoints.filter(c => c.obligationDigest === o.digest);
-        const checkpointStates = new Set(checkpointFacts.map(c => JSON.stringify([c.deadlineMs, c.observedAt, c.status, c.evidence])));
-        if (checkpointStates.size > 1) {
-            cases.push(base);
-            continue;
-        } // No latest-timestamp election from contradictory host facts.
-        if (o.coverage !== "available" || o.acceptance === "unresolved" || violations.some(v => v.status === "ERROR")) {
-            cases.push(base);
-            continue;
-        }
-        if (violations.length)
-            cases.push(signal(base, "intent_conflict", { failedChecks: violations.length }, [...base.evidence, ...violations.map(v => v.evidence)]));
-        if (facts.expectedWaits.includes(o.digest))
-            continue;
-        for (const c of checkpointFacts) {
-            if (c.status === "unknown") {
-                cases.push(base);
-                continue;
-            }
-            if (c.status === "pending" && c.observedAt > c.deadlineMs)
-                cases.push(signal(base, "overdue_checkpoint", { deadlineMs: c.deadlineMs, observedAt: c.observedAt }, [...base.evidence, c.evidence]));
-        }
-        if (o.acceptance === "unaccepted") {
-            const prior = facts.priorAccepted.filter(p => p.obligationDigest === o.digest && p.intentDigest === o.intentDigest && p.policyDigest === o.policyDigest && p.artifactDigest === o.artifactDigest);
-            if (prior.length)
-                cases.push(signal(base, "reopened_acceptance", {}, [...base.evidence, ...prior.map(p => p.acceptanceEvidence)]));
-        }
-    }
-    const unique = [...new Map(cases.map(c => [c.id, c])).values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    return { version: "work-signals-v1", cases: unique, issues: [] };
-}
-//# sourceMappingURL=work-signals.js.map

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

@@ -1,32 +0,0 @@
-{
-  "$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}$" } }
-}