project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,277 +0,0 @@
-import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.js";
-import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceComparator, DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
-import type { SemanticFactEnvironmentV1, SemanticFactLocatedValueV1, SemanticFactOracleV1 } from "./semantic-fact-types.js";
-import type { ActualProvenanceEvidenceV2, DataStateEvidenceV2, DistinctIdentityEvidenceV2, PopulationCoverageEvidenceV2, RecoveryEvidenceV2 } from "./long-task-complete-delivery-evidence-types.js";
-export type { ActualProvenanceEvidenceV2, DataStateEvidenceV2, DistinctIdentityEvidenceV2, PopulationCoverageEvidenceV2, RecoveryEvidenceV2, } from "./long-task-complete-delivery-evidence-types.js";
-interface EvidenceRecordBaseV2 {
-    assertion_key: string;
-    capability: EvidenceCapabilityV2;
-}
-export interface DesignEvidenceLocatorV2 {
-    kind: "json_pointer" | "image_region" | "semantic_node" | "trace_event" | "timeline_sample" | "asset_ref" | "custom";
-    value: string;
-}
-export interface InteractionTraceEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "interaction_trace";
-    target_ref: string;
-    given_keys: string[];
-    action_keys: string[];
-}
-export interface StateDeltaEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "state_delta";
-    before_sha256: string;
-    after_sha256: string;
-    changed_fields: string[];
-}
-export interface CrossSurfaceConsistencyEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "cross_surface_consistency";
-    surfaces: Array<{
-        surface_ref: string;
-        target_ref: string;
-        state_sha256: string;
-    }>;
-}
-export interface DurableReadbackEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "durable_readback";
-    write_session_id: string;
-    read_session_id: string;
-    written_sha256: string;
-    read_sha256: string;
-}
-export interface BoundaryInvocationEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "boundary_invocation";
-    boundary: string;
-    invocation_id: string;
-    request_sha256: string;
-    observer_target_ref: string;
-}
-export interface ExternalSideEffectEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "external_side_effect";
-    boundary: string;
-    effect_id: string;
-    effect_sha256: string;
-    observer_target_ref: string;
-}
-export interface FailureInjectionEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "failure_injection";
-    fault: string;
-    failure_observed: true;
-    recovery_state_sha256: string;
-}
-export interface VisualRenderEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "visual_render";
-    artifact_path: string;
-    artifact_sha256: string;
-}
-export interface DesignConformanceEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "design_conformance";
-    design_target_ref: string;
-    target_ref: string;
-    condition_keys: string[];
-    actual_artifact_path: string;
-    comparison_artifact_path: string;
-}
-export interface TargetRuntimeEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "target_runtime";
-    target_ref: string;
-    root_entrypoint: string;
-    session_id: string;
-    cold_start: boolean;
-}
-export interface DesignGroundMethodEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "design_method";
-    design_target_ref: string;
-    target_ref: string;
-    method: DesignResourceVerificationMethod;
-    cells: Array<{
-        condition_key: string;
-        artifact_path: string;
-        observation_artifact_path: string;
-        fact_refs: string[];
-        fact_results: DesignFactResultV2[];
-    }>;
-}
-export interface DesignFactResultV2 {
-    fact_ref: string;
-    subject_ref: string;
-    variation_ref: string;
-    property_ref: string;
-    actual_observation: {
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        value_sha256: string;
-        sensitivity: "plain" | "protected";
-        redaction: {
-            policy_ref: string;
-            representation: "digest_only" | "redacted_structured";
-            raw_persisted: false;
-        } | null;
-    };
-    actual_environment: {
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        value_sha256: string;
-    };
-    expected: DesignResourceLocatedDigestV1;
-    comparison: {
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        result_sha256: string;
-        comparator: DesignResourceComparator | string;
-        mode: "exact" | "tolerance";
-        parameters: DesignResourceLocatedDigestV1;
-        tolerance: DesignResourceLocatedDigestV1 | null;
-        mask: DesignResourceLocatedDigestV1 | null;
-        passed: boolean;
-    };
-    verdict: "passed" | "failed";
-    oracle: {
-        key: string;
-        trust: "frozen_executable" | "named_external_tcb";
-        identity: string;
-        version: string;
-        sha256: string | null;
-    };
-    environment: {
-        key: string;
-        identity: string;
-        definition: DesignResourceLocatedDigestV1;
-    };
-}
-export interface DesignSymbolicMethodEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "design_method";
-    fact_model: "symbolic_rules_v2";
-    design_target_ref: string;
-    target_ref: string;
-    method: DesignResourceVerificationMethod;
-    artifact_path: string;
-    observation_artifact_path: string;
-    rule_results: DesignSymbolicRuleResultV2[];
-}
-export interface DesignSymbolicRuleResultV2 {
-    obligation_ref: string;
-    fact_rule_ref: string;
-    region_sha256: string;
-    subject_or_relation_ref: string;
-    property_ref: string;
-    population_ref: string | null;
-    quantifier: {
-        kind: "one" | "all" | "any" | "none" | "exactly" | "at_least" | "at_most" | "range";
-        minimum: number | null;
-        maximum: number | null;
-    };
-    actual_observation: DesignFactResultV2["actual_observation"];
-    actual_environment: DesignFactResultV2["actual_environment"];
-    observation_sensitivity: "plain" | "protected";
-    expected: DesignResourceLocatedDigestV1;
-    proof_surface: string;
-    observation_boundary: string;
-    comparison: DesignFactResultV2["comparison"];
-    verdict: "passed" | "failed";
-    oracle: DesignFactResultV2["oracle"];
-    environment: DesignFactResultV2["environment"];
-    protected_value_policy: string;
-    completion_effect: string;
-}
-export type DesignMethodEvidenceV2 = DesignGroundMethodEvidenceV2 | DesignSymbolicMethodEvidenceV2;
-export interface DesignSymbolicCertificateEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "design_symbolic_certificate";
-    design_target_ref: string;
-    target_ref: string;
-    artifact_path: string;
-    artifact_sha256: string;
-    metrics: {
-        semantic_obligations: number;
-        certificate_obligations: number;
-        certificate_covered_omitted_axes: number;
-        certificate_covered_dependency_edges: number;
-        canonical_dag_nodes: number;
-        canonical_partition_edges: number;
-        canonical_bytes: number;
-        theoretical_ground_cardinality: string;
-    };
-    certificate_results: Array<{
-        certificate_ref: string;
-        fact_rule_refs: string[];
-        omitted_axis_refs: string[];
-        dependency_edge_refs: string[];
-        canonical_rule_dag_sha256: string;
-        source_noninterference_proof_sha256?: string;
-        production_noninterference_proof_sha256?: string;
-        recomputed: true;
-        verdict: "passed" | "failed";
-    }>;
-}
-export interface SemanticFactEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "semantic_fact";
-    manifest_ref: string;
-    manifest_sha256: string;
-    outcome_ref: string;
-    target_ref: string;
-    fact_key?: string;
-    fact_revision_digest?: string;
-    obligation_key?: string;
-    obligation_revision_digest?: string;
-    fact_ref: string;
-    proof_ref: string;
-    method: string;
-    subject_ref: string;
-    condition_ref: string;
-    property_ref: string;
-    actual_observation: {
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        value_sha256: string;
-        sensitivity: "plain" | "protected";
-        redaction: {
-            policy_ref: string;
-            representation: "digest_only" | "redacted_structured";
-            raw_persisted: false;
-        } | null;
-    };
-    actual_environment: {
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        value_sha256: string;
-    };
-    expected: SemanticFactLocatedValueV1;
-    comparison: {
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        result_sha256: string;
-        comparator: string;
-        mode: "exact" | "tolerance";
-        parameters: SemanticFactLocatedValueV1;
-        tolerance: SemanticFactLocatedValueV1 | null;
-        mask: SemanticFactLocatedValueV1 | null;
-        passed: boolean;
-    };
-    verdict: "passed" | "failed";
-    oracle: SemanticFactOracleV1;
-    environment: SemanticFactEnvironmentV1;
-    observer_results: Array<{
-        target_ref: string;
-        artifact_path: string;
-        artifact_sha256: string;
-        locator: DesignEvidenceLocatorV2;
-        value_sha256: string;
-        comparison_result_sha256: string;
-        passed: boolean;
-    }>;
-}
-export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
-    capability: "input_variation";
-    cases: Array<{
-        input_sha256: string;
-        output_sha256: string;
-    }>;
-    failure_case_observed: boolean;
-}
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ActualProvenanceEvidenceV2 | ExternalSideEffectEvidenceV2 | DistinctIdentityEvidenceV2 | DataStateEvidenceV2 | PopulationCoverageEvidenceV2 | FailureInjectionEvidenceV2 | RecoveryEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | DesignSymbolicCertificateEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;

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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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,
-            ...(assertion.applicability_ref
-                ? { applicability_ref: assertion.applicability_ref }
-                : {}),
-            observation: assertion.observation,
-            evidence_capabilities: assertion.evidence_capabilities,
-            evidence_complete: false,
-            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" ||
-        item.code === "evidence_capability_invalid"))
-        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

@@ -1,13 +0,0 @@
-import type { CompiledCheckV2, CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function validateCounterfactualObservationImpact(input: {
-    baseline_by_fact: Record<string, string>;
-    mutated_by_fact: Record<string, string>;
-    expected_affected_fact_refs: string[];
-    preserved_fact_refs: string[];
-    allowed_fanout_fact_refs?: string[];
-    target_live: boolean;
-    carrier_role: "product" | "evidence";
-}): string | null;
-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

@@ -1,166 +0,0 @@
-const NON_RESULT_SENSITIVITY_PREFIXES = [
-    "requirement.",
-    "control.",
-    "control_relation",
-    "obligation.",
-    "non_completing.",
-    "forbidden_shortcut.",
-];
-export function validateCounterfactualObservationImpact(input) {
-    if (input.carrier_role === "evidence")
-        return "counterfactual_mutates_generated_evidence";
-    if (!input.target_live)
-        return "counterfactual_target_not_live";
-    const expected = new Set(input.expected_affected_fact_refs);
-    const preserved = new Set(input.preserved_fact_refs);
-    const allowedFanout = new Set(input.allowed_fanout_fact_refs ?? []);
-    for (const factRef of expected) {
-        if (!Object.hasOwn(input.baseline_by_fact, factRef) ||
-            !Object.hasOwn(input.mutated_by_fact, factRef))
-            return "counterfactual_expected_fact_observation_missing";
-        if (input.baseline_by_fact[factRef] === input.mutated_by_fact[factRef])
-            return "counterfactual_expected_fact_unchanged";
-    }
-    for (const factRef of new Set([
-        ...Object.keys(input.baseline_by_fact),
-        ...Object.keys(input.mutated_by_fact),
-    ])) {
-        if (expected.has(factRef) || allowedFanout.has(factRef))
-            continue;
-        const baseline = input.baseline_by_fact[factRef];
-        const mutated = input.mutated_by_fact[factRef];
-        if (preserved.has(factRef) &&
-            (baseline === undefined || mutated === undefined || baseline !== mutated))
-            return "counterfactual_unexpected_fact_impact";
-        if (!preserved.has(factRef) && baseline !== mutated)
-            return "counterfactual_unexpected_fact_impact";
-    }
-    return null;
-}
-export function validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, report) {
-    validateGlobalStructuredSensitivity(contract, globalChecks, report);
-    validateGlobalSemanticWitnesses(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) ?? [];
-            validateBehavioralSemanticWitnesses(outcome.key, check, counterfactuals, report);
-            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 validateGlobalSemanticWitnesses(contract, checks, report) {
-    for (const check of checks)
-        validateBehavioralSemanticWitnesses("GLOBAL", check, contract.global.acceptance.counterfactual_controls.filter((control) => control.check_key === check.key), report);
-}
-function validateBehavioralSemanticWitnesses(scope, check, counterfactuals, report) {
-    for (const assertion of assertions(check)) {
-        if (!assertion.claims.length || !isBehavioralAssertion(check, assertion))
-            continue;
-        const witnesses = counterfactuals.filter((control) => isNarrowSemanticMutation(control.mutation.type) &&
-            control.expected_assertion_failures.includes(assertion.key) &&
-            assertion.claims.every((claim) => control.claims.includes(claim)));
-        if (!witnesses.length) {
-            issue(report, `behavioral_semantic_counterfactual_required:${scope}:${check.key}:${assertion.key}`);
-            continue;
-        }
-        if (!witnesses.some((control) => control.preserved_assertions.some((reference) => isLivenessAssertion(check, reference))))
-            issue(report, `behavioral_counterfactual_liveness_witness_required:${scope}:${check.key}:${assertion.key}`);
-    }
-}
-function isNarrowSemanticMutation(type) {
-    return type === "replace_json_value" || type === "replace_text";
-}
-function isBehavioralAssertion(check, assertion) {
-    return !(check.proof_surface === "implementation_structure" &&
-        assertion.evidence_capabilities.every((capability) => capability === "presence"));
-}
-function isLivenessAssertion(check, reference) {
-    const assertion = check.positive_assertions.find((candidate) => candidate.key === reference);
-    return Boolean(assertion &&
-        !assertion.claims.length &&
-        assertion.operator === "equals" &&
-        assertion.expected === true &&
-        assertion.evidence_capabilities.includes("target_runtime"));
-}
-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

@@ -1,10 +0,0 @@
-import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, CounterfactualControlV2, GlobalCounterfactualControlV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function evaluateCheckEvidence(check: CompiledCheckV2, raw: RawCommandExecutionV2, snapshotRoot: string, outcome?: CompiledOutcomeV2, observationAuthorityPaths?: readonly string[]): Promise<CheckExecutionResultV2>;
-export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[], baselineResults?: readonly CheckExecutionResultV2[], baselineExecutions?: ReadonlyMap<string, RawCommandExecutionV2>, executionUniverse?: readonly CompiledCheckV2[]): Promise<LongTaskFindingV2[]>;
-export declare function evaluateGlobalCounterfactuals(compiled: CompiledDeliveryContractV2, snapshotRoot: string, selectedCheckKeys?: ReadonlySet<string>, manifest?: WorkspaceManifestV2, baselineResults?: readonly CheckExecutionResultV2[], baselineExecutions?: ReadonlyMap<string, RawCommandExecutionV2>, executionUniverse?: readonly CompiledCheckV2[]): Promise<LongTaskFindingV2[]>;
-export declare function counterfactualExecutionMayOverlap(input: {
-    check: CompiledCheckV2;
-    control: CounterfactualControlV2 | GlobalCounterfactualControlV2;
-    protected_authority_paths?: readonly string[];
-}): boolean;
-export declare function isValidCounterfactualCheckResult(result: CheckExecutionResultV2, expectedAssertionFailures: string[], allowedFanoutAssertions?: string[]): boolean;