project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/long-task-acceptance-reachability-claims.js

@@ -0,0 +1,279 @@
+import { externalClaimCapabilityFloor } from "./long-task-proof-adequacy.js";
+import { claimSemanticCapabilityFloor } from "./long-task-claim-semantic-proof-floor.js";
+import { resolveObligationAuthority } from "./long-task-obligation-authority-resolution.js";
+import { claimObligationRef, claimProofMethod, externalConfirmationSessionMatchesApplicability, objectiveMachineClaimActualAuthority, pendingExternalRow, resolveObjectiveExternalClaimActualAuthority, selectOptionalSurface, } from "./long-task-acceptance-reachability-helpers.js";
+import { objectiveClaimSemanticIdentity } from "./long-task-obligation-semantic-identity.js";
+export function compileClaimReachability(input, rows, external) {
+    compileGlobalClaimReachability(input, rows, external);
+    compileOutcomeClaimReachability(input, rows, external);
+}
+function compileGlobalClaimReachability(input, rows, external) {
+    for (const claim of input.claims.by_global) {
+        const summary = input.claims.summary.claims_by_global[claim.local_key];
+        for (const applicabilityRef of claim.applicability_refs)
+            addClaimObligation(input, rows, external, null, claim.local_key, claim.id, applicabilityRef, summary?.proofs ?? [], [], claim.required_polarity);
+    }
+}
+function compileOutcomeClaimReachability(input, rows, external) {
+    for (const [outcomeKey, claims] of Object.entries(input.claims.by_outcome))
+        for (const claim of claims) {
+            if (claim.kind === "semantic_fact")
+                continue;
+            const summary = input.claims.summary.claims_by_outcome[outcomeKey]?.[claim.local_key];
+            for (const applicabilityRef of claim.applicability_refs)
+                addClaimObligation(input, rows, external, outcomeKey, claim.local_key, claim.id, applicabilityRef, summary?.proofs ?? [], claim.required_proof_surfaces, claim.required_polarity);
+        }
+}
+function addClaimObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, proofs, requiredSurfaces, requiredPolarity) {
+    const matching = proofs.filter((proof) => proof.applicability_ref === applicabilityRef &&
+        proof.polarity === requiredPolarity);
+    if (!requiredSurfaces.length) {
+        addOptionalClaimObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, requiredPolarity);
+        return;
+    }
+    for (const surface of requiredSurfaces)
+        addClaimSurfaceObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity);
+}
+function addOptionalClaimObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, requiredPolarity) {
+    const surfaces = [...new Set(matching.map((proof) => proof.proof_surface))];
+    if (!surfaces.length)
+        surfaces.push("runtime_behavior");
+    const profiles = surfaces.map((surface) => claimSurfaceAuthorityProfile(input, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity));
+    const selectedSurface = selectOptionalSurface(matching);
+    const selectedProfile = profiles.find((profile) => profile.surface === selectedSurface) ??
+        profiles[0];
+    const resolution = resolveObligationAuthority({
+        source_obligation_ref: selectedProfile.sourceObligationRef,
+        proof_surface_selection: "optional",
+        machine_candidates: profiles.flatMap((profile) => profile.machineCandidates),
+        external_candidates: profiles.flatMap((profile) => profile.externalCandidates),
+    });
+    const resolvedSurface = resolution.status === "machine_admitted"
+        ? resolution.machine.proof_surface
+        : resolution.status === "external_candidate"
+            ? resolution.external.proof_surface
+            : selectedProfile.surface;
+    if (resolution.status === "machine_admitted") {
+        const machineProfile = profiles.find((profile) => profile.surface === resolution.machine.proof_surface) ?? selectedProfile;
+        for (const profile of profiles)
+            for (const route of profile.externalCandidates) {
+                if (!route.expected_authority_ref)
+                    continue;
+                external.push({
+                    source_obligation_ref: profile.sourceObligationRef,
+                    outcome_key: outcomeKey,
+                    claim_ref: fullClaim,
+                    local_claim_ref: localClaim,
+                    applicability_ref: applicabilityRef,
+                    fact_ref: null,
+                    proof_ref: null,
+                    method: route.method ?? profile.method,
+                    proof_surface: route.proof_surface,
+                    evidence_capabilities: [
+                        ...(route.required_evidence_capabilities ?? []),
+                    ].sort(),
+                    expected_authority_ref: route.expected_authority_ref,
+                    confirmation_ref: route.confirmation_ref,
+                    required_polarity: requiredPolarity,
+                    completion_role: "advisory",
+                    acceptance_effect: "none",
+                    semantic_identity: route.semantic_identity ?? null,
+                    machine_obligation_ref: machineProfile.sourceObligationRef,
+                });
+            }
+    }
+    emitClaimAuthorityResolution(rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, profiles.find((profile) => profile.surface === resolvedSurface) ??
+        selectedProfile, resolution, requiredPolarity);
+}
+function addClaimSurfaceObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity) {
+    const profile = claimSurfaceAuthorityProfile(input, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity);
+    const resolution = resolveObligationAuthority({
+        source_obligation_ref: profile.sourceObligationRef,
+        proof_surface_selection: "required",
+        machine_candidates: profile.machineCandidates,
+        external_candidates: profile.externalCandidates,
+    });
+    emitClaimAuthorityResolution(rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, profile, resolution, requiredPolarity);
+}
+function claimSurfaceAuthorityProfile(input, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity) {
+    const capabilityFloorSet = externalClaimCapabilityFloor(input.contract, outcomeKey, localClaim, surface, applicabilityRef);
+    for (const capability of claimSemanticCapabilityFloor(input.contract, input.manifest, outcomeKey, localClaim, applicabilityRef))
+        capabilityFloorSet.add(capability);
+    const capabilityFloor = [...capabilityFloorSet].sort();
+    const method = claimProofMethod(capabilityFloor);
+    const candidates = matching.filter((proof) => proof.proof_surface === surface);
+    const sourceObligationRef = claimObligationRef(fullClaim, applicabilityRef, surface);
+    const machineCandidates = candidates.flatMap((proof) => {
+        if (!proof.assertion_key)
+            return [];
+        const check = input.compiled_checks.find((item) => item.outcome_key === outcomeKey && item.key === proof.check_key);
+        if (!check)
+            return [];
+        const authority = objectiveMachineClaimActualAuthority(input.compiled_checks, outcomeKey, proof.check_key, proof.assertion_key, localClaim);
+        if (!authority)
+            return [];
+        const requiredCapabilities = check.required_evidence_capabilities[proof.assertion_key] ?? [];
+        const expectedAuthorityRef = check.expected_authority_refs?.[proof.assertion_key];
+        if (!expectedAuthorityRef)
+            return [];
+        return [
+            {
+                check_key: proof.check_key,
+                assertion_key: proof.assertion_key,
+                proof_surface: proof.proof_surface,
+                method,
+                required_evidence_capabilities: requiredCapabilities,
+                semantic_identity: objectiveClaimSemanticIdentity({
+                    contract: input.contract,
+                    outcome_key: outcomeKey,
+                    claim_ref: fullClaim,
+                    local_claim_ref: localClaim,
+                    applicability_ref: applicabilityRef,
+                    required_polarity: requiredPolarity,
+                    expected_authority_ref: expectedAuthorityRef,
+                    method,
+                    required_evidence_capabilities: requiredCapabilities,
+                    observation_authority: authority,
+                }),
+            },
+        ];
+    });
+    const externalCandidates = candidates
+        .filter((proof) => proof.check_key.startsWith("EXTERNAL."))
+        .flatMap((proof) => {
+        const confirmationRef = proof.check_key.slice("EXTERNAL.".length);
+        const confirmation = input.contract.global.acceptance.external_confirmations.find((row) => row.key === confirmationRef);
+        if (!confirmation)
+            return [];
+        return (confirmation.obligations ?? [])
+            .filter((obligation) => obligation.claim_ref === fullClaim &&
+            obligation.applicability_ref === applicabilityRef &&
+            obligation.proof_surface === surface &&
+            obligation.fact_ref === null &&
+            obligation.proof_ref === null)
+            .map((obligation) => {
+            const authorityResolution = resolveObjectiveExternalClaimActualAuthority(input.compiled_checks, {
+                source_obligation_ref: sourceObligationRef,
+                outcome_key: outcomeKey,
+                claim_ref: fullClaim,
+                local_claim_ref: localClaim,
+                fact_ref: null,
+                proof_ref: null,
+                method: obligation.method,
+                proof_surface: obligation.proof_surface,
+            });
+            const authority = authorityResolution.status === "resolved"
+                ? authorityResolution.authority
+                : null;
+            const compiledExpectedAuthorityRef = authorityResolution.status === "resolved"
+                ? authorityResolution.expected_authority_ref
+                : null;
+            const expectedAuthorityMatches = compiledExpectedAuthorityRef !== null &&
+                obligation.expected_authority_ref === compiledExpectedAuthorityRef;
+            const objectiveActual = obligation.result_kind === "actual" &&
+                obligation.judgment_basis === undefined;
+            const semanticIdentity = authority && expectedAuthorityMatches
+                ? objectiveClaimSemanticIdentity({
+                    contract: input.contract,
+                    outcome_key: outcomeKey,
+                    claim_ref: fullClaim,
+                    local_claim_ref: localClaim,
+                    applicability_ref: applicabilityRef,
+                    required_polarity: requiredPolarity,
+                    expected_authority_ref: compiledExpectedAuthorityRef,
+                    method: obligation.method,
+                    required_evidence_capabilities: obligation.evidence_capabilities,
+                    observation_authority: authority,
+                })
+                : null;
+            return {
+                confirmation_ref: confirmationRef,
+                obligation_key: obligation.key,
+                proof_surface: obligation.proof_surface,
+                method: obligation.method,
+                required_evidence_capabilities: [
+                    ...obligation.evidence_capabilities,
+                ].sort(),
+                authority_ambiguous: authorityResolution.status === "ambiguous",
+                authority_unresolved: objectiveActual &&
+                    (authorityResolution.status !== "resolved" ||
+                        !expectedAuthorityMatches),
+                expected_authority_ref: objectiveActual
+                    ? (compiledExpectedAuthorityRef ?? undefined)
+                    : obligation.expected_authority_ref,
+                semantic_identity: semanticIdentity,
+                advisory_to_machine: semanticIdentity !== null &&
+                    expectedAuthorityMatches &&
+                    objectiveActual &&
+                    externalConfirmationSessionMatchesApplicability(input.contract, outcomeKey, applicabilityRef, confirmation),
+            };
+        });
+    });
+    return {
+        surface,
+        sourceObligationRef,
+        method,
+        capabilityFloor,
+        machineCandidates,
+        externalCandidates,
+    };
+}
+function emitClaimAuthorityResolution(rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, profile, resolution, requiredPolarity) {
+    const { sourceObligationRef, method, surface, capabilityFloor } = profile;
+    if (resolution.status === "external_candidate") {
+        const confirmationRef = resolution.external.confirmation_ref;
+        const expectedAuthorityRef = resolution.external.expected_authority_ref;
+        if (!expectedAuthorityRef) {
+            rows.push(pendingExternalRow(sourceObligationRef, outcomeKey, fullClaim, applicabilityRef, null, null, method, resolution.external.proof_surface, capabilityFloor, confirmationRef));
+            return;
+        }
+        external.push({
+            source_obligation_ref: sourceObligationRef,
+            outcome_key: outcomeKey,
+            claim_ref: fullClaim,
+            local_claim_ref: localClaim,
+            applicability_ref: applicabilityRef,
+            fact_ref: null,
+            proof_ref: null,
+            method,
+            proof_surface: resolution.external.proof_surface,
+            evidence_capabilities: capabilityFloor,
+            expected_authority_ref: expectedAuthorityRef,
+            confirmation_ref: confirmationRef,
+            required_polarity: requiredPolarity,
+            completion_role: "blocking",
+            acceptance_effect: "required",
+            semantic_identity: resolution.external.semantic_identity ?? null,
+            machine_obligation_ref: null,
+        });
+        rows.push(pendingExternalRow(sourceObligationRef, outcomeKey, fullClaim, applicabilityRef, null, null, method, resolution.external.proof_surface, capabilityFloor, confirmationRef));
+        return;
+    }
+    if (resolution.status === "machine_admitted") {
+        const machine = resolution.machine;
+        rows.push({
+            obligation_ref: sourceObligationRef,
+            source_obligation_ref: sourceObligationRef,
+            outcome_key: outcomeKey,
+            claim_ref: fullClaim,
+            applicability_ref: applicabilityRef,
+            fact_ref: null,
+            proof_ref: null,
+            method,
+            proof_surface: machine.proof_surface,
+            required_evidence_capabilities: machine.required_evidence_capabilities,
+            authority: "machine",
+            confirmation_ref: null,
+            status: "machine_admitted",
+            reason: null,
+            session_group: null,
+        });
+        return;
+    }
+    rows.push({
+        ...pendingExternalRow(sourceObligationRef, outcomeKey, fullClaim, applicabilityRef, null, null, method, surface, capabilityFloor, null),
+        authority: "none",
+        status: "unreachable",
+        reason: resolution.reason,
+    });
+}

package/dist/lib/long-task-acceptance-reachability-design.d.ts

@@ -0,0 +1,2 @@
+import type { AcceptanceObligationReachabilityV1, AcceptanceReachabilityInputV1, ExpectedExternalObligation } from "./long-task-acceptance-reachability-types.js";
+export declare function compileDesignFactReachability(input: AcceptanceReachabilityInputV1, rows: AcceptanceObligationReachabilityV1[], external: ExpectedExternalObligation[]): void;

package/dist/lib/long-task-acceptance-reachability-design.js

@@ -0,0 +1,96 @@
+import { designFactObligationDescriptors, externalDesignObligationMatches, } from "./long-task-design-obligation.js";
+import { pendingExternalRow } from "./long-task-acceptance-reachability-helpers.js";
+import { resolveObligationAuthority } from "./long-task-obligation-authority-resolution.js";
+export function compileDesignFactReachability(input, rows, external) {
+    const seen = new Set();
+    for (const descriptor of designFactObligationDescriptors(input.contract)) {
+        if (seen.has(descriptor.source_obligation_ref))
+            throw new Error(`design_obligation_identity_duplicate:${descriptor.source_obligation_ref}`);
+        seen.add(descriptor.source_obligation_ref);
+        const machineCandidates = admittedDesignMachineRoutes(input, descriptor);
+        const externalCandidates = input.contract.global.acceptance.external_confirmations
+            .filter((confirmation) => confirmation.blocks_target &&
+            confirmation.obligations?.some((obligation) => externalDesignObligationMatches(obligation, descriptor)))
+            .map((confirmation) => ({
+            confirmation_ref: confirmation.key,
+            proof_surface: descriptor.proof_surface,
+            method: descriptor.method,
+            required_evidence_capabilities: descriptor.evidence_capabilities,
+        }));
+        const resolution = resolveObligationAuthority({
+            source_obligation_ref: descriptor.source_obligation_ref,
+            proof_surface_selection: "required",
+            machine_candidates: machineCandidates,
+            external_candidates: externalCandidates,
+        });
+        if (resolution.status === "machine_admitted") {
+            rows.push({
+                obligation_ref: descriptor.source_obligation_ref,
+                source_obligation_ref: descriptor.source_obligation_ref,
+                outcome_key: descriptor.outcome_key,
+                claim_ref: descriptor.claim_ref,
+                applicability_ref: descriptor.applicability_ref,
+                fact_ref: descriptor.fact_ref,
+                proof_ref: descriptor.source_obligation_ref,
+                method: descriptor.method,
+                proof_surface: descriptor.proof_surface,
+                required_evidence_capabilities: descriptor.evidence_capabilities,
+                authority: "machine",
+                confirmation_ref: null,
+                status: "machine_admitted",
+                reason: null,
+                session_group: null,
+            });
+            continue;
+        }
+        if (resolution.status === "external_candidate") {
+            const expected = {
+                source_obligation_ref: descriptor.source_obligation_ref,
+                outcome_key: descriptor.outcome_key,
+                claim_ref: descriptor.claim_ref,
+                local_claim_ref: descriptor.local_claim_ref,
+                applicability_ref: descriptor.applicability_ref,
+                fact_ref: descriptor.fact_ref,
+                proof_ref: descriptor.source_obligation_ref,
+                method: descriptor.method,
+                proof_surface: descriptor.proof_surface,
+                evidence_capabilities: descriptor.evidence_capabilities,
+                expected_authority_ref: descriptor.expected_authority_ref,
+                confirmation_ref: resolution.external.confirmation_ref,
+                required_polarity: "positive",
+                completion_role: "blocking",
+                acceptance_effect: "required",
+                semantic_identity: null,
+                machine_obligation_ref: null,
+            };
+            external.push(expected);
+            rows.push(pendingExternalRow(descriptor.source_obligation_ref, descriptor.outcome_key, descriptor.claim_ref, descriptor.applicability_ref, descriptor.fact_ref, descriptor.source_obligation_ref, descriptor.method, descriptor.proof_surface, descriptor.evidence_capabilities, expected.confirmation_ref));
+            continue;
+        }
+        rows.push({
+            ...pendingExternalRow(descriptor.source_obligation_ref, descriptor.outcome_key, descriptor.claim_ref, descriptor.applicability_ref, descriptor.fact_ref, descriptor.source_obligation_ref, descriptor.method, descriptor.proof_surface, descriptor.evidence_capabilities, null),
+            authority: "none",
+            reason: resolution.reason === "no_admitted_proof_route"
+                ? "machine_observer_not_admitted"
+                : resolution.reason,
+        });
+    }
+}
+function admittedDesignMachineRoutes(input, descriptor) {
+    return input.compiled_checks.flatMap((check) => check.outcome_key === descriptor.outcome_key &&
+        check.key === descriptor.check_key &&
+        check.completion_role === "semantic" &&
+        check.observation_authorities.some((authority) => authority.obligation_ref === descriptor.source_obligation_ref &&
+            authority.assertion_ref === descriptor.assertion_ref &&
+            authority.authority !== "external_confirmation")
+        ? [
+            {
+                check_key: check.key,
+                assertion_key: descriptor.assertion_ref,
+                proof_surface: descriptor.proof_surface,
+                method: descriptor.method,
+                required_evidence_capabilities: descriptor.evidence_capabilities,
+            },
+        ]
+        : []);
+}

package/dist/lib/long-task-acceptance-reachability-external.d.ts

@@ -0,0 +1,9 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import type { AcceptanceObligationReachabilityV1, ExpectedExternalObligation } from "./long-task-acceptance-reachability-types.js";
+export declare function validateExternalDeclarations(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, expected: ExpectedExternalObligation[], compiledChecks: readonly CompiledCheckV2[]): Map<string, {
+    obligation_key: string;
+    session_group: string;
+}>;
+export declare function addUnboundBlockingConfirmationRows(contract: DeliveryContractV2, rows: AcceptanceObligationReachabilityV1[], expected: ExpectedExternalObligation[]): void;

package/dist/lib/long-task-acceptance-reachability-external.js

@@ -0,0 +1,123 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+import { effectiveExternalRouteRef, externalConfirmationSessionMatchesApplicability, objectiveExternalActualAdmitted, sameSet, sourceBackedExternalJudgmentAdmitted, } from "./long-task-acceptance-reachability-helpers.js";
+export function validateExternalDeclarations(contract, manifest, expected, compiledChecks) {
+    const result = new Map();
+    for (const confirmation of contract.global.acceptance
+        .external_confirmations) {
+        const expectedRows = expected.filter((row) => row.confirmation_ref === confirmation.key);
+        if (!expectedRows.length)
+            continue;
+        const obligations = confirmation.obligations ?? [];
+        if (!confirmationShapeComplete(confirmation, obligations.length, expectedRows))
+            continue;
+        if (!confirmationSetsMatch(confirmation, obligations, expectedRows))
+            continue;
+        const matched = matchConfirmationRows(contract, manifest, compiledChecks, confirmation, obligations, expectedRows);
+        if (!matched)
+            continue;
+        const sessionGroup = sha256Hex(canonicalValueJson({
+            owner: confirmation.owner,
+            actor: confirmation.actor,
+            target_ref: confirmation.target_ref,
+            environment_identity: confirmation.environment_identity,
+            scenario: confirmation.scenario,
+            evidence_requirements: confirmation.evidence_requirements,
+        }));
+        for (const match of matched)
+            result.set(effectiveExternalRouteRef(confirmation.key, match.source_obligation_ref), {
+                obligation_key: match.obligation_key,
+                session_group: sessionGroup,
+            });
+    }
+    return result;
+}
+export function addUnboundBlockingConfirmationRows(contract, rows, expected) {
+    for (const confirmation of contract.global.acceptance
+        .external_confirmations) {
+        if (!confirmation.blocks_target ||
+            confirmationFullyProjected(confirmation, expected))
+            continue;
+        const claimRef = confirmation.impact_claims[0] ?? "GLOBAL.unbound";
+        const outcomeKey = contract.outcomes.find((outcome) => claimRef === outcome.key || claimRef.startsWith(`${outcome.key}.`))?.key ?? null;
+        rows.push({
+            obligation_ref: `external-confirmation:${confirmation.key}`,
+            source_obligation_ref: `external-confirmation:${confirmation.key}`,
+            outcome_key: outcomeKey,
+            claim_ref: claimRef,
+            applicability_ref: "unbound",
+            fact_ref: null,
+            proof_ref: null,
+            method: "unbound",
+            proof_surface: "runtime_behavior",
+            required_evidence_capabilities: [],
+            authority: "external_confirmation",
+            confirmation_ref: confirmation.key,
+            status: "unreachable",
+            reason: "blocking_confirmation_has_no_exact_proof_obligations",
+            session_group: null,
+        });
+    }
+}
+function confirmationFullyProjected(confirmation, expected) {
+    const obligations = confirmation.obligations ?? [];
+    if (!obligations.length)
+        return false;
+    const expectedRows = expected.filter((row) => row.confirmation_ref === confirmation.key);
+    return (expectedRows.length === obligations.length &&
+        new Set(obligations.map((obligation) => obligation.key)).size ===
+            obligations.length &&
+        sameSet(confirmation.impact_claims, [
+            ...new Set(obligations.map((obligation) => obligation.claim_ref)),
+        ]));
+}
+function confirmationShapeComplete(confirmation, obligationCount, expectedRows) {
+    const requiresBlockingAssurance = expectedRows.some((row) => row.completion_role === "blocking");
+    return Boolean(confirmation.actor &&
+        (!requiresBlockingAssurance ||
+            confirmation.actor.identity_assurance?.scheme === "ed25519") &&
+        confirmation.target_ref &&
+        confirmation.environment_identity &&
+        confirmation.scenario?.given.length &&
+        confirmation.scenario.when.length &&
+        confirmation.evidence_requirements?.length &&
+        obligationCount);
+}
+function confirmationSetsMatch(confirmation, obligations, expectedRows) {
+    return (new Set(obligations.map((row) => row.key)).size === obligations.length &&
+        sameSet(confirmation.impact_claims, [
+            ...new Set(obligations.map((row) => row.claim_ref)),
+        ]) &&
+        obligations.length === expectedRows.length);
+}
+function matchConfirmationRows(contract, manifest, compiledChecks, confirmation, obligations, expectedRows) {
+    const used = new Set();
+    const matched = [];
+    for (const expectedRow of expectedRows) {
+        const candidates = obligations.filter((actual) => externalObligationMatches(actual, expectedRow));
+        const actual = candidates[0];
+        if (candidates.length !== 1 || !actual || used.has(actual.key))
+            return null;
+        const sessionMatches = externalConfirmationSessionMatchesApplicability(contract, expectedRow.outcome_key, expectedRow.applicability_ref, confirmation);
+        const resultKindAdmitted = actual.result_kind === "judgment"
+            ? sourceBackedExternalJudgmentAdmitted(contract, manifest, expectedRow, actual.judgment_basis, confirmation.actor?.authority_kind)
+            : objectiveExternalActualAdmitted(contract, manifest, expectedRow, compiledChecks) && actual.judgment_basis === undefined;
+        if (!sessionMatches || !resultKindAdmitted)
+            return null;
+        used.add(actual.key);
+        matched.push({
+            source_obligation_ref: expectedRow.source_obligation_ref,
+            obligation_key: actual.key,
+        });
+    }
+    return used.size === obligations.length ? matched : null;
+}
+function externalObligationMatches(actual, expected) {
+    return (actual.claim_ref === expected.claim_ref &&
+        actual.applicability_ref === expected.applicability_ref &&
+        actual.fact_ref === expected.fact_ref &&
+        actual.proof_ref === expected.proof_ref &&
+        actual.method === expected.method &&
+        actual.proof_surface === expected.proof_surface &&
+        sameSet(actual.evidence_capabilities, expected.evidence_capabilities) &&
+        actual.expected_authority_ref === expected.expected_authority_ref);
+}

package/dist/lib/long-task-acceptance-reachability-helpers.d.ts

@@ -0,0 +1,64 @@
+import type { ClaimApplicabilityV2, CompiledCheckV2, CompiledObservationAuthorityV2, DeliveryCheckV2, DeliveryContractV2, EvidenceCapabilityV2, ProofSurface } from "./long-task-delivery-types.js";
+import type { AcceptanceObligationReachabilityV1, ExpectedExternalObligation } from "./long-task-acceptance-reachability-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function claimProofMethod(capabilities: readonly EvidenceCapabilityV2[]): string;
+export declare function claimObligationRef(fullClaim: string, applicabilityRef: string, surface: ProofSurface): string;
+export declare function effectiveExternalRouteRef(confirmationRef: string, sourceObligationRef: string): string;
+export interface MachineAuthorizedAssertionQueryV1 {
+    authority_scope: "ordinary_claim" | "fact_bound" | "any";
+    outcome_key?: string | null;
+    check_key?: string;
+    assertion_key?: string;
+    local_claim_ref?: string;
+    applicability_ref?: string;
+    target_ref?: string;
+    check_journey_role?: ClaimApplicabilityV2["journey_role"];
+    proof_surface?: ProofSurface;
+    polarity?: "positive" | "negative";
+    required_evidence_capability?: EvidenceCapabilityV2;
+}
+export interface MachineAuthorizedAssertionV1 {
+    check: CompiledCheckV2;
+    assertion: CompiledCheckV2["positive_assertions"][number];
+    authority: CompiledObservationAuthorityV2;
+    polarity: "positive" | "negative";
+}
+export declare function machineAuthorizedAssertions(checks: readonly CompiledCheckV2[], query: MachineAuthorizedAssertionQueryV1): MachineAuthorizedAssertionV1[];
+export declare function machineAuthorizedAssertionExists(checks: readonly CompiledCheckV2[], query: MachineAuthorizedAssertionQueryV1): boolean;
+export declare function machineProofAdmitted(checks: CompiledCheckV2[], outcomeKey: string | null, checkKey: string, assertionKey: string, localClaim: string): boolean;
+export declare function objectiveMachineClaimActualAuthority(checks: readonly CompiledCheckV2[], outcomeKey: string | null, checkKey: string, assertionKey: string, localClaim: string): CompiledObservationAuthorityV2 | null;
+export declare function pendingExternalRow(sourceObligationRef: string, outcomeKey: string | null, claimRef: string, applicabilityRef: string, factRef: string | null, proofRef: string | null, method: string, proofSurface: ProofSurface, capabilities: EvidenceCapabilityV2[], confirmationRef: string | null): AcceptanceObligationReachabilityV1;
+export declare function selectOptionalSurface(proofs: Array<{
+    proof_surface: ProofSurface;
+    check_key: string;
+}>): ProofSurface;
+export declare function applicabilityProfile(contract: DeliveryContractV2, outcomeKey: string | null, applicabilityRef: string): ClaimApplicabilityV2 | null;
+export declare function externalConfirmationSessionMatchesApplicability(contract: DeliveryContractV2, outcomeKey: string | null, applicabilityRef: string, confirmation: DeliveryContractV2["global"]["acceptance"]["external_confirmations"][number]): boolean;
+export declare function objectiveExternalActualAdmitted(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, expected: ExpectedExternalObligation, compiledChecks?: readonly CompiledCheckV2[]): boolean;
+export declare function exactExternalClaimActualObligationRefsByAssertion(contract: DeliveryContractV2, outcomeKey: string | null, check: DeliveryCheckV2, expectedAuthorityRefs: Readonly<Record<string, string>>): ReadonlyMap<string, string>;
+export declare function objectiveExternalClaimActualAuthority(compiledChecks: readonly CompiledCheckV2[], expected: Pick<ExpectedExternalObligation, "source_obligation_ref" | "outcome_key" | "claim_ref" | "fact_ref" | "proof_ref" | "method" | "proof_surface"> & {
+    local_claim_ref?: string;
+}): CompiledObservationAuthorityV2 | null;
+export type ObjectiveExternalClaimActualAuthorityResolutionV1 = {
+    status: "resolved";
+    check: CompiledCheckV2;
+    authority: CompiledObservationAuthorityV2;
+    expected_authority_ref: string;
+} | {
+    status: "missing";
+} | {
+    status: "ambiguous";
+};
+export declare function resolveObjectiveExternalClaimActualAuthority(compiledChecks: readonly CompiledCheckV2[], expected: Pick<ExpectedExternalObligation, "source_obligation_ref" | "outcome_key" | "claim_ref" | "fact_ref" | "proof_ref" | "method" | "proof_surface"> & {
+    local_claim_ref?: string;
+}): ObjectiveExternalClaimActualAuthorityResolutionV1;
+export declare function admittedObjectiveExternalComparator(manifest: SemanticFactManifestV1, factRef: string, proofRef: string): "exact_value" | "population_set_equal" | null;
+export declare function objectivePopulationSet(value: unknown): value is string[];
+type JudgmentExpectedObligation = Pick<ExpectedExternalObligation, "claim_ref" | "applicability_ref" | "fact_ref" | "proof_ref" | "method" | "proof_surface"> & {
+    confirmation_ref: string | null;
+    evidence_capabilities?: readonly EvidenceCapabilityV2[];
+    required_evidence_capabilities?: readonly EvidenceCapabilityV2[];
+};
+export declare function sourceBackedExternalJudgmentAdmitted(contract: Pick<DeliveryContractV2, "source_claims" | "global">, manifest: SemanticFactManifestV1, expected: JudgmentExpectedObligation, basis: NonNullable<DeliveryContractV2["global"]["acceptance"]["external_confirmations"][number]["obligations"]>[number]["judgment_basis"] | undefined, actorKind: "human" | "expert" | "external_system" | undefined): boolean;
+export declare function sameSet(left: readonly string[], right: readonly string[]): boolean;
+export {};