project-tiny-context-harness 0.2.85 → 0.6.0

package/dist/lib/long-task-delivery-preflight.js

@@ -0,0 +1,151 @@
+import { readFile, stat } from "node:fs/promises";
+import { validateCounterfactualBindingClaims, validateGlobalCounterfactualBindingClaims, } from "./long-task-counterfactual-claim-policy.js";
+import { assertRepositoryPattern, matchesRepoPattern, proveRepositoryPatternSubset, repositoryPatternsMayOverlap, } from "./long-task-paths.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
+export function validateVerificationInputSeparation(contract, checks, workdirRelative) {
+    const implementation = contract.outcomes.flatMap((outcome) => [
+        ...outcome.technical.expected_change_paths,
+        ...outcome.technical.allowed_support_paths,
+    ]);
+    for (const check of checks)
+        for (const source of Object.keys(check.verification_input_hashes)) {
+            if (implementation.some((pattern) => repositoryPatternsMayOverlap(pattern, source)))
+                throw new Error(`verification_input_overlaps_implementation:${check.key}:${source}`);
+            if (source === workdirRelative ||
+                source.startsWith(`${workdirRelative}/`) ||
+                source === ".git" ||
+                source.startsWith(".git/") ||
+                source.split("/").includes("node_modules") ||
+                check.artifact_globs.some((artifact) => repositoryPatternsMayOverlap(artifact, source)))
+                throw new Error(`verification_input_protected:${check.key}:${source}`);
+        }
+}
+export function validateTechnicalPaths(contract, repository, workdirRelative, baseline) {
+    const forbidden = [
+        ...contract.global.technical.forbidden_paths.map((entry) => entry.path),
+        ...contract.outcomes.flatMap((outcome) => outcome.technical.forbidden_paths),
+    ].map((pattern, index) => assertRepositoryPattern(repository, pattern, `forbidden_paths[${index}]`));
+    for (const outcome of contract.outcomes) {
+        const allowed = [
+            ...outcome.technical.expected_change_paths,
+            ...outcome.technical.allowed_support_paths,
+        ].map((pattern, index) => assertRepositoryPattern(repository, pattern, `${outcome.key}.allowed_paths[${index}]`));
+        for (const pattern of allowed) {
+            if (repositoryPatternsMayOverlap(pattern, workdirRelative))
+                throw new Error(`protected_path_declared:long_task_workdir:${pattern}`);
+            if (forbidden.some((blocked) => repositoryPatternsMayOverlap(pattern, blocked)))
+                throw new Error(`allowed_forbidden_path_overlap:${pattern}`);
+        }
+        for (const binding of outcome.technical.bindings) {
+            const carriers = binding.carrier_paths.map((carrier) => assertRepositoryPattern(repository, carrier, `${outcome.key}.${binding.key}.carrier_path`));
+            for (const carrier of carriers) {
+                if (binding.existence === "existing" &&
+                    !baseline.files.some((file) => matchesRepoPattern(file.path, carrier)))
+                    throw new Error(`binding_carrier_path_not_found:${outcome.key}:${carrier}`);
+                if (!allowed.some((pattern) => proveRepositoryPatternSubset(carrier, pattern).status ===
+                    "proven_subset"))
+                    throw new Error(`binding_carrier_outside_change_paths:${outcome.key}:${carrier}`);
+            }
+            if (binding.kind === "file") {
+                const target = assertRepositoryPattern(repository, binding.target, `${outcome.key}.${binding.key}.target`);
+                if (!carriers.some((carrier) => matchesRepoPattern(target, carrier)))
+                    throw new Error(`binding_target_outside_carrier:${outcome.key}:${binding.key}`);
+            }
+            if (binding.kind === "path_glob") {
+                const target = assertRepositoryPattern(repository, binding.target, `${outcome.key}.${binding.key}.target`);
+                if (binding.existence === "existing" &&
+                    !baseline.files.some((file) => matchesRepoPattern(file.path, target)))
+                    throw new Error(`binding_target_not_found:${outcome.key}:${binding.key}`);
+            }
+        }
+    }
+}
+export async function validateCounterfactualPaths(contract, compiledGlobalChecks, compiledOutcomes, repository, workdirRelative, protectedAuthorityPaths) {
+    const allChecks = [
+        ...compiledGlobalChecks,
+        ...compiledOutcomes.flatMap((outcome) => outcome.acceptance.checks),
+    ];
+    const protectedInputs = new Set([
+        ...contract.task.source_paths,
+        ...protectedAuthorityPaths,
+        ...allChecks.flatMap((check) => [
+            ...Object.keys(check.verification_input_hashes),
+            check.runner.resolved_target,
+        ]),
+    ]);
+    for (const outcome of contract.outcomes) {
+        const compiled = compiledOutcomes.find((item) => item.key === outcome.key);
+        for (const control of outcome.acceptance.counterfactual_controls) {
+            const binding = outcome.technical.bindings.find((item) => item.key === control.binding_key);
+            if (!binding)
+                throw new Error(`counterfactual_binding_unknown:${outcome.key}:${control.key}:${control.binding_key}`);
+            validateCounterfactualBindingClaims(outcome, control, binding);
+            const check = compiled.acceptance.checks.find((item) => item.key === control.check_key);
+            await validateScopeCounterfactualPaths({
+                scope: outcome.key,
+                controlKey: control.key,
+                mutation: control.mutation,
+                binding,
+                check,
+                repository,
+                workdirRelative,
+                protectedInputs,
+            });
+        }
+    }
+    for (const control of contract.global.acceptance.counterfactual_controls) {
+        const { outcome, binding } = validateGlobalCounterfactualBindingClaims(contract, control);
+        const check = compiledGlobalChecks.find((item) => item.key === control.check_key);
+        await validateScopeCounterfactualPaths({
+            scope: "GLOBAL",
+            controlKey: control.key,
+            mutation: control.mutation,
+            binding,
+            check,
+            repository,
+            workdirRelative,
+            protectedInputs,
+            bindingRef: `${outcome.key}.${binding.key}`,
+        });
+    }
+}
+async function validateScopeCounterfactualPaths(options) {
+    const mutated = options.mutation.type === "remove_paths"
+        ? options.mutation.paths
+        : [options.mutation.path];
+    for (const relative of mutated) {
+        const target = resolveInsideRepository(options.repository, relative, `${options.scope}.counterfactual`);
+        const normalized = repoRelative(options.repository, target);
+        if (options.protectedInputs.has(normalized))
+            throw new Error(`counterfactual_verification_input_protected:${options.scope}:${relative}`);
+        if (normalized === options.workdirRelative ||
+            normalized.startsWith(`${options.workdirRelative}/`) ||
+            normalized === ".git" ||
+            normalized.startsWith(".git/") ||
+            normalized.split("/").includes("node_modules"))
+            throw new Error(`counterfactual_path_protected:${options.scope}:${relative}`);
+        if (!options.binding.carrier_paths.some((pattern) => proveRepositoryPatternSubset(normalized, pattern).status ===
+            "proven_subset"))
+            throw new Error(`counterfactual_path_outside_binding:${options.scope}:${options.controlKey}:${relative}`);
+        if (options.binding.existence === "existing" &&
+            !(await stat(target).catch(() => null)))
+            throw new Error(`counterfactual_path_not_found:${options.scope}:${relative}`);
+    }
+    if (options.mutation.type !== "replace_file")
+        return;
+    const fixtureTarget = resolveInsideRepository(options.repository, options.mutation.fixture_path, `${options.scope}.counterfactual.fixture`);
+    const fixture = repoRelative(options.repository, await assertProtectedRepositoryFile(options.repository, fixtureTarget, `${options.scope}.counterfactual.fixture`));
+    if (!Object.hasOwn(options.check.verification_input_hashes, fixture))
+        throw new Error(`counterfactual_fixture_must_be_verification_input:${options.scope}:${fixture}`);
+}
+export async function hashDeclaredFiles(repository, files, label) {
+    const result = {};
+    for (const [index, file] of files.entries()) {
+        const target = resolveInsideRepository(repository, file, `${label}[${index}]`);
+        const protectedTarget = await assertProtectedRepositoryFile(repository, target, `${label}[${index}]`);
+        result[repoRelative(repository, protectedTarget)] = sha256Hex(await readFile(protectedTarget));
+    }
+    return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
+}

package/dist/lib/long-task-delivery-shape.d.ts

@@ -0,0 +1,5 @@
+export * from "./long-task-acceptance-shape.js";
+export * from "./long-task-product-shape.js";
+export * from "./long-task-shape-primitives.js";
+export * from "./long-task-source-shape.js";
+export * from "./long-task-technical-shape.js";

package/dist/lib/long-task-delivery-shape.js

@@ -0,0 +1,5 @@
+export * from "./long-task-acceptance-shape.js";
+export * from "./long-task-product-shape.js";
+export * from "./long-task-shape-primitives.js";
+export * from "./long-task-source-shape.js";
+export * from "./long-task-technical-shape.js";

package/dist/lib/long-task-delivery-types.d.ts

@@ -0,0 +1,8 @@
+export * from "./long-task-contract-types.js";
+export * from "./long-task-counterfactual-types.js";
+export * from "./long-task-authority-types.js";
+export * from "./long-task-evidence-adapter-types.js";
+export * from "./long-task-risk-types.js";
+export * from "./long-task-runtime-types.js";
+export * from "./long-task-source-authority-types.js";
+export * from "./long-task-workspace-runtime-types.js";

package/dist/lib/long-task-delivery-types.js

@@ -0,0 +1,8 @@
+export * from "./long-task-contract-types.js";
+export * from "./long-task-counterfactual-types.js";
+export * from "./long-task-authority-types.js";
+export * from "./long-task-evidence-adapter-types.js";
+export * from "./long-task-risk-types.js";
+export * from "./long-task-runtime-types.js";
+export * from "./long-task-source-authority-types.js";
+export * from "./long-task-workspace-runtime-types.js";

package/dist/lib/long-task-delivery-validation.d.ts

@@ -0,0 +1,3 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+export declare function validateDeliveryContractStructure(contract: DeliveryContractV2): void;
+export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2): string[];

package/dist/lib/long-task-delivery-validation.js

@@ -0,0 +1,175 @@
+import { assertCompiledClaimsCovered, compileProductClaimCoverage, } from "./long-task-claims.js";
+import { fail } from "./long-task-delivery-shape.js";
+import { proveRepositoryPatternSubset } from "./long-task-paths.js";
+import { validateSourceClaimMappings } from "./long-task-source-claim-validation.js";
+import { validateDeclaredCheckSafety } from "./long-task-claim-proof-policy.js";
+import { validateEvidenceAdapterCompatibility } from "./long-task-evidence-adapter-policy.js";
+export function validateDeliveryContractStructure(contract) {
+    validateUniqueKeys(contract);
+    validateDependencies(contract);
+    validateOwnerAndBindings(contract);
+    validateDeclaredCheckSafety(contract);
+    validateEvidenceAdapters(contract);
+    const claims = compileProductClaimCoverage(contract, {
+        allow_uncovered: true,
+    });
+    validateSourceClaimMappings(contract, claims);
+    assertCompiledClaimsCovered(claims);
+}
+export function deliveryContractStructureDiagnostics(contract) {
+    const diagnostics = [];
+    const report = (message) => diagnostics.push(message);
+    validateUniqueKeys(contract, report);
+    validateDependencies(contract, report);
+    validateOwnerAndBindings(contract, report);
+    validateDeclaredCheckSafety(contract, report);
+    validateEvidenceAdapters(contract, report);
+    let claims = null;
+    capture(diagnostics, () => {
+        claims = compileProductClaimCoverage(contract, { allow_uncovered: true });
+    });
+    if (claims) {
+        validateSourceClaimMappings(contract, claims, report);
+        capture(diagnostics, () => assertCompiledClaimsCovered(claims));
+    }
+    return [...new Set(diagnostics)];
+}
+function validateEvidenceAdapters(contract, report) {
+    for (const check of contract.global.acceptance.checks)
+        captureOrReport(report, () => validateEvidenceAdapterCompatibility(check, null));
+    for (const outcome of contract.outcomes)
+        for (const check of outcome.acceptance.checks)
+            captureOrReport(report, () => validateEvidenceAdapterCompatibility(check, outcome.key));
+}
+function validateUniqueKeys(contract, report) {
+    unique(contract.outcomes.map((outcome) => outcome.key), "outcome_key_duplicate", report);
+    unique(contract.global.acceptance.checks.map((check) => check.key), "global_check_key_duplicate", report);
+    unique(contract.source_claims.map((claim) => claim.key), "source_claim_key_duplicate", report);
+    for (const [fact, outcomes] of Object.entries(contract.risk.facts))
+        unique(outcomes, `risk_fact_outcome_duplicate:${fact}`, report);
+    unique(contract.global.acceptance.counterfactual_controls.map((control) => control.key), "global_counterfactual_key_duplicate", report);
+    unique(contract.global.acceptance.external_confirmations.map((item) => item.key), "external_confirmation_key_duplicate", report);
+    unique([
+        ...contract.global.product.non_goals,
+        ...contract.global.technical.constraints,
+        ...contract.global.technical.forbidden_paths,
+        ...contract.global.technical.forbidden_shortcuts,
+    ].map((item) => item.key), "global_constraint_key_duplicate", report);
+    for (const outcome of contract.outcomes) {
+        unique(outcome.acceptance.checks.map((check) => check.key), `check_key_duplicate:${outcome.key}`, report);
+        unique(outcome.product.requirements.map((item) => item.key), `requirement_key_duplicate:${outcome.key}`, report);
+        unique(outcome.product.controls.map((control) => control.key), `control_key_duplicate:${outcome.key}`, report);
+        unique(outcome.product.non_completing_outcomes.map((item) => item.key), `non_completing_key_duplicate:${outcome.key}`, report);
+        unique(outcome.technical.obligations.map((item) => item.key), `obligation_key_duplicate:${outcome.key}`, report);
+        unique(outcome.technical.forbidden_shortcuts.map((item) => item.key), `forbidden_shortcut_key_duplicate:${outcome.key}`, report);
+        unique(outcome.technical.bindings.map((item) => item.key), `binding_key_duplicate:${outcome.key}`, report);
+        unique(outcome.acceptance.counterfactual_controls.map((item) => item.key), `counterfactual_key_duplicate:${outcome.key}`, report);
+        for (const check of outcome.acceptance.checks) {
+            unique(check.environment_requirements.map((item) => item.key), `environment_requirement_key_duplicate:${outcome.key}:${check.key}`, report);
+            unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key), `assertion_key_duplicate:${outcome.key}:${check.key}`, report);
+            unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.observation), `assertion_observation_duplicate:${outcome.key}:${check.key}`, report);
+        }
+    }
+    for (const check of contract.global.acceptance.checks)
+        unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.observation), `assertion_observation_duplicate:GLOBAL:${check.key}`, report);
+}
+function validateOwnerAndBindings(contract, report) {
+    const contextRefs = new Set(contract.task.context_refs);
+    for (const outcome of contract.outcomes) {
+        for (const reference of outcome.product.owner.context_refs)
+            if (!contextRefs.has(reference))
+                issue(report, "owner_context_ref_unknown", `${outcome.key}:${reference}`);
+        if (!outcome.product.owner.path_globs.length)
+            issue(report, "owner_path_globs_empty", outcome.key);
+        for (const candidate of [
+            ...outcome.technical.expected_change_paths,
+            ...outcome.technical.allowed_support_paths,
+        ])
+            if (!outcome.product.owner.path_globs.some((owner) => isProvenSubset(candidate, owner)))
+                issue(report, "path_outside_owner_boundary", `${outcome.key}:${candidate}`);
+        const checks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
+        for (const binding of outcome.technical.bindings) {
+            for (const carrier of binding.carrier_paths)
+                if (!outcome.product.owner.path_globs.some((owner) => isProvenSubset(carrier, owner)))
+                    issue(report, "binding_carrier_outside_owner_boundary", `${outcome.key}:${binding.key}:${carrier}`);
+            if (binding.kind === "verified") {
+                const check = checks.get(binding.verification_check_key ?? "");
+                if (!check) {
+                    issue(report, "verified_binding_check_unknown", `${outcome.key}:${binding.key}`);
+                    continue;
+                }
+                const obligationClaim = `obligation.${binding.key}`;
+                const covered = [
+                    ...check.positive_assertions,
+                    ...check.negative_assertions,
+                ].some((assertion) => assertion.claims.includes(obligationClaim));
+                if (!covered)
+                    issue(report, "verified_binding_obligation_uncovered", `${outcome.key}:${binding.key}`);
+            }
+        }
+    }
+}
+function isProvenSubset(candidate, owner) {
+    return (proveRepositoryPatternSubset(candidate, owner).status === "proven_subset");
+}
+function unique(values, code, report) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            issue(report, code, value);
+        seen.add(value);
+    }
+}
+function capture(diagnostics, action) {
+    try {
+        action();
+    }
+    catch (error) {
+        diagnostics.push(error instanceof Error ? error.message : String(error));
+    }
+}
+function validateDependencies(contract, report) {
+    const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
+    for (const outcome of contract.outcomes)
+        for (const dependency of outcome.depends_on) {
+            if (dependency === outcome.key)
+                issue(report, "outcome_dependency_self", outcome.key);
+            if (!outcomes.has(dependency))
+                issue(report, "outcome_dependency_unknown", `${outcome.key}:${dependency}`);
+        }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (value) => {
+        if (visiting.has(value)) {
+            issue(report, "outcome_dependency_cycle", value);
+            return;
+        }
+        if (visited.has(value))
+            return;
+        visiting.add(value);
+        for (const dependency of outcomes.get(value).depends_on)
+            if (outcomes.has(dependency))
+                visit(dependency);
+        visiting.delete(value);
+        visited.add(value);
+    };
+    for (const outcome of outcomes.keys())
+        visit(outcome);
+}
+function issue(report, code, detail) {
+    if (!report)
+        fail(code, detail);
+    report(`delivery_contract_invalid:${code}:${detail}`);
+}
+function captureOrReport(report, action) {
+    if (!report) {
+        action();
+        return;
+    }
+    try {
+        action();
+    }
+    catch (error) {
+        report(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/lib/long-task-evidence-adapter-policy.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryCheckV2, EvidenceAdapter, ProofSurface, RunnerType } from "./long-task-delivery-types.js";
+export declare function evidenceAdapterForRunner(type: RunnerType): EvidenceAdapter;
+export declare function validateEvidenceAdapterCompatibility(check: DeliveryCheckV2, outcomeKey: string | null): void;
+export declare function adapterSupportsProofSurface(adapter: EvidenceAdapter, surface: ProofSurface): boolean;

package/dist/lib/long-task-evidence-adapter-policy.js

@@ -0,0 +1,15 @@
+export function evidenceAdapterForRunner(type) {
+    return type === "playwright_test"
+        ? "playwright_json_v1"
+        : "structured_json_v2";
+}
+export function validateEvidenceAdapterCompatibility(check, outcomeKey) {
+    const adapter = evidenceAdapterForRunner(check.runner.type);
+    if (!adapterSupportsProofSurface(adapter, check.proof_surface))
+        throw new Error(`evidence_adapter_mismatch:${outcomeKey ?? "GLOBAL"}:${check.key}:${check.proof_surface}:${adapter}`);
+}
+export function adapterSupportsProofSurface(adapter, surface) {
+    return surface === "ui_browser"
+        ? adapter === "playwright_json_v1"
+        : adapter === "structured_json_v2";
+}

package/dist/lib/long-task-evidence-adapter-types.d.ts

@@ -0,0 +1 @@
+export type EvidenceAdapter = "structured_json_v2" | "playwright_json_v1";

package/dist/lib/long-task-evidence-adapter-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/long-task-evidence-findings.d.ts

@@ -0,0 +1,5 @@
+import type { CheckExecutionResultV2, CompiledCheckV2, CompiledOutcomeV2, LongTaskFindingV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
+export declare function evaluateAssertionResults(check: CompiledCheckV2, observations: Record<string, unknown>): CheckExecutionResultV2["assertion_results"];
+export declare function classifyCheckStatus(raw: RawCommandExecutionV2, findings: LongTaskFindingV2[]): CheckExecutionResultV2["status"];
+export declare function assertionFinding(check: CompiledCheckV2, result: CheckExecutionResultV2["assertion_results"][number], observations: Record<string, unknown>, outcome?: CompiledOutcomeV2): LongTaskFindingV2;
+export declare function checkFinding(check: CompiledCheckV2, code: string, message: string, nextAction: string): LongTaskFindingV2;

package/dist/lib/long-task-evidence-findings.js

@@ -0,0 +1,113 @@
+import { evaluateDeliveryAssertionDetailed, observationValue, } from "./long-task-assertions-v2.js";
+export function evaluateAssertionResults(check, observations) {
+    const assertions = [
+        ...check.positive_assertions.map((assertion) => ({
+            assertion,
+            polarity: "positive",
+        })),
+        ...check.negative_assertions.map((assertion) => ({
+            assertion,
+            polarity: "negative",
+        })),
+    ];
+    return assertions.map(({ assertion, polarity }) => {
+        const evaluation = evaluateDeliveryAssertionDetailed(assertion, observations);
+        return {
+            key: assertion.key,
+            ...(assertion.criterion ? { criterion: assertion.criterion } : {}),
+            polarity,
+            passed: evaluation.passed,
+            claims: assertion.claims,
+            observation: assertion.observation,
+            status: evaluation.status,
+            ...(Object.hasOwn(evaluation, "expected")
+                ? { expected: evaluation.expected }
+                : {}),
+            ...(Object.hasOwn(evaluation, "actual")
+                ? { actual: evaluation.actual }
+                : {}),
+        };
+    });
+}
+export function classifyCheckStatus(raw, findings) {
+    if (raw.execution_status !== "completed")
+        return raw.execution_status;
+    if (raw.exit_code !== 0 ||
+        findings.some((item) => item.code === "test_failed"))
+        return "test_failed";
+    if (findings.some((item) => item.code === "invalid_evidence" || item.code === "artifact_missing"))
+        return "invalid_evidence";
+    if (findings.some((item) => item.assertion_key) ||
+        findings.some((item) => item.code === "population_coverage_failed"))
+        return "assertion_failed";
+    return "passed";
+}
+export function assertionFinding(check, result, observations, outcome) {
+    const ac = playwrightCase(result.observation);
+    let code = result.status;
+    let message = `Assertion ${result.key} did not match its expected value.`;
+    let nextAction = "Fix the observable behavior or the named acceptance assertion, then rerun this Check.";
+    if (ac) {
+        const prefix = `playwright.case.${ac}`;
+        const executed = observationValue(observations, `${prefix}.executed`);
+        const skipped = observationValue(observations, `${prefix}.skipped`);
+        const flaky = observationValue(observations, `${prefix}.flaky`);
+        const unexpected = observationValue(observations, `${prefix}.unexpected`);
+        if (flaky.found && flaky.value === true) {
+            code = "acceptance_case_flaky";
+            message = `Acceptance case ${ac} was flaky.`;
+            nextAction =
+                "Remove flakiness from every declared Playwright project instance and rerun this Check.";
+        }
+        else if (unexpected.found && unexpected.value === true) {
+            code = "acceptance_case_unexpected";
+            message = `Acceptance case ${ac} had an unexpected result.`;
+            nextAction =
+                "Fix the unexpected Playwright result in every declared project and rerun this Check.";
+        }
+        else if (skipped.found && skipped.value === true) {
+            code = "acceptance_case_skipped";
+            message = `Acceptance case ${ac} was skipped.`;
+            nextAction =
+                "Make the declared [ac:<key>] Playwright case executable and rerun this Check.";
+        }
+        else if (executed.found && executed.value === false) {
+            code = "acceptance_case_not_executed";
+            message = `Acceptance case ${ac} was not executed.`;
+            nextAction =
+                "Add or restore the declared [ac:<key>] Playwright case and rerun this Check.";
+        }
+    }
+    else if (result.status === "observation_missing") {
+        message = `Observation ${result.observation} was missing.`;
+        nextAction =
+            "Emit the declared Observation from the Check evidence and rerun it.";
+    }
+    else if (result.status === "observation_type_mismatch") {
+        message = `Observation ${result.observation} had an incompatible type.`;
+        nextAction =
+            "Fix the Observation type or the Contract operator and rerun this Check.";
+    }
+    return {
+        ...checkFinding(check, code, message, nextAction),
+        claim_keys: result.claims,
+        assertion_key: result.key,
+        ...(result.criterion ? { criterion: result.criterion } : {}),
+        observation: result.observation,
+        ...(Object.hasOwn(result, "expected") ? { expected: result.expected } : {}),
+        ...(Object.hasOwn(result, "actual") ? { actual: result.actual } : {}),
+        ...(outcome ? { owner_paths: outcome.product.owner.path_globs } : {}),
+    };
+}
+export function checkFinding(check, code, message, nextAction) {
+    return {
+        code,
+        outcome_key: check.outcome_key,
+        check_key: check.key,
+        message,
+        next_action: nextAction,
+    };
+}
+function playwrightCase(observation) {
+    return (/^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(observation)?.[1] ?? null);
+}

package/dist/lib/long-task-evidence-sensitivity-policy.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledCheckV2, CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+export declare function validateClaimEvidenceSensitivity(contract: DeliveryContractV2, globalChecks: CompiledCheckV2[], outcomes: CompiledOutcomeV2[], report?: ValidationReporter): void;
+type ValidationReporter = (message: string) => void;
+export {};

package/dist/lib/long-task-evidence-sensitivity-policy.js

@@ -0,0 +1,98 @@
+const NON_RESULT_SENSITIVITY_PREFIXES = [
+    "requirement.",
+    "control.",
+    "obligation.",
+    "non_completing.",
+    "forbidden_shortcut.",
+];
+export function validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, report) {
+    validateGlobalStructuredSensitivity(contract, globalChecks, report);
+    const weakOutcomes = new Set(contract.risk.facts.weak_observability);
+    for (const outcome of outcomes) {
+        const population = outcome.acceptance.population;
+        const counterfactualsByCheck = groupCounterfactuals(outcome);
+        for (const check of outcome.acceptance.checks) {
+            const counterfactuals = counterfactualsByCheck.get(check.key) ?? [];
+            if (check.evidence_adapter === "structured_json_v2") {
+                const assertionClaims = new Set(assertions(check).flatMap((assertion) => assertion.claims));
+                const populationClaims = new Set(population?.check_key === check.key ? population.claims : []);
+                const declaredClaims = new Set([
+                    ...assertionClaims,
+                    ...populationClaims,
+                ]);
+                const counterfactualClaims = new Set(counterfactuals.flatMap((control) => control.claims));
+                const required = [...declaredClaims].filter((claim) => weakOutcomes.has(outcome.key) || !populationClaims.has(claim));
+                const missing = required
+                    .filter((claim) => !counterfactualClaims.has(claim))
+                    .sort();
+                if (missing.length)
+                    issue(report, `structured_evidence_sensitivity_required:${outcome.key}:${check.key}:${missing.join(",")}`);
+                validateResultRoots(outcome.key, check, counterfactuals, report);
+            }
+            if (check.evidence_adapter === "playwright_json_v1" &&
+                weakOutcomes.has(outcome.key))
+                validateWeakPlaywrightSensitivity(outcome.key, check, counterfactuals, report);
+        }
+    }
+}
+function validateGlobalStructuredSensitivity(contract, checks, report) {
+    for (const check of checks) {
+        if (check.evidence_adapter !== "structured_json_v2")
+            continue;
+        const claims = new Set(assertions(check).flatMap((assertion) => assertion.claims));
+        if (!claims.size)
+            continue;
+        const controls = contract.global.acceptance.counterfactual_controls.filter((control) => control.check_key === check.key);
+        const covered = new Set(controls.flatMap((control) => control.claims));
+        const missing = [...claims].filter((claim) => !covered.has(claim)).sort();
+        if (missing.length)
+            issue(report, `global_structured_evidence_sensitivity_required:${check.key}:${missing.join(",")}`);
+    }
+}
+function validateWeakPlaywrightSensitivity(outcomeKey, check, counterfactuals, report) {
+    for (const assertion of assertions(check).filter((item) => item.claims.length > 0)) {
+        const relevant = counterfactuals.filter((control) => control.expected_assertion_failures.includes(assertion.key));
+        if (!relevant.length) {
+            issue(report, `playwright_weak_observability_sensitivity_required:${outcomeKey}:${check.key}:${assertion.key}`);
+            continue;
+        }
+        const covered = new Set(relevant.flatMap((control) => control.claims));
+        const missing = assertion.claims
+            .filter((claim) => !covered.has(claim))
+            .sort();
+        if (missing.length)
+            issue(report, `playwright_weak_observability_claim_sensitivity_required:${outcomeKey}:${check.key}:${missing.join(",")}`);
+    }
+    validateResultRoots(outcomeKey, check, counterfactuals, report);
+}
+function validateResultRoots(outcomeKey, check, counterfactuals, report) {
+    for (const assertion of assertions(check)) {
+        if (!assertion.claims.includes("result"))
+            continue;
+        const resultSensitive = counterfactuals.some((control) => control.expected_assertion_failures.includes(assertion.key) &&
+            control.claims.includes("result") &&
+            control.claims.some(isNonResultSensitivityClaim));
+        if (!resultSensitive)
+            issue(report, `structured_result_counterfactual_non_result_required:${outcomeKey}:${check.key}:${assertion.key}`);
+    }
+}
+function assertions(check) {
+    return [...check.positive_assertions, ...check.negative_assertions];
+}
+function groupCounterfactuals(outcome) {
+    const grouped = new Map();
+    for (const control of outcome.acceptance.counterfactual_controls) {
+        const controls = grouped.get(control.check_key) ?? [];
+        controls.push(control);
+        grouped.set(control.check_key, controls);
+    }
+    return grouped;
+}
+function isNonResultSensitivityClaim(claim) {
+    return NON_RESULT_SENSITIVITY_PREFIXES.some((prefix) => claim.startsWith(prefix));
+}
+function issue(report, message) {
+    if (!report)
+        throw new Error(message);
+    report(message);
+}

package/dist/lib/long-task-evidence-v2.d.ts

@@ -0,0 +1,5 @@
+import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function evaluateCheckEvidence(check: CompiledCheckV2, raw: RawCommandExecutionV2, snapshotRoot: string, outcome?: CompiledOutcomeV2): Promise<CheckExecutionResultV2>;
+export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2): Promise<LongTaskFindingV2[]>;
+export declare function evaluateGlobalCounterfactuals(compiled: CompiledDeliveryContractV2, snapshotRoot: string, selectedCheckKeys?: ReadonlySet<string>, manifest?: WorkspaceManifestV2): Promise<LongTaskFindingV2[]>;
+export declare function isValidCounterfactualCheckResult(result: CheckExecutionResultV2, expectedAssertionFailures: string[]): boolean;