project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/long-task-obligation-semantic-identity.js

@@ -0,0 +1,116 @@
+import { findDesignFactObligation } from "./long-task-design-obligation.js";
+import { canonicalApplicabilityIdentity, claimApplicabilityProfile, } from "./long-task-applicability-identity.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function objectiveClaimSemanticIdentity(input) {
+    const authority = input.observation_authority;
+    const applicability = claimApplicabilityProfile(input.contract, input.outcome_key, input.applicability_ref);
+    const requiredCapabilities = [
+        ...new Set(input.required_evidence_capabilities),
+    ].sort();
+    if (!applicability ||
+        authority.fact_ref !== null ||
+        authority.claim_refs.length !== 1 ||
+        authority.claim_refs[0] !== input.local_claim_ref ||
+        authority.target_ref !== applicability.target_ref ||
+        authority.method !== input.method ||
+        !requiredCapabilities.every((capability) => authority.evidence_capabilities.includes(capability)) ||
+        !exactObservationAuthorityShape(authority))
+        return null;
+    return sha256Hex(canonicalValueJson({
+        claim_ref: input.claim_ref,
+        local_claim_ref: input.local_claim_ref,
+        applicability_identity: canonicalApplicabilityIdentity(applicability),
+        target_ref: applicability.target_ref,
+        required_polarity: input.required_polarity,
+        expected_authority_ref: input.expected_authority_ref,
+        expected_value_sha256: authority.expected_value_sha256,
+        actual_projection: authority.actual_projection,
+        method: input.method,
+        required_evidence_capabilities: requiredCapabilities,
+        comparison: authority.comparison,
+    }));
+}
+export function effectiveExternalObligationSemanticIdentity(input, expected) {
+    if (expected.semantic_identity)
+        return expected.semantic_identity;
+    const applicability = claimApplicabilityProfile(input.contract, expected.outcome_key, expected.applicability_ref);
+    if (!applicability)
+        return null;
+    const common = {
+        source_obligation_ref: expected.source_obligation_ref,
+        claim_ref: expected.claim_ref,
+        local_claim_ref: expected.local_claim_ref,
+        applicability_identity: canonicalApplicabilityIdentity(applicability),
+        target_ref: applicability.target_ref,
+        required_polarity: expected.required_polarity,
+        expected_authority_ref: expected.expected_authority_ref,
+        method: expected.method,
+        required_evidence_capabilities: [
+            ...new Set(expected.evidence_capabilities),
+        ].sort(),
+    };
+    if (expected.fact_ref && expected.proof_ref) {
+        const design = findDesignFactObligation(input.contract, expected);
+        if (design)
+            return sha256Hex(canonicalValueJson({
+                kind: "design_fact",
+                ...common,
+                design_obligation_ref: design.source_obligation_ref,
+                design_target_ref: design.target_key,
+                fact_ref: design.fact_ref,
+                proof_ref: design.source_obligation_ref,
+                expected_design_sha256: design.expected.sha256,
+                actual_projection: "raw_exact",
+                comparison: {
+                    comparator: design.comparison.comparator,
+                    mode: design.comparison.mode,
+                    parameters_sha256: design.comparison.parameters.sha256,
+                    tolerance_sha256: design.comparison.tolerance?.sha256 ?? null,
+                    mask_sha256: design.comparison.mask?.sha256 ?? null,
+                },
+            }));
+        const fact = input.manifest.facts.find((candidate) => candidate.key === expected.fact_ref);
+        const proof = input.manifest.proof_obligations.find((candidate) => candidate.key === expected.proof_ref &&
+            candidate.fact_ref === expected.fact_ref);
+        if (fact && proof)
+            return sha256Hex(canonicalValueJson({
+                kind: "semantic_fact",
+                ...common,
+                fact_ref: fact.key,
+                proof_ref: proof.key,
+                expected_value_sha256: fact.expected.sha256,
+                actual_projection: "raw_exact",
+                comparison: {
+                    comparator: proof.comparison.comparator,
+                    mode: proof.comparison.mode,
+                    parameters_sha256: proof.comparison.parameters.sha256,
+                    tolerance_sha256: proof.comparison.tolerance?.sha256 ?? null,
+                    mask_sha256: proof.comparison.mask?.sha256 ?? null,
+                },
+            }));
+        return null;
+    }
+    if (expected.fact_ref || expected.proof_ref)
+        return null;
+    return sha256Hex(canonicalValueJson({
+        kind: "source_delegated_judgment",
+        ...common,
+        expected_value_sha256: null,
+        actual_projection: null,
+        comparison: null,
+    }));
+}
+function exactObservationAuthorityShape(authority) {
+    return Boolean(typeof authority.expected_value_sha256 === "string" &&
+        /^[a-f0-9]{64}$/u.test(authority.expected_value_sha256) &&
+        typeof authority.actual_projection === "string" &&
+        authority.comparison &&
+        typeof authority.comparison.comparator === "string" &&
+        typeof authority.comparison.mode === "string" &&
+        sha256OrNull(authority.comparison.parameters_sha256) &&
+        sha256OrNull(authority.comparison.tolerance_sha256) &&
+        sha256OrNull(authority.comparison.mask_sha256));
+}
+function sha256OrNull(value) {
+    return value === null || /^[a-f0-9]{64}$/u.test(value);
+}

package/dist/lib/long-task-observation-authority.d.ts

@@ -12,6 +12,17 @@ interface CompileObservationAuthorityPlanInput {
     source_backed_execution_target: SourceBackedExecutionTargetV2 | null;
     workspace_manifest: WorkspaceManifestV2;
     protected_authority_paths?: readonly string[];
+    external_design_obligation_refs?: ReadonlySet<string>;
+    external_claim_obligation_refs_by_assertion?: ReadonlyMap<string, string>;
 }
 export declare function compileObservationAuthorityPlan(input: CompileObservationAuthorityPlanInput): CompiledObservationAuthorityV2[];
+export declare function projectExternallyOwnedDesignAssertions(check: DeliveryCheckV2, designTargets: CompiledDesignTargetV2[], machineAuthorities: CompiledObservationAuthorityV2[], externalDesignObligationRefs: ReadonlySet<string>): {
+    check: DeliveryCheckV2;
+    removed_assertion_refs: Set<string>;
+};
+export declare function projectExternallyOwnedClaimAssertions(check: DeliveryCheckV2, observationAuthorities: CompiledObservationAuthorityV2[], externalClaimObligationRefsByAssertion: ReadonlyMap<string, string>): {
+    check: DeliveryCheckV2;
+    removed_assertion_refs: Set<string>;
+};
+export declare function assertionObligationRef(outcomeKey: string | null, checkKey: string, assertionKey: string): string;
 export {};

package/dist/lib/long-task-observation-authority.js

@@ -1,5 +1,6 @@
 import { JSON_POINTER_EXACT_METHODS, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
 import { classifyMachineObservationCarrierRoleConflict } from "./long-task-admitted-observation.js";
+import { designGroundObligationRef } from "./long-task-design-obligation.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { classifyRepositoryPatternOverlap, normalizeRepositoryFile, } from "./long-task-paths.js";
 const PROCESS_DERIVED_CAPABILITIES = new Set([
@@ -106,7 +107,8 @@ export function compileObservationAuthorityPlan(input) {
         if (factBoundAssertions.has(assertion.key))
             continue;
         const expected = exactAssertionExpected(assertion);
-        const obligationRef = assertionObligationRef(input.outcome_key, input.check.key, assertion.key);
+        const obligationRef = input.external_claim_obligation_refs_by_assertion?.get(assertion.key) ??
+            assertionObligationRef(input.outcome_key, input.check.key, assertion.key);
         candidates.push({
             obligation_ref: obligationRef,
             observation_identity: obligationRef,
@@ -115,6 +117,7 @@ export function compileObservationAuthorityPlan(input) {
             target_ref: input.check.execution_target.target_ref,
             method: "exact_value",
             expected_value_sha256: sha256Hex(canonicalValueJson(expected)),
+            expected_value: expected,
             actual_projection: assertionActualProjection(assertion),
             comparison: {
                 comparator: "exact_value",
@@ -127,10 +130,89 @@ export function compileObservationAuthorityPlan(input) {
             diagnostic_scope: "assertion",
         });
     }
-    const rows = candidates.map((candidate) => compileCandidate(input, candidate));
+    const rows = candidates.flatMap((candidate) => {
+        try {
+            return [compileCandidate(input, candidate)];
+        }
+        catch (error) {
+            const exactExternalDesign = candidate.diagnostic_scope === "design_fact" &&
+                input.external_design_obligation_refs?.has(candidate.obligation_ref);
+            const exactExternalClaim = candidate.diagnostic_scope === "assertion" &&
+                input.external_claim_obligation_refs_by_assertion?.get(candidate.assertion.key) === candidate.obligation_ref;
+            if ((exactExternalDesign || exactExternalClaim) &&
+                externalizableObservationError(error))
+                return [compileExternalCandidate(input, candidate)];
+            throw error;
+        }
+    });
     assertUniqueRows(rows);
     return rows.sort((left, right) => canonicalValueJson(left).localeCompare(canonicalValueJson(right)));
 }
+export function projectExternallyOwnedDesignAssertions(check, designTargets, machineAuthorities, externalDesignObligationRefs) {
+    const obligationsByAssertion = new Map();
+    const add = (assertionRef, obligationRef) => {
+        const refs = obligationsByAssertion.get(assertionRef) ?? [];
+        refs.push(obligationRef);
+        obligationsByAssertion.set(assertionRef, refs);
+    };
+    for (const target of designTargets) {
+        for (const binding of target.verification_method_bindings)
+            for (const artifact of binding.evidence_artifacts)
+                for (const expectation of artifact.fact_expectations)
+                    add(binding.assertion_ref, designGroundObligationRef(target.key, binding.method, artifact.condition_key, expectation.fact_ref));
+        for (const binding of target.symbolic_method_bindings ?? [])
+            for (const expectation of binding.rule_expectations)
+                add(binding.assertion_ref, expectation.obligation_ref);
+    }
+    const machineRefs = new Set(machineAuthorities
+        .filter((authority) => authority.authority !== "external_confirmation")
+        .map((authority) => authority.obligation_ref));
+    const removed = new Set();
+    for (const [assertionRef, refs] of obligationsByAssertion) {
+        const externalRefs = refs.filter((ref) => externalDesignObligationRefs.has(ref));
+        if (!externalRefs.length)
+            continue;
+        const admittedMachineRefs = refs.filter((ref) => machineRefs.has(ref));
+        if (admittedMachineRefs.length === refs.length)
+            continue;
+        if (!admittedMachineRefs.length && externalRefs.length === refs.length) {
+            removed.add(assertionRef);
+            continue;
+        }
+        fail("mixed_machine_external_design_assertion", `${check.key}:${assertionRef}:${refs.join(",")}`);
+    }
+    if (!removed.size)
+        return { check, removed_assertion_refs: removed };
+    return {
+        check: {
+            ...check,
+            positive_assertions: check.positive_assertions.filter((assertion) => !removed.has(assertion.key)),
+            negative_assertions: check.negative_assertions.filter((assertion) => !removed.has(assertion.key)),
+        },
+        removed_assertion_refs: removed,
+    };
+}
+export function projectExternallyOwnedClaimAssertions(check, observationAuthorities, externalClaimObligationRefsByAssertion) {
+    const removed = new Set();
+    for (const [assertionRef, obligationRef,] of externalClaimObligationRefsByAssertion) {
+        const authorities = observationAuthorities.filter((authority) => authority.assertion_ref === assertionRef &&
+            authority.obligation_ref === obligationRef);
+        if (authorities.some((authority) => authority.authority !== "external_confirmation"))
+            continue;
+        if (authorities.some((authority) => authority.authority === "external_confirmation"))
+            removed.add(assertionRef);
+    }
+    if (!removed.size)
+        return { check, removed_assertion_refs: removed };
+    return {
+        check: {
+            ...check,
+            positive_assertions: check.positive_assertions.filter((assertion) => !removed.has(assertion.key)),
+            negative_assertions: check.negative_assertions.filter((assertion) => !removed.has(assertion.key)),
+        },
+        removed_assertion_refs: removed,
+    };
+}
 function compileCandidate(input, candidate) {
     const unimplementedDerivedCapability = candidate.assertion.evidence_capabilities.find((capability) => PROCESS_CAPABILITIES_REQUIRING_A_SEPARATE_PACKAGE_DERIVATION.has(capability));
     if (unimplementedDerivedCapability)
@@ -198,6 +280,46 @@ function compileCandidate(input, candidate) {
         runtime_requirements: runtimeRequirements(input),
     };
 }
+function compileExternalCandidate(input, candidate) {
+    const carrierRefs = [];
+    const comparison = candidate.comparison;
+    const expectedIdentity = sha256Hex(canonicalValueJson({
+        obligation_ref: candidate.obligation_ref,
+        fact_ref: candidate.fact_ref,
+        method: candidate.method,
+        expected_value_sha256: candidate.expected_value_sha256,
+        comparison,
+        actual_projection: candidate.actual_projection,
+        carrier_refs: carrierRefs,
+    }));
+    return {
+        obligation_ref: candidate.obligation_ref,
+        fact_ref: candidate.fact_ref,
+        assertion_ref: candidate.assertion.key,
+        claim_refs: [...candidate.assertion.claims].sort(),
+        target_ref: candidate.target_ref,
+        proof_surface: input.check.proof_surface,
+        method: candidate.method,
+        evidence_capabilities: [
+            ...candidate.assertion.evidence_capabilities,
+        ].sort(),
+        authority: "external_confirmation",
+        expected_identity: expectedIdentity,
+        expected_value_sha256: candidate.expected_value_sha256,
+        ...(Object.hasOwn(candidate, "expected_value")
+            ? { expected_value: candidate.expected_value }
+            : {}),
+        actual_projection: candidate.actual_projection,
+        observation_identity: candidate.observation_identity,
+        comparison,
+        locator_policy: {
+            kind: "fixed_json_pointer",
+            value: observationPointer(candidate.observation_identity),
+        },
+        carrier_refs: carrierRefs,
+        runtime_requirements: runtimeRequirements(input),
+    };
+}
 function selectAuthority(input, candidate) {
     const target = input.execution_target;
     if (target.role !== "product")
@@ -325,11 +447,20 @@ function requiredAssertion(assertions, assertionRef, diagnostic) {
         throw new Error(diagnostic);
     return assertion;
 }
-function assertionObligationRef(outcomeKey, checkKey, assertionKey) {
-    return `assertion.${outcomeKey ?? "GLOBAL"}.${checkKey}.${assertionKey}`;
+function externalizableObservationError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return [
+        "unsupported_observer_requires_external_confirmation:",
+        "custom_oracle_machine_completion_forbidden:",
+        "machine_observer_not_admitted:",
+        "process_observer_direct_root_required:",
+        "process_observer_root_invocation_required:",
+        "process_observer_root_argv_mismatch:",
+    ].some((prefix) => error.message.startsWith(prefix));
 }
-function designGroundObligationRef(targetKey, method, conditionKey, factRef) {
-    return `design.${targetKey}.${method}.${conditionKey}.${factRef}`;
+export function assertionObligationRef(outcomeKey, checkKey, assertionKey) {
+    return `assertion.${outcomeKey ?? "GLOBAL"}.${checkKey}.${assertionKey}`;
 }
 function observationPointer(identity) {
     return `/observations/${identity.replace(/~/gu, "~0").replace(/\//gu, "~1")}`;

package/dist/lib/long-task-process-table.d.ts

@@ -0,0 +1,9 @@
+export interface ProcessInstance {
+    pid: number;
+    parent_pid: number;
+}
+export declare function processSnapshot(): Promise<ProcessInstance[]>;
+export declare function descendantsOf(rootPid: number, snapshot: readonly ProcessInstance[]): ProcessInstance[];
+export declare function liveProcessInstances(candidates: readonly ProcessInstance[]): ProcessInstance[];
+export declare function rootProcessAlive(rootPid: number): boolean;
+export declare function uniqueProcessInstances(instances: readonly ProcessInstance[]): ProcessInstance[];

package/dist/lib/long-task-process-table.js

@@ -0,0 +1,87 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const PROCESS_TABLE_OUTPUT_LIMIT = 2 * 1024 * 1024;
+const execFileAsync = promisify(execFile);
+export async function processSnapshot() {
+    assertNonWindowsProcessTree();
+    let stdout;
+    try {
+        const result = await execFileAsync("ps", ["-A", "-o", "pid=,ppid="], {
+            encoding: "utf8",
+            timeout: 5_000,
+            maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT,
+        });
+        stdout = result.stdout;
+    }
+    catch (error) {
+        throw new Error(`process_observer_process_tree_inspection_unavailable:${message(error)}`);
+    }
+    const rows = [];
+    for (const line of stdout.split(/\r?\n/u)) {
+        const [pidText, parentText] = line.trim().split(/\s+/u);
+        const pid = Number.parseInt(pidText ?? "", 10);
+        const parent = Number.parseInt(parentText ?? "", 10);
+        if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parent))
+            continue;
+        rows.push({ pid, parent_pid: parent });
+    }
+    return rows;
+}
+export function descendantsOf(rootPid, snapshot) {
+    const children = new Map();
+    for (const processInstance of snapshot) {
+        const row = children.get(processInstance.parent_pid);
+        if (row)
+            row.push(processInstance);
+        else
+            children.set(processInstance.parent_pid, [processInstance]);
+    }
+    const result = [];
+    const pending = [...(children.get(rootPid) ?? [])];
+    const seen = new Set();
+    while (pending.length) {
+        const processInstance = pending.shift();
+        if (seen.has(processInstance.pid))
+            continue;
+        seen.add(processInstance.pid);
+        result.push(processInstance);
+        pending.push(...(children.get(processInstance.pid) ?? []));
+    }
+    return result;
+}
+export function liveProcessInstances(candidates) {
+    assertNonWindowsProcessTree();
+    return candidates.filter((candidate) => processIdExists(candidate.pid));
+}
+export function rootProcessAlive(rootPid) {
+    assertNonWindowsProcessTree();
+    return processIdExists(rootPid);
+}
+export function uniqueProcessInstances(instances) {
+    return [
+        ...new Map(instances.map((instance) => [instance.pid, instance])).values(),
+    ];
+}
+function processIdExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (nodeErrorCode(error) === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+function assertNonWindowsProcessTree() {
+    if (process.platform === "win32")
+        throw new Error("process_observer_windows_job_required");
+}
+function nodeErrorCode(error) {
+    return error && typeof error === "object" && "code" in error
+        ? String(error.code)
+        : null;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-process-tree.d.ts

@@ -0,0 +1,8 @@
+export interface ProcessTreeObserver {
+    stop(): void;
+    wait(): Promise<void>;
+    terminate(force: boolean): Promise<void>;
+    forceQuiescence(): Promise<void>;
+    assertQuiescent(): Promise<void>;
+}
+export declare function createProcessTreeObserver(rootPid: number): ProcessTreeObserver;

package/dist/lib/long-task-process-tree.js

@@ -0,0 +1,108 @@
+import { descendantsOf, liveProcessInstances, processSnapshot, rootProcessAlive, uniqueProcessInstances, } from "./long-task-process-table.js";
+const PROCESS_TREE_GRACE_MS = 1_000;
+export function createProcessTreeObserver(rootPid) {
+    if (process.platform === "win32")
+        throw new Error("process_observer_windows_job_required");
+    let stopped = false;
+    const observed = new Map();
+    const monitor = observe();
+    return {
+        stop() {
+            stopped = true;
+        },
+        wait() {
+            return monitor;
+        },
+        terminate(force) {
+            return terminateProcessTree(rootPid, force, [...observed.values()], true);
+        },
+        forceQuiescence() {
+            return forceProcessTreeQuiescence(rootPid, observed);
+        },
+        assertQuiescent() {
+            return assertProcessTreeQuiescent(rootPid, observed);
+        },
+    };
+    async function observe() {
+        do {
+            const snapshot = await processSnapshot();
+            if (snapshot.some((entry) => entry.pid === rootPid))
+                for (const descendant of descendantsOf(rootPid, snapshot))
+                    observed.set(descendant.pid, descendant);
+            if (stopped)
+                return;
+            await delay(25);
+        } while (!stopped);
+    }
+}
+async function forceProcessTreeQuiescence(rootPid, observed) {
+    await terminateProcessTree(rootPid, true, [...observed.values()], true);
+    const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
+    while (Date.now() < deadline) {
+        const rootAlive = rootProcessAlive(rootPid);
+        const descendantsAlive = liveProcessInstances([
+            ...observed.values(),
+        ]).length;
+        const groupAlive = processGroupExists(rootPid);
+        if (!rootAlive && descendantsAlive === 0 && !groupAlive)
+            return;
+        await delay(25);
+    }
+    throw new Error("process_observer_descendant_process_alive");
+}
+async function assertProcessTreeQuiescent(rootPid, observed) {
+    const snapshot = await processSnapshot();
+    const finalDescendants = snapshot.some((entry) => entry.pid === rootPid)
+        ? descendantsOf(rootPid, snapshot)
+        : [];
+    const candidates = uniqueProcessInstances([
+        ...observed.values(),
+        ...finalDescendants,
+    ]);
+    const descendants = liveProcessInstances(candidates);
+    if (!descendants.length && !processGroupExists(rootPid))
+        return;
+    await terminateProcessTree(rootPid, true, descendants, false);
+    throw new Error("process_observer_descendant_process_alive");
+}
+async function terminateProcessTree(rootPid, force, knownDescendants, includeRoot) {
+    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
+        return;
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    if (includeRoot)
+        try {
+            process.kill(-rootPid, signal);
+        }
+        catch (error) {
+            if (nodeErrorCode(error) !== "ESRCH")
+                throw error;
+        }
+    const descendants = liveProcessInstances(knownDescendants);
+    for (const descendant of descendants.reverse())
+        try {
+            process.kill(descendant.pid, signal);
+        }
+        catch (error) {
+            if (nodeErrorCode(error) !== "ESRCH")
+                throw error;
+        }
+}
+function processGroupExists(rootPid) {
+    try {
+        process.kill(-rootPid, 0);
+        return true;
+    }
+    catch (error) {
+        if (nodeErrorCode(error) === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+function nodeErrorCode(error) {
+    return error && typeof error === "object" && "code" in error
+        ? String(error.code)
+        : null;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/lib/long-task-proof-adequacy.d.ts

@@ -0,0 +1,12 @@
+import type { DeliveryContractV2, EvidenceCapabilityV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export { externalClaimCapabilityFloor } from "./long-task-proof-capability-floor.js";
+export type CheckCompletionRoleV2 = "semantic" | "diagnostic";
+export interface CheckProofAdequacyV2 {
+    completion_role: CheckCompletionRoleV2;
+    expected_authority_refs: Record<string, string>;
+    required_evidence_capabilities: Record<string, EvidenceCapabilityV2[]>;
+}
+export type ProofAdequacyByCheckV2 = Record<string, CheckProofAdequacyV2>;
+export declare function proofAdequacyCheckKey(outcomeKey: string | null, checkKey: string): string;
+export declare function validateLongTaskProofAdequacy(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, expectationsByCheck: ReadonlyMap<string, SemanticFactExpectationV2[]>): ProofAdequacyByCheckV2;

package/dist/lib/long-task-proof-adequacy.js

@@ -0,0 +1,57 @@
+import { generateClaims, generateGlobalClaims, } from "./long-task-claim-definitions.js";
+import { assertionCapabilityFloor } from "./long-task-proof-capability-floor.js";
+import { claimSemanticCapabilityFloor } from "./long-task-claim-semantic-proof-floor.js";
+import { resolveExpectedAuthority } from "./long-task-expected-authority.js";
+import { validateSemanticFactProofFloors } from "./long-task-semantic-proof-adequacy.js";
+export { externalClaimCapabilityFloor } from "./long-task-proof-capability-floor.js";
+export function proofAdequacyCheckKey(outcomeKey, checkKey) {
+    return `${outcomeKey ?? "GLOBAL"}:${checkKey}`;
+}
+export function validateLongTaskProofAdequacy(contract, manifest, expectationsByCheck) {
+    validateSemanticFactProofFloors(manifest);
+    const result = {};
+    const globalClaims = new Map(generateGlobalClaims(contract.global).map((claim) => [
+        claim.local_key,
+        claim,
+    ]));
+    for (const check of contract.global.acceptance.checks)
+        result[proofAdequacyCheckKey(null, check.key)] = validateCheck(contract, null, check, globalClaims, manifest, expectationsByCheck.get(check.key) ?? []);
+    for (const outcome of contract.outcomes) {
+        const claims = new Map(generateClaims(outcome).map((claim) => [claim.local_key, claim]));
+        for (const check of outcome.acceptance.checks)
+            result[proofAdequacyCheckKey(outcome.key, check.key)] = validateCheck(contract, outcome.key, check, claims, manifest, expectationsByCheck.get(check.key) ?? []);
+    }
+    return result;
+}
+function validateCheck(contract, outcomeKey, check, claims, manifest, expectations) {
+    const assertions = [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ];
+    const claimBearing = assertions.filter((assertion) => assertion.claims.length);
+    const expectedAuthorityRefs = {};
+    const requiredCapabilities = {};
+    for (const assertion of claimBearing) {
+        const claimRef = assertion.claims[0];
+        const claim = claims.get(claimRef);
+        if (!claim)
+            fail("proof_adequacy_claim_unknown", `${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}:${claimRef}`);
+        expectedAuthorityRefs[assertion.key] = resolveExpectedAuthority(contract, outcomeKey, assertion, manifest, expectations);
+        const required = assertionCapabilityFloor(contract, outcomeKey, check, assertion, claim, expectations, claimSemanticCapabilityFloor(contract, manifest, outcomeKey, claimRef, assertion.applicability_ref ?? null, "kind" in claim ? claim.kind : undefined, "required_proof_surfaces" in claim ? claim.required_proof_surfaces : []));
+        requiredCapabilities[assertion.key] = [...required].sort();
+        const missing = [...required].filter((capability) => !assertion.evidence_capabilities.includes(capability));
+        if (missing.length)
+            fail("proof_adequacy_capability_missing", `${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}:${missing.sort().join(",")}`);
+        if (required.has("population_coverage") &&
+            assertion.operator !== "set_equals")
+            fail("population_coverage_set_equality_required", `${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}`);
+    }
+    return {
+        completion_role: claimBearing.length ? "semantic" : "diagnostic",
+        expected_authority_refs: expectedAuthorityRefs,
+        required_evidence_capabilities: requiredCapabilities,
+    };
+}
+function fail(code, detail) {
+    throw new Error(`delivery_contract_invalid:${code}:${detail}`);
+}

package/dist/lib/long-task-proof-capability-floor.d.ts

@@ -0,0 +1,6 @@
+import type { DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, EvidenceCapabilityV2, ProductClaimV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
+export declare function assertionCapabilityFloor(contract: DeliveryContractV2, outcomeKey: string | null, check: DeliveryCheckV2, assertion: DeliveryAssertionV2, claim: ProductClaimV2 | {
+    kind?: string;
+    local_key: string;
+}, expectations: SemanticFactExpectationV2[], semanticClaimFloor?: ReadonlySet<EvidenceCapabilityV2>): Set<EvidenceCapabilityV2>;
+export declare function externalClaimCapabilityFloor(contract: DeliveryContractV2, outcomeKey: string | null, localClaim: string, proofSurface: DeliveryCheckV2["proof_surface"], applicabilityRef: string | null, checkKey?: string | null): Set<EvidenceCapabilityV2>;