project-tiny-context-harness 0.2.85 → 0.6.1

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

@@ -0,0 +1,226 @@
+import { copyFile, rm, stat } from "node:fs/promises";
+import { evaluatePopulation } from "./long-task-assertions-v2.js";
+import { collectCheckArtifacts } from "./long-task-artifacts.js";
+import { executeCheckRunner } from "./long-task-check-runner.js";
+import { createCounterfactualSandbox } from "./long-task-counterfactual-sandbox.js";
+import { assertionFinding, checkFinding, classifyCheckStatus, evaluateAssertionResults, } from "./long-task-evidence-findings.js";
+import { classifyPlaywrightCounterfactual } from "./long-task-playwright-counterfactual-policy.js";
+import { resolveInsideRepository } from "./long-task-workspace.js";
+export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
+    const artifacts = await collectCheckArtifacts(check, snapshotRoot);
+    const assertionResults = evaluateAssertionResults(check, raw.observations);
+    const executionCompleted = raw.execution_status === "completed";
+    const findings = [];
+    if (!executionCompleted)
+        findings.push(checkFinding(check, raw.execution_status, raw.error ?? raw.execution_status, raw.execution_status === "blocked_external"
+            ? "Satisfy the declared Environment Requirement and rerun this Check."
+            : "Repair the declared runner or evidence protocol and rerun this Check."));
+    if (executionCompleted && raw.exit_code !== 0)
+        findings.push(checkFinding(check, "test_failed", `command exited ${raw.exit_code}`, "Fix the implementation or declared verification command, then rerun this Check."));
+    if (executionCompleted &&
+        raw.observations["playwright.zero_or_all_skipped"] === true)
+        findings.push(checkFinding(check, "test_failed", "Playwright executed zero tests or skipped every test.", "Make the declared Playwright target execute at least one non-skipped test."));
+    if (executionCompleted) {
+        for (const error of artifacts.errors)
+            findings.push(checkFinding(check, "artifact_missing", error, "Produce the artifact declared for this Check and rerun it."));
+        for (const result of assertionResults)
+            if (!result.passed)
+                findings.push(assertionFinding(check, result, raw.observations, outcome));
+    }
+    const population = outcome?.acceptance.population;
+    let populationPassed = true;
+    if (executionCompleted && population?.check_key === check.key) {
+        const result = evaluatePopulation(population, raw.observations);
+        populationPassed = result.passed;
+        if (!result.passed)
+            findings.push({
+                ...checkFinding(check, "population_coverage_failed", result.reason ?? "full population coverage was not proven", "Fix entity enumeration/exclusion behavior and rerun the population Check."),
+                expected: { coverage_percent: 100 },
+                actual: result.actual,
+                claim_keys: population.claims,
+            });
+    }
+    const status = classifyCheckStatus(raw, findings);
+    const claimProofs = status === "passed"
+        ? assertionResults.flatMap((result) => result.claims.map((claim) => ({
+            check_key: check.key,
+            assertion_key: result.key,
+            polarity: result.polarity,
+            proof_surface: check.proof_surface,
+        })))
+        : [];
+    if (status === "passed" &&
+        population &&
+        population.check_key === check.key &&
+        populationPassed)
+        claimProofs.push(...population.claims.map(() => ({
+            check_key: check.key,
+            assertion_key: null,
+            polarity: "population",
+            proof_surface: check.proof_surface,
+        })));
+    return {
+        internal_id: check.internal_id,
+        outcome_key: check.outcome_key,
+        check_key: check.key,
+        status,
+        evidence_adapter: check.evidence_adapter,
+        execution_identity: raw.raw_execution_identity,
+        assertion_results: assertionResults,
+        observations: raw.observations,
+        artifact_hashes: artifacts.hashes,
+        claim_proofs: claimProofs,
+        findings,
+        attempts: raw.attempts,
+        duration_ms: raw.duration_ms,
+    };
+}
+export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, manifest) {
+    return evaluateCounterfactualSet(outcome.acceptance.counterfactual_controls.map((control) => ({
+        control,
+        check: outcome.acceptance.checks.find((item) => item.key === control.check_key),
+        evidenceOutcome: outcome,
+        findingOutcomeKey: outcome.key,
+        owningOutcome: outcome,
+        bindingRef: `${outcome.key}.${control.binding_key}`,
+    })), snapshotRoot, manifest);
+}
+export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, selectedCheckKeys, manifest) {
+    return evaluateCounterfactualSet((compiled.global.acceptance.counterfactual_controls ?? [])
+        .filter((control) => !selectedCheckKeys || selectedCheckKeys.has(control.check_key))
+        .map((control) => {
+        const [outcomeKey] = control.binding_ref.split(".");
+        return {
+            control,
+            check: compiled.global.acceptance.checks.find((item) => item.key === control.check_key),
+            findingOutcomeKey: null,
+            owningOutcome: compiled.outcomes.find((outcome) => outcome.key === outcomeKey),
+            bindingRef: control.binding_ref,
+        };
+    }), snapshotRoot, manifest);
+}
+async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
+    const findings = [];
+    for (const entry of entries) {
+        const { control, check } = entry;
+        const owningBinding = entry.owningOutcome.technical.bindings.find((binding) => `${entry.owningOutcome.key}.${binding.key}` === entry.bindingRef);
+        const sandbox = await createCounterfactualSandbox(snapshotRoot, check, control, owningBinding?.carrier_paths ?? [], manifest);
+        const root = sandbox.root;
+        try {
+            const mutationTargets = control.mutation.type === "remove_paths"
+                ? control.mutation.paths
+                : [control.mutation.path];
+            const missingTargets = [];
+            for (const target of mutationTargets)
+                if (!(await stat(resolveInsideRepository(root, target, "counterfactual.target")).catch(() => null)))
+                    missingTargets.push(target);
+            if (missingTargets.length) {
+                findings.push(counterfactualIntegrityFinding(entry, {
+                    execution_status: "not_run",
+                    finding_codes: ["counterfactual_mutation_target_missing"],
+                    missing_targets: missingTargets,
+                }));
+                continue;
+            }
+            if (control.mutation.type === "remove_paths") {
+                for (const target of control.mutation.paths)
+                    await rm(resolveInsideRepository(root, target, "counterfactual.remove_paths"), { recursive: true, force: true });
+            }
+            else {
+                await copyFile(resolveInsideRepository(root, control.mutation.fixture_path, "counterfactual.fixture"), resolveInsideRepository(root, control.mutation.path, "counterfactual.path"));
+            }
+            const raw = await executeCheckRunner(check, root);
+            const result = await evaluateCheckEvidence(check, raw, root, entry.evidenceOutcome);
+            const playwrightClassification = result.evidence_adapter === "playwright_json_v1"
+                ? classifyPlaywrightCounterfactual(raw, result, control)
+                : null;
+            const sensitivityResult = playwrightClassification?.normalized_result ?? result;
+            const failedAssertions = result.assertion_results
+                .filter((assertion) => !assertion.passed)
+                .map((assertion) => assertion.key)
+                .sort();
+            const expected = [...control.expected_assertion_failures].sort();
+            const acceptedExit = playwrightClassification
+                ? playwrightClassification.accepted_test_failure_exit
+                : raw.exit_code === 0;
+            const valid = raw.execution_status === "completed" &&
+                acceptedExit &&
+                isValidCounterfactualCheckResult(sensitivityResult, expected);
+            if (!valid)
+                findings.push(counterfactualIntegrityFinding(entry, playwrightClassification
+                    ? playwrightCounterfactualDiagnostic(raw, result, expected, playwrightClassification.rejection_reasons)
+                    : {
+                        execution_status: raw.execution_status,
+                        exit_code: raw.exit_code,
+                        result_status: result.status,
+                        failed_assertions: failedAssertions,
+                        finding_codes: result.findings.map((finding) => finding.code),
+                    }));
+        }
+        finally {
+            await sandbox.dispose();
+        }
+    }
+    return findings;
+}
+function playwrightCounterfactualDiagnostic(raw, result, expectedAssertions, rejectionReasons) {
+    const caseIds = result.assertion_results
+        .map((assertion) => /^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(assertion.observation)?.[1])
+        .filter((item) => Boolean(item));
+    const unexpectedCaseIds = caseIds.filter((id) => raw.observations[`playwright.case.${id}.unexpected`] === true);
+    const timedOutCaseIds = caseIds.filter((id) => Number(raw.observations[`playwright.case.${id}.timed_out_instances`]) > 0);
+    const interruptedCaseIds = caseIds.filter((id) => Number(raw.observations[`playwright.case.${id}.interrupted_instances`]) >
+        0);
+    return {
+        execution_status: raw.execution_status,
+        exit_code: raw.exit_code,
+        result_status: result.status,
+        report_error_count: raw.observations["playwright.report_error_count"] ?? null,
+        expected_assertions: expectedAssertions,
+        unexpected_case_ids: [...new Set(unexpectedCaseIds)].sort(),
+        declared_unexpected_instances: raw.observations["playwright.declared_unexpected_instances"] ?? null,
+        unbound_unexpected_instances: raw.observations["playwright.unbound_unexpected_instances"] ?? null,
+        timed_out_case_ids: [...new Set(timedOutCaseIds)].sort(),
+        interrupted_case_ids: [...new Set(interruptedCaseIds)].sort(),
+        finding_codes: result.findings.map((finding) => finding.code),
+        rejection_reasons: rejectionReasons,
+    };
+}
+function counterfactualIntegrityFinding(entry, actual) {
+    return {
+        code: "counterfactual_integrity_failed",
+        outcome_key: entry.findingOutcomeKey,
+        check_key: entry.check.key,
+        ...(entry.control.expected_assertion_failures.length === 1
+            ? { assertion_key: entry.control.expected_assertion_failures[0] }
+            : {}),
+        claim_keys: entry.control.claims,
+        binding_ref: entry.bindingRef,
+        owning_outcome_key: entry.owningOutcome.key,
+        owner_paths: entry.owningOutcome.product.owner.path_globs,
+        message: `Counterfactual ${entry.control.key} did not fail exactly the designated Assertions.`,
+        expected: [...entry.control.expected_assertion_failures].sort(),
+        actual,
+        next_action: "Repair the referenced implementation carrier or proof so only the designated Assertion value mismatches demonstrate sensitivity.",
+    };
+}
+export function isValidCounterfactualCheckResult(result, expectedAssertionFailures) {
+    const expected = [...expectedAssertionFailures].sort();
+    const failedAssertions = result.assertion_results
+        .filter((assertion) => !assertion.passed)
+        .map((assertion) => assertion.key)
+        .sort();
+    return (result.status === "assertion_failed" &&
+        result.findings.length === expected.length &&
+        result.findings.filter((finding) => finding.assertion_key).length ===
+            expected.length &&
+        result.findings
+            .filter((finding) => finding.assertion_key)
+            .every((finding) => expected.some((key) => finding.assertion_key === key)) &&
+        result.findings.every((finding) => finding.code === "assertion_value_mismatch") &&
+        result.assertion_results
+            .filter((assertion) => !assertion.passed)
+            .every((assertion) => assertion.status === "assertion_value_mismatch") &&
+        failedAssertions.length === expected.length &&
+        failedAssertions.every((item, index) => item === expected[index]));
+}

package/dist/lib/long-task-explain-acceptance-link.d.ts

@@ -0,0 +1,46 @@
+import type { ClaimCoverageSummaryV2, DeliveryContractV2, SourceClaimV2 } from "./long-task-delivery-types.js";
+type AcceptanceDisposition = Extract<SourceClaimV2["disposition"], {
+    type: "acceptance";
+}>;
+export declare function explainAcceptanceLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: AcceptanceDisposition): ({
+    type: "acceptance";
+    reference: string;
+    scope: "global" | "outcome";
+    outcome_key: string | null;
+    criterion: string | null;
+    claims: string[];
+    source_backed_claims: string[];
+    required_proof_surfaces: Record<string, string[]>;
+    covered_proof_surfaces: Record<string, string[]>;
+    proof_surface: import("./long-task-contract-types.js").ProofSurface;
+    evidence_adapter: import("./long-task-evidence-adapter-types.js").EvidenceAdapter;
+    observation: string;
+    counterfactuals: {
+        key: string;
+        claims: string[];
+        binding_ref: string;
+        owning_outcome_key: string;
+        expected_assertion_failures: string[];
+    }[] | {
+        key: string;
+        claims: string[];
+        binding_key: string;
+        owning_outcome_key: string | null;
+        expected_assertion_failures: string[];
+    }[];
+} | {
+    type: string;
+    reference: string;
+    scope: null;
+    outcome_key: null;
+    criterion: null;
+    claims: never[];
+    source_backed_claims: never[];
+    required_proof_surfaces: {};
+    covered_proof_surfaces: {};
+    proof_surface: null;
+    evidence_adapter: null;
+    observation: null;
+    counterfactuals: never[];
+})[];
+export {};

package/dist/lib/long-task-explain-acceptance-link.js

@@ -0,0 +1,96 @@
+import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
+import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
+export function explainAcceptanceLinks(contract, coverage, disposition) {
+    return disposition.refs.map((reference) => {
+        const resolved = resolveAcceptanceAssertion(contract, reference);
+        if (!resolved)
+            return missingAcceptanceLink(reference);
+        const { assertion, check } = resolved;
+        const required = {};
+        const covered = {};
+        for (const claim of assertion.claims) {
+            if (resolved.scope === "outcome") {
+                const proof = coverage.claims_by_outcome[resolved.outcome_key]?.[claim];
+                required[claim] = proof ? proof.required_surfaces : [];
+                covered[claim] = proof ? proof.covered_surfaces : [];
+            }
+            else {
+                const proof = coverage.claims_by_global[claim];
+                required[claim] = [];
+                covered[claim] = proof
+                    ? [...new Set(proof.proofs.map((item) => item.proof_surface))].sort()
+                    : [];
+            }
+        }
+        const counterfactuals = acceptanceCounterfactuals(contract, resolved.scope, resolved.outcome_key, resolved.check_key, resolved.assertion_key);
+        return {
+            type: disposition.type,
+            reference,
+            scope: resolved.scope,
+            outcome_key: resolved.outcome_key,
+            criterion: assertion.criterion ?? null,
+            claims: assertion.claims,
+            source_backed_claims: assertion.claims.filter((claim) => sourceBacked(contract, resolved.scope, resolved.outcome_key, claim)),
+            required_proof_surfaces: required,
+            covered_proof_surfaces: covered,
+            proof_surface: check.proof_surface,
+            evidence_adapter: evidenceAdapterForRunner(check.runner.type),
+            observation: assertion.observation,
+            counterfactuals,
+        };
+    });
+}
+function missingAcceptanceLink(reference) {
+    return {
+        type: "acceptance",
+        reference,
+        scope: null,
+        outcome_key: null,
+        criterion: null,
+        claims: [],
+        source_backed_claims: [],
+        required_proof_surfaces: {},
+        covered_proof_surfaces: {},
+        proof_surface: null,
+        evidence_adapter: null,
+        observation: null,
+        counterfactuals: [],
+    };
+}
+function sourceBacked(contract, scope, outcomeKey, claim) {
+    if (scope === "global")
+        return contract.source_claims.some((source) => source.disposition.type === "global_constraint" &&
+            source.disposition.refs.includes(claim));
+    const reference = `${outcomeKey}.${claim}`;
+    return contract.source_claims.some((source) => {
+        const disposition = source.disposition;
+        return ((disposition.type === "claim" || disposition.type === "outcome_result") &&
+            (disposition.type === "outcome_result"
+                ? disposition.ref === reference
+                : disposition.refs.includes(reference)));
+    });
+}
+function acceptanceCounterfactuals(contract, scope, outcomeKey, checkKey, assertionKey) {
+    if (scope === "global")
+        return contract.global.acceptance.counterfactual_controls
+            .filter((control) => control.check_key === checkKey &&
+            control.expected_assertion_failures.includes(assertionKey))
+            .map((control) => ({
+            key: control.key,
+            claims: control.claims,
+            binding_ref: control.binding_ref,
+            owning_outcome_key: control.binding_ref.split(".")[0],
+            expected_assertion_failures: control.expected_assertion_failures,
+        }));
+    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
+    return (outcome?.acceptance.counterfactual_controls ?? [])
+        .filter((control) => control.check_key === checkKey &&
+        control.expected_assertion_failures.includes(assertionKey))
+        .map((control) => ({
+        key: control.key,
+        claims: control.claims,
+        binding_key: control.binding_key,
+        owning_outcome_key: outcomeKey,
+        expected_assertion_failures: control.expected_assertion_failures,
+    }));
+}

package/dist/lib/long-task-explain-claim-links.d.ts

@@ -0,0 +1,45 @@
+import type { ClaimCoverageSummaryV2, DeliveryContractV2, SourceClaimV2 } from "./long-task-delivery-types.js";
+type ClaimDisposition = Extract<SourceClaimV2["disposition"], {
+    type: "claim";
+}>;
+type GlobalDisposition = Extract<SourceClaimV2["disposition"], {
+    type: "global_constraint";
+}>;
+type ResultDisposition = Extract<SourceClaimV2["disposition"], {
+    type: "outcome_result";
+}>;
+export declare function explainOutcomeClaimLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: ClaimDisposition): {
+    type: "claim";
+    reference: string;
+    source_backed: boolean;
+    checks: string[];
+    assertions: (string | null)[];
+    required_proof_surfaces: import("./long-task-contract-types.js").ProofSurface[];
+    covered_proof_surfaces: import("./long-task-contract-types.js").ProofSurface[];
+    evidence_adapters: (import("./long-task-evidence-adapter-types.js").EvidenceAdapter | null)[];
+}[];
+export declare function explainOutcomeResultLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: ResultDisposition): {
+    type: "outcome_result";
+    reference: string;
+    source_backed: boolean;
+    checks: string[];
+}[];
+export declare function explainGlobalClaimLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: GlobalDisposition): {
+    type: "global_constraint";
+    reference: string;
+    source_backed: boolean;
+    checks: string[];
+    assertions: (string | null)[];
+    evidence_adapters: (import("./long-task-evidence-adapter-types.js").EvidenceAdapter | null)[];
+    counterfactuals: {
+        key: string;
+        check_key: string;
+        binding_ref: string;
+        owning_outcome: string;
+        owner_paths: string[];
+        carrier_paths: string[];
+        expected_assertion_failures: string[];
+        mutation: import("./long-task-counterfactual-types.js").CounterfactualMutationV2;
+    }[];
+}[];
+export {};

package/dist/lib/long-task-explain-claim-links.js

@@ -0,0 +1,88 @@
+import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
+export function explainOutcomeClaimLinks(contract, coverage, disposition) {
+    return disposition.refs.map((reference) => {
+        const [outcomeKey, ...parts] = reference.split(".");
+        const proof = coverage.claims_by_outcome[outcomeKey]?.[parts.join(".")];
+        return {
+            type: disposition.type,
+            reference,
+            source_backed: sourceBacked(contract, reference),
+            checks: proof ? unique(proof.proofs.map((item) => item.check_key)) : [],
+            assertions: proof
+                ? unique(proof.proofs.map((item) => item.assertion_key))
+                : [],
+            required_proof_surfaces: proof ? proof.required_surfaces : [],
+            covered_proof_surfaces: proof ? proof.covered_surfaces : [],
+            evidence_adapters: proof
+                ? unique(proof.proofs.map((item) => outcomeAdapter(contract, outcomeKey, item.check_key)))
+                : [],
+        };
+    });
+}
+export function explainOutcomeResultLinks(contract, coverage, disposition) {
+    const proof = coverage.claims_by_outcome[disposition.ref.split(".")[0]]?.result;
+    return [
+        {
+            type: disposition.type,
+            reference: disposition.ref,
+            source_backed: sourceBacked(contract, disposition.ref),
+            checks: proof ? unique(proof.proofs.map((item) => item.check_key)) : [],
+        },
+    ];
+}
+export function explainGlobalClaimLinks(contract, coverage, disposition) {
+    return disposition.refs.map((reference) => {
+        const proof = coverage.claims_by_global[reference];
+        return {
+            type: disposition.type,
+            reference,
+            source_backed: sourceBacked(contract, reference),
+            checks: proof ? unique(proof.proofs.map((item) => item.check_key)) : [],
+            assertions: proof
+                ? unique(proof.proofs.map((item) => item.assertion_key))
+                : [],
+            evidence_adapters: proof
+                ? unique(proof.proofs.map((item) => globalAdapter(contract, item.check_key)))
+                : [],
+            counterfactuals: contract.global.acceptance.counterfactual_controls
+                .filter((control) => control.claims.includes(reference))
+                .map((control) => {
+                const [outcomeKey, bindingKey] = control.binding_ref.split(".");
+                const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
+                const binding = outcome?.technical.bindings.find((item) => item.key === bindingKey);
+                return {
+                    key: control.key,
+                    check_key: control.check_key,
+                    binding_ref: control.binding_ref,
+                    owning_outcome: outcomeKey,
+                    owner_paths: outcome?.product.owner.path_globs ?? [],
+                    carrier_paths: binding?.carrier_paths ?? [],
+                    expected_assertion_failures: control.expected_assertion_failures,
+                    mutation: control.mutation,
+                };
+            }),
+        };
+    });
+}
+function unique(values) {
+    return values.filter((value, index) => values.indexOf(value) === index);
+}
+function sourceBacked(contract, reference) {
+    return contract.source_claims.some((source) => {
+        const disposition = source.disposition;
+        if (disposition.type === "outcome_result")
+            return disposition.ref === reference;
+        return ((disposition.type === "claim" ||
+            disposition.type === "global_constraint") &&
+            disposition.refs.includes(reference));
+    });
+}
+function outcomeAdapter(contract, outcomeKey, checkKey) {
+    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
+    const check = outcome?.acceptance.checks.find((candidate) => candidate.key === checkKey);
+    return check ? evidenceAdapterForRunner(check.runner.type) : null;
+}
+function globalAdapter(contract, checkKey) {
+    const check = contract.global.acceptance.checks.find((candidate) => candidate.key === checkKey);
+    return check ? evidenceAdapterForRunner(check.runner.type) : null;
+}

package/dist/lib/long-task-explain-source-links.d.ts

@@ -0,0 +1,93 @@
+import type { ClaimCoverageSummaryV2, DeliveryContractV2, SourceClaimV2 } from "./long-task-delivery-types.js";
+export declare function explainSourceLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, source: SourceClaimV2): ({
+    type: "acceptance" | "claim" | "decision_required" | "external_confirmation" | "global_constraint" | "outcome_result" | "risk_fact";
+    reason: string | null;
+} | {
+    type: "acceptance";
+    reference: string;
+    scope: "global" | "outcome";
+    outcome_key: string | null;
+    criterion: string | null;
+    claims: string[];
+    source_backed_claims: string[];
+    required_proof_surfaces: Record<string, string[]>;
+    covered_proof_surfaces: Record<string, string[]>;
+    proof_surface: import("./long-task-contract-types.js").ProofSurface;
+    evidence_adapter: import("./long-task-evidence-adapter-types.js").EvidenceAdapter;
+    observation: string;
+    counterfactuals: {
+        key: string;
+        claims: string[];
+        binding_ref: string;
+        owning_outcome_key: string;
+        expected_assertion_failures: string[];
+    }[] | {
+        key: string;
+        claims: string[];
+        binding_key: string;
+        owning_outcome_key: string | null;
+        expected_assertion_failures: string[];
+    }[];
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+} | {
+    type: string;
+    reference: string;
+    scope: null;
+    outcome_key: null;
+    criterion: null;
+    claims: never[];
+    source_backed_claims: never[];
+    required_proof_surfaces: {};
+    covered_proof_surfaces: {};
+    proof_surface: null;
+    evidence_adapter: null;
+    observation: null;
+    counterfactuals: never[];
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+} | {
+    type: "claim";
+    reference: string;
+    source_backed: boolean;
+    checks: string[];
+    assertions: (string | null)[];
+    required_proof_surfaces: import("./long-task-contract-types.js").ProofSurface[];
+    covered_proof_surfaces: import("./long-task-contract-types.js").ProofSurface[];
+    evidence_adapters: (import("./long-task-evidence-adapter-types.js").EvidenceAdapter | null)[];
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+} | {
+    type: "outcome_result";
+    reference: string;
+    source_backed: boolean;
+    checks: string[];
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+} | {
+    type: "global_constraint";
+    reference: string;
+    source_backed: boolean;
+    checks: string[];
+    assertions: (string | null)[];
+    evidence_adapters: (import("./long-task-evidence-adapter-types.js").EvidenceAdapter | null)[];
+    counterfactuals: {
+        key: string;
+        check_key: string;
+        binding_ref: string;
+        owning_outcome: string;
+        owner_paths: string[];
+        carrier_paths: string[];
+        expected_assertion_failures: string[];
+        mutation: import("./long-task-counterfactual-types.js").CounterfactualMutationV2;
+    }[];
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+} | {
+    type: "external_confirmation";
+    reference: string;
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+} | {
+    type: "risk_fact";
+    reference: string;
+    risk_fact: string;
+    affected_outcome: string;
+    effective_risk: import("./long-task-risk-types.js").EffectiveRiskLevel;
+    risk_reasons: ("critical_user_path" | "data_migration" | "full_population_operation" | "irreversible_external_effect" | "multi_repository_change" | "permission_boundary_change" | "persistent_data_change" | "public_api_or_schema_change" | "security_boundary_change" | "weak_observability")[];
+    canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
+})[];

package/dist/lib/long-task-explain-source-links.js

@@ -0,0 +1,51 @@
+import { explainAcceptanceLinks } from "./long-task-explain-acceptance-link.js";
+import { explainGlobalClaimLinks, explainOutcomeClaimLinks, explainOutcomeResultLinks, } from "./long-task-explain-claim-links.js";
+import { buildCanonicalSourceTargetIndex } from "./long-task-source-target-index.js";
+import { classifyLongTaskRisk } from "./long-task-risk.js";
+export function explainSourceLinks(contract, coverage, source) {
+    const disposition = source.disposition;
+    const targets = buildCanonicalSourceTargetIndex(contract);
+    let links;
+    if (disposition.type === "acceptance")
+        links = explainAcceptanceLinks(contract, coverage, disposition);
+    if (disposition.type === "claim")
+        links = explainOutcomeClaimLinks(contract, coverage, disposition);
+    if (disposition.type === "outcome_result")
+        links = explainOutcomeResultLinks(contract, coverage, disposition);
+    if (disposition.type === "global_constraint")
+        links = explainGlobalClaimLinks(contract, coverage, disposition);
+    if (disposition.type === "external_confirmation")
+        links = disposition.refs.map((reference) => ({
+            type: disposition.type,
+            reference,
+        }));
+    if (disposition.type === "risk_fact") {
+        const risk = classifyLongTaskRisk(contract);
+        links = disposition.refs.map((reference) => {
+            const [fact, affectedOutcome] = reference.split(":");
+            return {
+                type: disposition.type,
+                reference,
+                risk_fact: fact,
+                affected_outcome: affectedOutcome,
+                effective_risk: risk.effective_level,
+                risk_reasons: risk.reasons_by_outcome[affectedOutcome] ?? [],
+            };
+        });
+    }
+    links ??= [
+        {
+            type: disposition.type,
+            reason: "reason" in disposition ? disposition.reason : null,
+        },
+    ];
+    return links.map((link) => {
+        if (!("reference" in link))
+            return link;
+        const target = targets.get(link.reference);
+        return {
+            ...link,
+            canonical_target: target ?? null,
+        };
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { FinalReceiptV2 } from "./long-task-delivery-types.js";
+export declare function runDeliveryFinalGate(workdirInput: string): Promise<FinalReceiptV2>;