@skill-harness/cli 0.12.0 → 0.14.0

package/dist/archive-learning.d.ts

@@ -0,0 +1,3 @@
+import type { Args } from './cli.js';
+/** Explicit operator requests, not a scheduler or model route. The inert host cannot invoke this CLI. */
+export declare function cmdArchiveLearning(args: Args): void;

package/dist/archive-learning.js

@@ -0,0 +1,153 @@
+import { constants, openSync, readSync, fstatSync, closeSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { createArchiveAccess, openArchiveAccess, readFixedOrderFacts, createWeeklyInvestigation, openWeeklyInvestigation, createTrustLifecycle, openTrustLifecycle } from '@skill-harness/adapters';
+import { parseLearningRequest } from '@skill-harness/core';
+/** Explicit operator requests, not a scheduler or model route. The inert host cannot invoke this CLI. */
+export function cmdArchiveLearning(args) {
+    if (args._.length !== 1 || Object.keys(args.flags).sort().join() !== 'request,state' || typeof args.flags.state !== 'string' || !isAbsolute(args.flags.state) || typeof args.flags.request !== 'string')
+        throw Error('archive weekly|trust|access requires --state /absolute/directory --request file');
+    const fd = openSync(args.flags.request, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    let text;
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > 65536)
+            throw Error('bounded regular learning request required');
+        const bytes = Buffer.alloc(65537);
+        let n = 0;
+        while (n < bytes.length) {
+            const k = readSync(fd, bytes, n, bytes.length - n, n);
+            if (!k)
+                break;
+            n += k;
+        }
+        if (n > 65536)
+            throw Error('learning request exceeds bound');
+        text = new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, n));
+    }
+    finally {
+        closeSync(fd);
+    }
+    const request = parseLearningRequest(text);
+    if (Object.keys(request).sort().join() !== 'authority,input,operation')
+        throw Error('closed learning request required');
+    const input = request.input, authority = request.authority, state = args.flags.state;
+    let result;
+    if (args._[0] === 'access') {
+        if (request.operation === 'create')
+            result = createArchiveAccess(state, input, authority).inspect();
+        else {
+            const access = openArchiveAccess(state);
+            switch (request.operation) {
+                case 'inspect':
+                    result = access.inspect();
+                    break;
+                case 'preview-consent':
+                    result = access.previewConsent(input);
+                    break;
+                case 'consent': {
+                    const p = input;
+                    result = access.consent(p.grant, authority, p.now);
+                    break;
+                }
+                case 'preview-revocation':
+                    result = access.previewRevocation(input);
+                    break;
+                case 'revoke': {
+                    const p = input;
+                    access.revoke(p.id, authority, p.now);
+                    result = { recorded: true };
+                    break;
+                }
+                case 'facts': {
+                    const p = input;
+                    result = readFixedOrderFacts(access.inspect().policy.archiveRoot, p.manifestId, { directory: state, purpose: p.purpose }, p.expected, p.now);
+                    break;
+                }
+                default: throw Error('unsupported access operation; raw read/export is not a CLI operation');
+            }
+        }
+    }
+    else if (args._[0] === 'weekly') {
+        if (request.operation === 'create') {
+            result = createWeeklyInvestigation(state, input).inspect();
+        }
+        else {
+            const job = openWeeklyInvestigation(state);
+            switch (request.operation) {
+                case 'inspect':
+                    result = job.inspect();
+                    break;
+                case 'run':
+                    result = job.run(request.input);
+                    break;
+                case 'approve':
+                    result = job.approve(authority);
+                    break;
+                case 'preview': {
+                    const p = request.input;
+                    result = job.preview(p.specPath, p.scenario);
+                    break;
+                }
+                case 'promote':
+                    result = job.promote(input, authority);
+                    break;
+                case 'freeze':
+                    result = job.freeze(input, authority);
+                    break;
+                case 'preview-edit':
+                    result = job.previewEdit(input);
+                    break;
+                case 'edit':
+                    result = job.edit(input, authority);
+                    break;
+                case 'evaluation':
+                    result = job.evaluation();
+                    break;
+                case 'preview-screen':
+                    result = job.previewScreen(input);
+                    break;
+                case 'screen':
+                    result = job.screen(input, authority);
+                    break;
+                default: throw Error('unsupported weekly operation');
+            }
+        }
+    }
+    else if (args._[0] === 'trust') {
+        if (request.operation === 'create') {
+            result = createTrustLifecycle(state, input, authority).inspect(0);
+        }
+        else {
+            const job = openTrustLifecycle(state);
+            switch (request.operation) {
+                case 'inspect':
+                    result = job.inspect(input);
+                    break;
+                case 'predict':
+                    job.predict(input);
+                    result = { recorded: true };
+                    break;
+                case 'correct': {
+                    const p = request.input;
+                    job.correct(p.prior, p.prediction, p.reason);
+                    result = { recorded: true };
+                    break;
+                }
+                case 'outcome':
+                    job.outcome(input, authority);
+                    result = { recorded: true };
+                    break;
+                case 'expose': {
+                    const p = request.input;
+                    result = job.expose(p.id, p.now);
+                    break;
+                }
+                default: throw Error('unsupported trust operation');
+            }
+        }
+    }
+    else
+        throw Error('unsupported learning family');
+    console.log(JSON.stringify(result, null, 2));
+}
+//# sourceMappingURL=archive-learning.js.map

package/dist/archive.d.ts

@@ -0,0 +1,3 @@
+import type { Args } from "./cli.js";
+/** Explicit file ingestion/metadata inspection only; never launches a worker or publishes content. */
+export declare function cmdArchive(args: Args): Promise<void>;

package/dist/archive.js

@@ -0,0 +1,52 @@
+import { ingestPolicySource, inspectPolicyCheckpoint, observeArchiveSource } from "@skill-harness/adapters";
+import { cmdArchiveLearning } from "./archive-learning.js";
+/** Explicit file ingestion/metadata inspection only; never launches a worker or publishes content. */
+export async function cmdArchive(args) {
+    const operation = args._[0];
+    if (operation === "weekly" || operation === "trust" || operation === "access") {
+        cmdArchiveLearning(args);
+        return;
+    }
+    if (operation === "watch") {
+        if (args._.length !== 1 || Object.keys(args.flags).some(key => !["policy", "source", "previous", "interval-ms", "max-polls"].includes(key)))
+            throw new Error("unsupported archive watch option");
+        const required = (key) => { const value = args.flags[key]; if (typeof value !== "string" || !value)
+            throw new Error(`archive watch requires --${key}`); return value; };
+        const signal = new AbortController(), abort = () => signal.abort();
+        process.on("SIGINT", abort);
+        process.on("SIGTERM", abort);
+        try {
+            const result = await observeArchiveSource({ policyPath: required("policy"), sourceId: required("source"),
+                previousCheckpointId: args.flags.previous === undefined ? undefined : required("previous"),
+                intervalMs: args.flags["interval-ms"] === undefined ? 1000 : Number(required("interval-ms")), maxPolls: Number(required("max-polls")), signal: signal.signal,
+                onObservation: observation => console.log(JSON.stringify({ checkpointId: observation.checkpointId, policySha256: observation.policySha256, syntax: observation.syntax })),
+            });
+            console.log(JSON.stringify(result));
+        }
+        finally {
+            process.removeListener("SIGINT", abort);
+            process.removeListener("SIGTERM", abort);
+        }
+        return;
+    }
+    if (args._.length !== 1 || !["ingest", "inspect"].includes(operation)) {
+        throw new Error("usage: archive ingest|inspect --policy <file> --source <id> [--previous <checkpoint> | --checkpoint <id>]");
+    }
+    const allowed = operation === "ingest" ? ["policy", "source", "previous"] : ["policy", "source", "checkpoint"];
+    for (const key of Object.keys(args.flags))
+        if (!allowed.includes(key))
+            throw new Error(`unsupported archive option: ${key}`);
+    const required = (key) => {
+        const value = args.flags[key];
+        if (typeof value !== "string" || !value)
+            throw new Error(`archive requires --${key}`);
+        return value;
+    };
+    const policy = required("policy"), source = required("source");
+    const result = operation === "ingest"
+        ? ingestPolicySource(policy, source, args.flags.previous === undefined ? undefined : required("previous"))
+        : inspectPolicyCheckpoint(policy, source, required("checkpoint"));
+    // Successful storage/reporting is not successful work: missing/partial fields are never promoted to acceptance.
+    console.log(JSON.stringify(result, null, 2));
+}
+//# sourceMappingURL=archive.js.map

package/dist/cli.d.ts

@@ -31,7 +31,6 @@ export declare function cmdGrade(args: Args, adapterOverride?: HarnessAdapter):
  * than reconcile two numbers in prose.
  */
 export declare function cmdJudgeAgreement(args: Args): void;
-export declare function cmdMutationTest(): Promise<void>;
 /**
  * Re-evaluate needle gates against the saved staged diffs — no subject call. A rep
  * whose gate verdict flips from fail to pass was never judged and costs one judge call.

package/dist/cli.js

@@ -3,12 +3,12 @@ import { readFileSync, existsSync, mkdirSync, writeFileSync, mkdtempSync, rmSync
 import { load as yamlLoad } from "js-yaml";
 import { basename, dirname, join, resolve, relative } from "node:path";
 import { tmpdir } from "node:os";
-import { discover, resolveSkill, loadSpec, parseSpec, appendScenario, parseModelRef, runSkillModel, formatScorecard, readResults, regradeRun, lintSkill, failsGate, renderTemplateSpec, isTemplateSpec, renderDraftSpec, buildSuggestPrompt, parseSuggestDraft, rescoreRun, regateRun, specPathForRunDir, collectLift, collectStability, boundaryCells, stabilityNote, PATH_LEGEND, restampSkill, resolveAdjudicationJudges, adjudicateRun, judgeResemblesSubject, computeCoverage, formatCoverage, selectAffected, formatAffected, gitDiff, exec, HARNESS_VERSION, defaultJudge, assertJudgeAllowed, judgeAgreement, assertNotDowngraded, downgradeWarning, isScoredMode, runTrajectoryMutationSelfTest, resolveArm, isFreeOfflineCommand, screenResults, formatScreen, } from "@skill-harness/core";
+import { discover, resolveSkill, loadSpec, parseSpec, appendScenario, parseModelRef, runSkillModel, formatScorecard, readResults, regradeRun, lintSkill, failsGate, renderTemplateSpec, isTemplateSpec, renderDraftSpec, buildSuggestPrompt, parseSuggestDraft, rescoreRun, regateRun, specPathForRunDir, collectLift, collectStability, boundaryCells, stabilityNote, PATH_LEGEND, restampSkill, resolveAdjudicationJudges, adjudicateRun, judgeResemblesSubject, computeCoverage, formatCoverage, selectAffected, formatAffected, gitDiff, exec, HARNESS_VERSION, defaultJudge, assertJudgeAllowed, judgeAgreement, assertNotDowngraded, downgradeWarning, isScoredMode, resolveArm, isFreeOfflineCommand, screenResults, formatScreen, } from "@skill-harness/core";
 import { getAdapter } from "@skill-harness/adapters";
 import { serveReview } from "./serve.js";
-import { runSelfScreeningMutationCases } from "./mutation-catalogue.js";
 import { runCompareCommand } from "./compare.js";
 import { cmdQualification } from "./qualification.js";
+import { cmdArchive } from "./archive.js";
 const DEFAULT_MODEL = "fireworks:accounts/fireworks/models/deepseek-v4-pro";
 // The judge default lives in core (`defaultJudge()`), which resolves
 // SKILL_HARNESS_JUDGE over a baked value — it was duplicated in three places
@@ -404,18 +404,6 @@ export function cmdJudgeAgreement(args) {
     console.log(`\njudge agreement: ${report.agree} agree / ${report.disagree} disagree / ${report.error} error; ${report.rate === null ? "n/a" : `${(report.rate * 100).toFixed(1)}%`} across ${report.comparable} comparable scenario(s).`);
     console.log("offline report only; no model or judge calls.");
 }
-export async function cmdMutationTest() {
-    const trajectory = runTrajectoryMutationSelfTest();
-    const report = { baseline: trajectory.baseline, cases: [...trajectory.cases, ...await runSelfScreeningMutationCases()] };
-    console.log(`mutation self-test: baseline ${report.baseline}`);
-    for (const test of report.cases) {
-        console.log(`  ${test.detected ? "✓" : "✗"} ${test.id}: ${test.status} — ${test.detail}`);
-    }
-    const missed = report.cases.filter((test) => !test.detected);
-    console.log(`\n${report.cases.length - missed.length}/${report.cases.length} mutations detected; no model or judge calls.`);
-    if (missed.length)
-        process.exitCode = 1;
-}
 async function cmdRescore(args) {
     const runDirs = args._;
     if (runDirs.length === 0)
@@ -906,7 +894,9 @@ export function help() {
                      [--auto-rejudge] [--secondary-judge p:m] [--tie-break-judge p:m]
                        ask again about untrustworthy cells (ambiguous / contradictory / non-unanimous /
                        ship-deciding). OFF by default; prints the exact MAX extra call count first.
-  mutation-test                                  prove trajectory + results/delivery/screen gates turn red (${free("mutation-test")})
+  archive ingest|inspect|watch --policy file --source id  explicit external ingestion/metadata (${free("archive")})
+  archive weekly|trust|access --state /private/dir --request file  durable learning/consent lifecycle (${free("archive")})
+                        watch requires --max-polls N; optional --interval-ms N and --previous checkpoint
   judge-agreement <run-dir>                      compare two distinct persisted judge votes per scenario (${free("judge-agreement")})
   rescore <run-dir>...                          re-score saved reps vs current spec thresholds (${free("rescore")})
   regate <run-dir>...  [--judge prov:model]     re-evaluate saved gates (no subject call; judges fail→pass reps)
@@ -943,7 +933,7 @@ export async function main(argv) {
         case "run": return cmdRun(args);
         case "compare": return cmdCompare(args);
         case "grade": return cmdGrade(args);
-        case "mutation-test": return cmdMutationTest();
+        case "archive": return cmdArchive(args);
         case "judge-agreement": return cmdJudgeAgreement(args);
         case "rescore": return cmdRescore(args);
         case "regate": return cmdRegate(args);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/cli",
-    "version": "0.12.0",
+    "version": "0.14.0",
     "description": "skill-harness CLI — run, grade, review, and lint agent-skill scenarios on the pi harness",
     "type": "module",
     "license": "MIT",
@@ -44,7 +44,7 @@
         "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "@skill-harness/core": "0.12.0",
-        "@skill-harness/adapters": "0.12.0"
+        "@skill-harness/core": "0.14.0",
+        "@skill-harness/adapters": "0.14.0"
     }
 }

package/dist/mutation-catalogue.d.ts

@@ -1,8 +0,0 @@
-export interface PermanentMutationCase {
-    id: string;
-    detected: boolean;
-    status: "FAIL" | "ERROR";
-    detail: string;
-}
-/** Permanent non-trajectory mutation cases exercised by the free mutation-test command. */
-export declare function runSelfScreeningMutationCases(): Promise<PermanentMutationCase[]>;

package/dist/mutation-catalogue.js

@@ -1,95 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseSpec, planAdjudication, runSkillModel, screenResults, validateResults, } from "@skill-harness/core";
-import { authenticatePromptObservation, bindPromptObservation, normalizePromptPayload, observeProviderPayload, promptCaptureIsTrusted, } from "@skill-harness/adapters";
-const h = "a".repeat(64);
-const deliveryAssertion = (status = "PASS") => ({ kind: "skill_delivered", status, detail: status });
-function validV3() {
-    return {
-        schema: 3, skill: "mutation", harness: "pi", model: "fake:m", judge: { provider: "fake", model: "j" },
-        timestamp: "t", label: null, mode: "force", effective_grade: { passed: 1, total: 1, pct: 100, letter: "A", ship: true, note: "" },
-        subject_invocations: [{ scenario_id: "A1", repetition: 0, prompt: { capture_version: "prompt-provenance-v1", request_index: 0, raw_sha256: h, normalized_sha256: h, normalization_rule: "cwd-line-v1", bytes: 1, contract_sha256: h, contract_bytes: 1, contract_occurrences: 1, mechanism: "append-system-prompt", status: "PASS" } }],
-        scenarios: [{ id: "A1", criterion_count: 1, judge_verdict: "PASS", judge_reason: "ok", suspect: false, override: null, note: "", objective: { status: "PASS", assertions: [deliveryAssertion()] }, rep_judgments: [{ repetition: 0, recorded_verdict: "PASS", objective: { status: "PASS", assertions: [deliveryAssertion()] }, judgments: [{ ordinal: 1, judge: { provider: "fake", model: "j" }, verdict: "PASS", reason: "ok", suspect: false, criteria: [{ index: 1, verdict: "PASS", reason: "ok" }] }] }] }],
-    };
-}
-function catches(id, mutate, detail) {
-    const result = structuredClone(validV3());
-    mutate(result);
-    let detected = false;
-    try {
-        validateResults(result);
-    }
-    catch {
-        detected = true;
-    }
-    return { id, detected, status: detected ? "FAIL" : "ERROR", detail };
-}
-function screenFile(id, verdicts) {
-    const result = validV3();
-    result.scenarios[0].id = id;
-    result.scenarios[0].reps = verdicts.length;
-    result.subject_invocations = verdicts.map((_, repetition) => ({ ...structuredClone(result.subject_invocations[0]), scenario_id: id, repetition }));
-    result.scenarios[0].rep_judgments = verdicts.map((verdict, repetition) => ({ repetition, recorded_verdict: verdict, objective: { status: "PASS", assertions: [deliveryAssertion()] }, judgments: [{ ordinal: 1, judge: { provider: "fake", model: "j" }, verdict, reason: verdict, suspect: false, criteria: [{ index: 1, verdict, reason: verdict }] }] }));
-    return result;
-}
-async function objectiveSuppressesJudge() {
-    const dir = mkdtempSync(join(tmpdir(), "skill-harness-mutation-delivery-"));
-    let judgeCalls = 0;
-    try {
-        mkdirSync(join(dir, "tests"), { recursive: true });
-        writeFileSync(join(dir, "SKILL.md"), "---\nname: mutation\ndescription: fixture\n---\n\n## Contract\nDo it.\n", "utf8");
-        const specPath = join(dir, "tests/specification.yaml");
-        writeFileSync(specPath, "skill: mutation\njudge_persona: strict\nship_bar: { total: 1, min_pass: 1, no_critical_fail: true }\ncritical: []\nscenarios:\n  - id: A1\n    title: delivery\n    turns: [hi]\n    checklist: [does it]\n", "utf8");
-        const spec = parseSpec(readFileSync(specPath, "utf8"), specPath);
-        const adapter = {
-            name: "pi", observesPrompts: true, available: async () => true,
-            run: async (req) => { req.onPromptObservation?.({ capture_version: "prompt-provenance-v1", request_index: 0, raw_sha256: h, normalized_sha256: h, normalization_rule: "cwd-line-v1", bytes: 1, contract_sha256: h, contract_bytes: 1, contract_occurrences: 0, mechanism: "append-system-prompt", status: "NOT-MEASURED" }); return ">>> USER:\nhi\n\n<<< ASSISTANT:\nanswer\n"; },
-            judge: async () => { judgeCalls++; return "VERDICT: PASS\nREASON: wrong"; },
-        };
-        const out = await runSkillModel({ spec, skillDir: dir, specPath, adapter, model: { provider: "fake", model: "m" }, modelToken: "fake:m", judge: { provider: "fake-judge", model: "j" }, mode: "force", timestamp: "2026-09-04T01:00:00.000Z" });
-        const detected = judgeCalls === 0 && out.results.scenarios[0].judge_verdict === "NOT-MEASURED" && out.results.effective_grade.total === 0;
-        return { id: "delivery-objective-suppresses-judge", detected, status: detected ? "FAIL" : "ERROR", detail: "undelivered subject must never reach the judge or efficacy denominator" };
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-/** Permanent non-trajectory mutation cases exercised by the free mutation-test command. */
-export async function runSelfScreeningMutationCases() {
-    const contract = "## Contract\nDo it\n";
-    const one = observeProviderPayload({ instructions: contract }, contract, "append-system-prompt", 0);
-    const forged = { ...one, contract_sha256: "f".repeat(64) };
-    const ceiling = screenFile("C", ["PASS", "PASS", "PASS", "PASS", "FAIL"]);
-    for (const observation of ceiling.subject_invocations)
-        observation.prompt = { ...observation.prompt, mechanism: "none", contract_occurrences: 0, status: "PASS" };
-    const undelivered = screenFile("U", ["PASS", "PASS"]);
-    undelivered.subject_invocations[1].prompt = { ...undelivered.subject_invocations[1].prompt, contract_occurrences: 0, status: "NOT-MEASURED" };
-    const suspect = screenFile("S", ["PASS"]);
-    suspect.scenarios[0].rep_judgments[0].judgments[0].suspect = true;
-    const cases = [
-        catches("schema-v3-missing-observation-rejected", r => { delete r.subject_invocations; }, "schema v3 must reject missing delivery evidence"),
-        catches("schema-v3-panel-divergence-rejected", r => { r.scenarios[0].rep_judgments[0].recorded_verdict = "FAIL"; }, "stored panel result must equal recomputed clean votes"),
-        catches("schema-v3-missing-criterion-rejected", r => { r.scenarios[0].rep_judgments[0].judgments[0].criteria.pop(); }, "criterion omissions must remain explicit"),
-        catches("schema-v3-per-repetition-objective-rejected", r => { delete r.scenarios[0].rep_judgments[0].objective; }, "aggregate objective cannot hide a repetition"),
-        catches("schema-v3-top-level-verdict-rejected", r => { const panel = r.scenarios[0].rep_judgments[0]; panel.judgments[0].verdict = "FAIL"; panel.judgments[0].criteria = panel.judgments[0].criteria.map(vote => ({ ...vote, verdict: "FAIL" })); panel.recorded_verdict = "FAIL"; }, "top-level verdict must match retained repetition evidence"),
-        catches("schema-v3-unsupported-pass-rejected", r => { r.scenarios[0].rep_judgments[0].judgments = []; }, "behavioral PASS requires a retained clean judgment"),
-        catches("schema-v3-adjudication-state-rejected", r => { const primary = r.scenarios[0].rep_judgments[0].judgments[0]; r.scenarios[0].adjudication = { repetition: 0, trigger: "ship_deciding", state: "unresolved", judgments: [primary, { ...structuredClone(primary), ordinal: 2 }] }; }, "adjudication state and verdict must match clean votes"),
-        { id: "delivery-zero-not-measured", detected: observeProviderPayload({ instructions: "none" }, contract, "append-system-prompt", 0).status === "NOT-MEASURED", status: "FAIL", detail: "zero delivery is not product failure" },
-        { id: "delivery-duplicate-not-measured", detected: observeProviderPayload({ instructions: contract + contract }, contract, "append-system-prompt", 0).status === "NOT-MEASURED", status: "FAIL", detail: "duplicate delivery is not valid measurement" },
-        { id: "delivery-unobservable-error", detected: observeProviderPayload({}, contract, "append-system-prompt", 0).status === "ERROR", status: "FAIL", detail: "unsupported payload is instrument error" },
-        await objectiveSuppressesJudge(),
-        { id: "delivery-error-suppresses-adjudication", detected: planAdjudication({ cells: [{ id: "A1", verdict: "ERROR", reason: "instrument", suspect: false, deliveryStatus: "ERROR" }], scenarios: [{ id: "A1", title: "A1", critical: false, mode: "inline", turns: ["x"], checklist: ["y"], workspace: "none", remote: false }], shipBar: { total: 1, min_pass: 1, no_critical_fail: true }, critical: [], tieBreakAvailable: true }).maxAdditionalCalls === 0, status: "FAIL", detail: "instrument delivery ERROR cannot authorize adjudication spend" },
-        { id: "observer-normalization-scope", detected: JSON.stringify(normalizePromptPayload({ instructions: "Keep /a\nCurrent working directory: /a\nKeep /a" }, "cwd-line-v1")) === JSON.stringify({ instructions: "Keep /a\nCurrent working directory:<normalized>\nKeep /a" }), status: "FAIL", detail: "normalization changes only the cwd line" },
-        { id: "observer-contract-binding", detected: bindPromptObservation(authenticatePromptObservation(forged, "key"), contract, "append-system-prompt", 0, "key").status === "ERROR", status: "FAIL", detail: "child contract identity cannot replace parent binding" },
-        { id: "observer-mac-tamper-rejected", detected: bindPromptObservation({ ...authenticatePromptObservation(one, "key"), mac: "0".repeat(64) }, contract, "append-system-prompt", 0, "key").status === "ERROR", status: "FAIL", detail: "complete child observation requires parent authentication" },
-        { id: "observer-extension-forgery-rejected", detected: !promptCaptureIsTrusted(1), status: "FAIL", detail: "same-process subject extensions cannot produce trusted provenance" },
-        { id: "observer-argv-wiring", detected: promptCaptureIsTrusted(0) && !promptCaptureIsTrusted(1), status: "FAIL", detail: "observer is enabled only on the authenticated extension-free path" },
-        { id: "screen-ceiling-boundary", detected: screenResults([ceiling]).scenarios[0].classification === "CEILING", status: "FAIL", detail: "four of five control passes is CEILING" },
-        { id: "screen-undelivered-filter", detected: (() => { const row = screenResults([undelivered]).scenarios[0]; return row.treatment.n === 1 && row.not_measured === 1; })(), status: "FAIL", detail: "undelivered reps have a bucket outside efficacy" },
-        { id: "screen-suspect-filter", detected: screenResults([suspect]).scenarios[0].control.n === 0, status: "FAIL", detail: "suspect-only panels do not enter rates" },
-        { id: "screen-unsupported-pass-filter", detected: (() => { const unsupported = screenFile("P", ["PASS"]); unsupported.scenarios[0].rep_judgments[0].judgments = []; return screenResults([unsupported]).scenarios[0].control.n === 0; })(), status: "FAIL", detail: "recorded PASS without a clean vote does not enter efficacy" },
-    ];
-    return cases.map(test => ({ ...test, status: test.detected ? "FAIL" : "ERROR" }));
-}
-//# sourceMappingURL=mutation-catalogue.js.map