project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-check-runner.js

@@ -1,307 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { access, realpath } from "node:fs/promises";
-import net from "node:net";
-import path from "node:path";
-import { decodeCheckEvidence, invalidEvidence, } from "./long-task-check-evidence-decoder.js";
-import { spawnCommandOnce } from "./long-task-command-process.js";
-import { declaredEnvironmentValues, outputContainsDeclaredEnvironmentValue, runnerEnvironment, } from "./long-task-runner-environment.js";
-import { decodeProductObservationEnvelope } from "./long-task-process-observation.js";
-import { resolveInsideRepository } from "./long-task-workspace.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export async function executeCheckRunner(check, snapshotRoot, context) {
-    const started = Date.now();
-    let processAuthorities;
-    try {
-        processAuthorities = processObservationAuthorities(check.observation_authorities ?? [], context?.observation_authorities ?? []);
-    }
-    catch (error) {
-        return invalidRawExecution(check, started, message(error));
-    }
-    const processObserverIssue = validateProcessObserverActivation(check, snapshotRoot, processAuthorities, context);
-    if (processObserverIssue)
-        return invalidRawExecution(check, started, processObserverIssue);
-    const unavailable = await probeEnvironment(check.environment_requirements, snapshotRoot);
-    if (unavailable)
-        return {
-            raw_execution_identity: check.raw_execution_identity,
-            execution_identity: check.raw_execution_identity,
-            execution_status: "blocked_external",
-            exit_code: -1,
-            observations: {},
-            evidence_records: [],
-            stdout_sha256: sha256Hex(""),
-            stderr_sha256: sha256Hex(""),
-            attempts: 0,
-            duration_ms: Date.now() - started,
-            error: unavailable,
-        };
-    const retryAllowed = check.runner.retry_policy === "transient_once" &&
-        check.runner.idempotent &&
-        (check.runner.effect === "read_only" ||
-            check.runner.effect === "test_sandbox");
-    const maximumAttempts = retryAllowed ? 2 : 1;
-    for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
-        try {
-            const raw = await runOnce(check, snapshotRoot, processAuthorities, context?.snapshot_sha256, context?.process_runtime_closure_identity);
-            const secrets = declaredEnvironmentValues(check.environment_requirements);
-            let decoded = outputContainsDeclaredEnvironmentValue(raw, secrets)
-                ? invalidEvidence(raw.exit_code, "check_evidence_contains_declared_environment_value")
-                : raw.process_observation
-                    ? {
-                        execution_status: "completed",
-                        exit_code: raw.exit_code,
-                        observations: {},
-                        evidence_records: [],
-                        error: null,
-                    }
-                    : decodeCheckEvidence(check, raw.exit_code, raw.stdout, raw.stderr);
-            if (raw.process_observation && raw.exit_code !== 0)
-                decoded = invalidEvidence(raw.exit_code, "process_observer_nonzero_exit");
-            else if (raw.process_observation &&
-                decoded.execution_status !== "completed")
-                decoded = invalidEvidence(raw.exit_code, "project_submitted_execution_status_disagrees_with_harness");
-            if (raw.process_observation &&
-                packageObservationContainsDeclaredEnvironmentValue(raw.process_observation, secrets))
-                decoded = invalidEvidence(raw.exit_code, "check_evidence_contains_declared_environment_value");
-            return {
-                raw_execution_identity: check.raw_execution_identity,
-                execution_identity: check.raw_execution_identity,
-                ...decoded,
-                stdout_sha256: sha256Hex(raw.stdout),
-                stderr_sha256: sha256Hex(raw.stderr),
-                attempts: attempt,
-                duration_ms: Date.now() - started,
-                package_observations: raw.process_observation?.package_observations ?? [],
-                host_execution_attestation: raw.host_execution_attestation,
-            };
-        }
-        catch (error) {
-            const reason = message(error);
-            if (attempt < maximumAttempts)
-                continue;
-            return {
-                raw_execution_identity: check.raw_execution_identity,
-                execution_identity: check.raw_execution_identity,
-                execution_status: isProcessObservationError(reason)
-                    ? "invalid_evidence"
-                    : "infrastructure_error",
-                exit_code: -1,
-                observations: {},
-                evidence_records: [],
-                stdout_sha256: sha256Hex(""),
-                stderr_sha256: sha256Hex(reason),
-                attempts: attempt,
-                duration_ms: Date.now() - started,
-                error: reason,
-                package_observations: [],
-                host_execution_attestation: null,
-            };
-        }
-    }
-    throw new Error("unreachable");
-}
-async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256, processRuntimeClosureIdentity) {
-    const runner = check.runner;
-    const cwd = resolveInsideRepository(snapshotRoot, runner.resolved_cwd || ".", "runner.resolved_cwd");
-    const executable = runner.type === "project_binary"
-        ? resolveInsideRepository(snapshotRoot, runner.resolved_target, "runner.resolved_target")
-        : runner.executable;
-    const argv = [...runner.executable_argv_prefix, ...runner.argv];
-    if (!processAuthorities.length) {
-        const execution = await spawnCommandOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements), false);
-        return {
-            ...execution,
-            process_observation: null,
-            host_execution_attestation: null,
-        };
-    }
-    const executionNonce = randomBytes(32).toString("hex");
-    const execution = await spawnCommandOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements, "product_observation"), true);
-    const processObservation = decodeProductObservationEnvelope({
-        bytes: execution.stdout,
-        authorities: processAuthorities,
-    });
-    const declaredRoot = resolveInsideRepository(snapshotRoot, processAuthorities[0].runtime_requirements.declared_root_entrypoint, "process_observer.declared_root_entrypoint");
-    const [actualExecutable, actualDeclaredRoot] = await Promise.all([
-        realpath(executable),
-        realpath(declaredRoot),
-    ]);
-    const directRootMatch = sameHostPath(actualExecutable, actualDeclaredRoot) &&
-        sameStringArray(argv, processAuthorities[0].runtime_requirements.declared_root_argv ?? []);
-    if (!directRootMatch)
-        throw new Error("process_observer_direct_root_required");
-    return {
-        exit_code: execution.exit_code,
-        stdout: execution.stdout,
-        stderr: execution.stderr,
-        process_observation: processObservation,
-        host_execution_attestation: {
-            raw_execution_identity: check.raw_execution_identity,
-            executable_path: actualExecutable,
-            declared_root_entrypoint: actualDeclaredRoot,
-            actual_argv: [...argv],
-            declared_root_argv: [
-                ...(processAuthorities[0].runtime_requirements.declared_root_argv ??
-                    []),
-            ],
-            direct_root_match: directRootMatch,
-            pid: execution.pid,
-            started_at: execution.started_at,
-            completed_at: execution.completed_at,
-            exit_code: execution.exit_code,
-            snapshot_sha256: snapshotSha256,
-            observation_execution_nonce: executionNonce,
-            observation_artifact_sha256: processObservation.artifact_sha256,
-            process_runtime_closure_identity: processRuntimeClosureIdentity,
-        },
-    };
-}
-function validateProcessObserverActivation(check, snapshotRoot, authorities, context) {
-    if (!authorities.length)
-        return null;
-    if (!context?.snapshot_sha256)
-        return "process_observer_snapshot_identity_required";
-    if (!context.process_runtime_closure_identity ||
-        !check.process_runtime_closure ||
-        context.process_runtime_closure_identity !==
-            check.process_runtime_closure.closure_identity)
-        return "process_runtime_closure_identity_mismatch";
-    if (check.environment_requirements.some((requirement) => requirement.kind === "env_var" &&
-        (requirement.target.toUpperCase() === "TY_CONTEXT_OBSERVATION_OUTPUT" ||
-            requirement.target.toUpperCase() ===
-                "TY_CONTEXT_OBSERVATION_CHALLENGE" ||
-            requirement.target.toUpperCase() === "TY_CONTEXT_CHECK_PROTOCOL")))
-        return "process_observer_reserved_environment_requirement";
-    if (check.runner.type !== "project_binary" ||
-        check.execution_target.entrypoint !== "root")
-        return "process_observer_direct_root_required";
-    const executable = resolveInsideRepository(snapshotRoot, check.runner.resolved_target, "process_observer.runner_target");
-    const actualArgv = [
-        ...check.runner.executable_argv_prefix,
-        ...check.runner.argv,
-    ];
-    for (const authority of authorities) {
-        const requirements = authority.runtime_requirements;
-        if (requirements.runtime_family !== "process" ||
-            requirements.target_role !== "product" ||
-            requirements.entrypoint !== "root" ||
-            requirements.runner_type !== "project_binary" ||
-            requirements.resolved_runner_target !== check.runner.resolved_target ||
-            requirements.declared_root_argv === null ||
-            !sameStringArray(requirements.resolved_runner_argv, check.runner.argv) ||
-            !sameStringArray(requirements.declared_root_argv, actualArgv) ||
-            check.runner.executable_argv_prefix.length !== 0 ||
-            !requirements.direct_root_match)
-            return "process_observer_direct_root_required";
-        const declaredRoot = resolveInsideRepository(snapshotRoot, requirements.declared_root_entrypoint, "process_observer.declared_root_entrypoint");
-        if (!sameHostPath(executable, declaredRoot))
-            return "process_observer_direct_root_required";
-    }
-    return null;
-}
-function processObservationAuthorities(checkAuthorities, groupedAuthorities) {
-    const byIdentity = new Map();
-    for (const authority of [...checkAuthorities, ...groupedAuthorities]) {
-        if (authority.authority !== "package_process_json_exact")
-            continue;
-        const identity = `${authority.assertion_ref}\0${authority.obligation_ref}\0${authority.method}`;
-        const existing = byIdentity.get(identity);
-        if (existing &&
-            canonicalValueJson(existing) !== canonicalValueJson(authority))
-            throw new Error("process_observation_authority_group_mismatch");
-        byIdentity.set(identity, authority);
-    }
-    return [...byIdentity.values()];
-}
-function invalidRawExecution(check, started, reason) {
-    return {
-        raw_execution_identity: check.raw_execution_identity,
-        execution_identity: check.raw_execution_identity,
-        execution_status: "invalid_evidence",
-        exit_code: -1,
-        observations: {},
-        evidence_records: [],
-        stdout_sha256: sha256Hex(""),
-        stderr_sha256: sha256Hex(reason),
-        attempts: 0,
-        duration_ms: Date.now() - started,
-        error: reason,
-        package_observations: [],
-        host_execution_attestation: null,
-    };
-}
-function packageObservationContainsDeclaredEnvironmentValue(observation, values) {
-    if (!values.length)
-        return false;
-    const serialized = JSON.stringify(observation.observations);
-    return values.some((value) => serialized.includes(value));
-}
-function isProcessObservationError(reason) {
-    return (reason.startsWith("process_observation_") ||
-        reason.startsWith("process_observer_"));
-}
-function sameHostPath(left, right) {
-    return process.platform === "win32"
-        ? path.resolve(left).toLowerCase() === path.resolve(right).toLowerCase()
-        : path.resolve(left) === path.resolve(right);
-}
-function sameStringArray(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}
-async function probeEnvironment(requirements, snapshotRoot) {
-    for (const requirement of requirements) {
-        let available = false;
-        if (requirement.kind === "executable")
-            available = await executableExists(requirement.target);
-        else if (requirement.kind === "env_var")
-            available = Boolean(process.env[requirement.target]);
-        else if (requirement.kind === "file")
-            available = Boolean((await statSafe(resolveInsideRepository(snapshotRoot, requirement.target, `environment.${requirement.key}`)))?.isFile());
-        else if (requirement.kind === "directory")
-            available = Boolean((await statSafe(resolveInsideRepository(snapshotRoot, requirement.target, `environment.${requirement.key}`)))?.isDirectory());
-        else if ("host" in requirement)
-            available = await loopbackAvailable(requirement.host, requirement.port, requirement.timeout_ms);
-        if (!available)
-            return `environment_requirement_unavailable:${requirement.key}`;
-    }
-    return null;
-}
-async function executableExists(target) {
-    if (path.isAbsolute(target))
-        return access(target)
-            .then(() => true)
-            .catch(() => false);
-    const names = process.platform === "win32"
-        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM")
-            .split(";")
-            .flatMap((extension) => [target, `${target}${extension}`])
-        : [target];
-    for (const folder of (process.env.PATH ?? "").split(path.delimiter))
-        for (const name of names)
-            if (await access(path.join(folder, name))
-                .then(() => true)
-                .catch(() => false))
-                return true;
-    return false;
-}
-async function loopbackAvailable(host, port, timeoutMs) {
-    return new Promise((resolve) => {
-        const socket = net.createConnection({ host, port });
-        const finish = (value) => {
-            socket.destroy();
-            resolve(value);
-        };
-        socket.setTimeout(timeoutMs, () => finish(false));
-        socket.once("connect", () => finish(true));
-        socket.once("error", () => finish(false));
-    });
-}
-async function statSafe(file) {
-    return import("node:fs/promises")
-        .then(({ stat }) => stat(file))
-        .catch(() => null);
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

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

@@ -1,2 +0,0 @@
-import type { DeliveryCheckV2 } from "./long-task-delivery-types.js";
-export declare function parseCheck(value: unknown, label: string): DeliveryCheckV2;

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

@@ -1,171 +0,0 @@
-import { array, EVIDENCE_CAPABILITIES, fail, key, JOURNEY_ROLES, literal, object, parseEnvironmentRequirements, PROOF_SURFACES, repositoryCwd, repositoryFile, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
-export function parseCheck(value, label) {
-    const row = object(value, label, [
-        "key",
-        "journey_roles",
-        "execution_target",
-        "scenario",
-        "proof_surface",
-        "runner",
-        "verification_inputs",
-    ], [
-        "input_paths",
-        "expected_output_paths",
-        "artifact_globs",
-        "positive_assertions",
-        "negative_assertions",
-        "environment_requirements",
-    ]);
-    const executionTarget = object(row.execution_target, `${label}.execution_target`, ["target_ref", "entrypoint"]);
-    const scenario = object(row.scenario, `${label}.scenario`, ["given", "when"]);
-    return {
-        key: key(row.key, `${label}.key`),
-        journey_roles: array(row.journey_roles, `${label}.journey_roles`).map((item, index) => literal(item, JOURNEY_ROLES, `${label}.journey_roles[${index}]`)),
-        execution_target: {
-            target_ref: key(executionTarget.target_ref, `${label}.execution_target.target_ref`),
-            entrypoint: literal(executionTarget.entrypoint, ["root", "internal"], `${label}.execution_target.entrypoint`),
-        },
-        scenario: {
-            given: parseScenarioSteps(scenario.given, `${label}.scenario.given`),
-            when: parseScenarioSteps(scenario.when, `${label}.scenario.when`),
-        },
-        proof_surface: literal(row.proof_surface, PROOF_SURFACES, `${label}.proof_surface`),
-        runner: parseRunner(row.runner, `${label}.runner`),
-        verification_inputs: repositoryPatterns(row.verification_inputs, `${label}.verification_inputs`),
-        input_paths: Object.hasOwn(row, "input_paths")
-            ? repositoryPatterns(row.input_paths, `${label}.input_paths`)
-            : [],
-        expected_output_paths: Object.hasOwn(row, "expected_output_paths")
-            ? repositoryPatterns(row.expected_output_paths, `${label}.expected_output_paths`)
-            : [],
-        artifact_globs: Object.hasOwn(row, "artifact_globs")
-            ? repositoryPatterns(row.artifact_globs, `${label}.artifact_globs`)
-            : [],
-        positive_assertions: Object.hasOwn(row, "positive_assertions")
-            ? parseAssertions(row.positive_assertions, `${label}.positive_assertions`)
-            : [],
-        negative_assertions: Object.hasOwn(row, "negative_assertions")
-            ? parseAssertions(row.negative_assertions, `${label}.negative_assertions`)
-            : [],
-        environment_requirements: Object.hasOwn(row, "environment_requirements")
-            ? parseEnvironmentRequirements(row.environment_requirements, `${label}.environment_requirements`)
-            : [],
-    };
-}
-function parseRunner(value, label) {
-    const row = object(value, label, ["type", "target", "effect"], ["argv", "cwd", "timeout_ms", "retry_policy", "idempotent"]);
-    const timeout = Object.hasOwn(row, "timeout_ms")
-        ? Number(row.timeout_ms)
-        : 30_000;
-    if (!Number.isInteger(timeout) || timeout < 100 || timeout > 3_600_000)
-        fail(`${label}.timeout_ms`, "must be an integer from 100 to 3600000");
-    if (Object.hasOwn(row, "idempotent") && typeof row.idempotent !== "boolean")
-        fail(`${label}.idempotent`, "must be a boolean");
-    const type = literal(row.type, [
-        "package_script",
-        "project_binary",
-        "node_oracle",
-        "playwright_test",
-    ], `${label}.type`);
-    return {
-        type,
-        target: type === "package_script"
-            ? string(row.target, `${label}.target`)
-            : repositoryFile(row.target, `${label}.target`),
-        argv: Object.hasOwn(row, "argv") ? strings(row.argv, `${label}.argv`) : [],
-        cwd: Object.hasOwn(row, "cwd")
-            ? repositoryCwd(row.cwd, `${label}.cwd`)
-            : ".",
-        timeout_ms: timeout,
-        effect: literal(row.effect, ["read_only", "test_sandbox"], `${label}.effect`),
-        retry_policy: Object.hasOwn(row, "retry_policy")
-            ? literal(row.retry_policy, ["none", "transient_once"], `${label}.retry_policy`)
-            : "none",
-        idempotent: Object.hasOwn(row, "idempotent")
-            ? row.idempotent
-            : false,
-    };
-}
-function parseAssertions(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "applicability_ref", "expected"]);
-        const operator = literal(row.operator, [
-            "equals",
-            "not_equals",
-            "contains",
-            "not_contains",
-            "matches",
-            "not_matches",
-            "greater_than",
-            "greater_or_equal",
-            "less_than",
-            "less_or_equal",
-            "truthy",
-            "falsy",
-            "exists",
-            "set_equals",
-            "subset_of",
-            "superset_of",
-        ], `${itemLabel}.operator`);
-        const hasExpected = Object.hasOwn(row, "expected");
-        if (isBinaryAssertionOperator(operator) && !hasExpected)
-            fail(itemLabel, "assertion_expected_required");
-        if (!isBinaryAssertionOperator(operator) && hasExpected)
-            fail(itemLabel, "assertion_expected_forbidden");
-        if (isBinaryAssertionOperator(operator))
-            validateAssertionExpected(operator, row.expected, itemLabel);
-        const base = {
-            key: key(row.key, `${itemLabel}.key`),
-            ...(Object.hasOwn(row, "criterion")
-                ? { criterion: string(row.criterion, `${itemLabel}.criterion`) }
-                : {}),
-            claims: strings(row.claims, `${itemLabel}.claims`),
-            ...(Object.hasOwn(row, "applicability_ref")
-                ? {
-                    applicability_ref: key(row.applicability_ref, `${itemLabel}.applicability_ref`),
-                }
-                : {}),
-            observation: string(row.observation, `${itemLabel}.observation`),
-            evidence_capabilities: array(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
-            operator,
-        };
-        return isBinaryAssertionOperator(operator)
-            ? { ...base, operator, expected: row.expected }
-            : {
-                ...base,
-                operator: operator,
-            };
-    });
-}
-function parseScenarioSteps(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "statement"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-        };
-    });
-}
-function isBinaryAssertionOperator(operator) {
-    return !["exists", "truthy", "falsy"].includes(operator);
-}
-function validateAssertionExpected(operator, expected, label) {
-    if (operator === "matches" || operator === "not_matches") {
-        if (typeof expected !== "string")
-            fail(label, "assertion_expected_string_required");
-        try {
-            new RegExp(expected, "u");
-        }
-        catch {
-            fail(label, "assertion_expected_invalid_regex");
-        }
-    }
-    if (["greater_than", "greater_or_equal", "less_than", "less_or_equal"].includes(operator) &&
-        (typeof expected !== "number" || !Number.isFinite(expected)))
-        fail(label, "assertion_expected_finite_number_required");
-    if (["set_equals", "subset_of", "superset_of"].includes(operator) &&
-        !Array.isArray(expected))
-        fail(label, "assertion_expected_array_required");
-}

package/dist/lib/long-task-claim-definitions.d.ts

@@ -1,7 +0,0 @@
-import type { ClaimProofV2, DeliveryContractV2, DeliveryOutcomeV2, GlobalClaimV2, ProductClaimV2 } from "./long-task-delivery-types.js";
-export declare function generateClaims(outcome: DeliveryOutcomeV2): ProductClaimV2[];
-export declare function generateGlobalClaims(global: DeliveryContractV2["global"]): GlobalClaimV2[];
-export declare function validateGlobalProofPolarity(claim: GlobalClaimV2, proof: ClaimProofV2): void;
-export declare function validateProofSurface(claim: ProductClaimV2, proof: ClaimProofV2, outcomeKey: string): void;
-export declare function assertAllClaimsCovered(uncovered: string[]): void;
-export declare function assertAllGlobalClaimsCovered(uncovered: string[]): void;

package/dist/lib/long-task-claim-definitions.js

@@ -1,85 +0,0 @@
-import { controlFieldFacts } from "./long-task-control-fields.js";
-import { fail } from "./long-task-delivery-shape.js";
-export function generateClaims(outcome) {
-    const claims = [
-        claim(outcome.key, "result", "result", [], outcome.product.result_applicability_refs),
-    ];
-    for (const requirement of outcome.product.requirements)
-        claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces, requirement.applicability_refs));
-    for (const control of outcome.product.controls) {
-        for (const field of controlFieldFacts(control))
-            claims.push(claim(outcome.key, `control.${control.key}.${field.claim_field}`, "control", [], field.applicability_refs, field.state === "not_applicable" ? "negative" : "positive"));
-    }
-    if (outcome.product.control_relation_closure.state !== "unresolved")
-        claims.push(claim(outcome.key, "control_relation_closure", "control_relation", [], outcome.product.control_relation_closure.applicability_refs, outcome.product.control_relation_closure.state === "not_applicable"
-            ? "negative"
-            : "positive"));
-    for (const relation of outcome.product.control_relations)
-        claims.push(claim(outcome.key, `control_relation.${relation.key}`, "control_relation", relation.required_proof_surfaces, relation.applicability_refs));
-    for (const item of outcome.product.non_completing_outcomes)
-        claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing", [], item.applicability_refs, "negative"));
-    for (const item of outcome.technical.obligations)
-        claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces, item.applicability_refs));
-    for (const binding of outcome.semantic_fact_bindings?.facts ?? []) {
-        const requiredSurfaces = [
-            ...new Set((outcome.semantic_fact_bindings?.proofs ?? [])
-                .filter((proof) => proof.fact_ref === binding.fact_ref)
-                .map((proof) => proof.proof_surface)),
-        ];
-        claims.push(claim(outcome.key, binding.claim_ref, "semantic_fact", requiredSurfaces, [
-            binding.applicability_ref,
-        ]));
-    }
-    for (const item of outcome.technical.forbidden_shortcuts)
-        claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut", [], item.applicability_refs, "negative"));
-    return claims;
-}
-export function generateGlobalClaims(global) {
-    return [
-        ...global.product.non_goals.map((item) => globalClaim(`non_goal.${item.key}`, "global_non_goal", "negative", item.applicability_refs)),
-        ...global.technical.constraints.map((item) => globalClaim(`constraint.${item.key}`, "global_constraint", "positive", item.applicability_refs)),
-        ...global.technical.forbidden_shortcuts.map((item) => globalClaim(`forbidden_shortcut.${item.key}`, "global_forbidden_shortcut", "negative", item.applicability_refs)),
-    ].sort((left, right) => left.id.localeCompare(right.id));
-}
-export function validateGlobalProofPolarity(claim, proof) {
-    if (proof.polarity !== claim.required_polarity)
-        fail("global_negative_claim_proof_required", `${claim.local_key}:${proof.check_key}`);
-}
-export function validateProofSurface(claim, proof, outcomeKey) {
-    if (proof.polarity !== claim.required_polarity)
-        fail("claim_proof_polarity_mismatch", `${outcomeKey}:${claim.local_key}:${proof.polarity}:${claim.required_polarity}`);
-    if ((claim.kind === "requirement" ||
-        claim.kind === "obligation" ||
-        claim.kind === "semantic_fact") &&
-        claim.required_proof_surfaces.length > 0 &&
-        !claim.required_proof_surfaces.includes(proof.proof_surface))
-        fail(`${claim.kind}_proof_surface_mismatch`, `${outcomeKey}:${claim.local_key}:${proof.proof_surface}`);
-}
-export function assertAllClaimsCovered(uncovered) {
-    if (uncovered.length)
-        fail("product_claim_uncovered", uncovered.sort().join(","));
-}
-export function assertAllGlobalClaimsCovered(uncovered) {
-    if (uncovered.length)
-        fail("global_claim_uncovered", uncovered.sort().join(","));
-}
-function claim(outcomeKey, localKey, kind, requiredProofSurfaces = [], applicabilityRefs = [], requiredPolarity = "positive") {
-    return {
-        id: `${outcomeKey}.${localKey}`,
-        outcome_key: outcomeKey,
-        local_key: localKey,
-        kind,
-        required_proof_surfaces: requiredProofSurfaces,
-        required_polarity: requiredPolarity,
-        applicability_refs: applicabilityRefs,
-    };
-}
-function globalClaim(localKey, kind, requiredPolarity, applicabilityRefs) {
-    return {
-        id: `GLOBAL.${localKey}`,
-        local_key: localKey,
-        kind,
-        required_polarity: requiredPolarity,
-        applicability_refs: applicabilityRefs,
-    };
-}

package/dist/lib/long-task-claim-proof-policy.d.ts

@@ -1,4 +0,0 @@
-import type { DeliveryAssertionV2, DeliveryContractV2, ProductClaimV2, ProofSurface } from "./long-task-delivery-types.js";
-export declare function validateDeclaredCheckSafety(contract: DeliveryContractV2, report?: (message: string) => void): void;
-export declare function validateClaimAssertionOperator(claim: ProductClaimV2, assertion: DeliveryAssertionV2, proofSurface: ProofSurface, outcomeKey: string, checkKey: string): void;
-export declare function validateGlobalAssertionOperator(assertion: DeliveryAssertionV2, checkKey: string): void;

package/dist/lib/long-task-claim-proof-policy.js

@@ -1,57 +0,0 @@
-const PRESENCE_OR_UNARY = new Set(["exists", "truthy", "falsy"]);
-export function validateDeclaredCheckSafety(contract, report) {
-    for (const check of contract.global.acceptance.checks)
-        validateCheck(check, null, report);
-    for (const outcome of contract.outcomes)
-        for (const check of outcome.acceptance.checks)
-            validateCheck(check, outcome.key, report);
-}
-export function validateClaimAssertionOperator(claim, assertion, proofSurface, outcomeKey, checkKey) {
-    if (!assertion.claims.length || !PRESENCE_OR_UNARY.has(assertion.operator))
-        return;
-    const implementationStructureObligation = claim.kind === "obligation" &&
-        proofSurface === "implementation_structure" &&
-        claim.required_proof_surfaces.includes("implementation_structure");
-    if (assertion.operator === "exists" && implementationStructureObligation)
-        return;
-    throw new Error(`claim_assertion_explicit_expected_required:${outcomeKey}:${checkKey}:${assertion.key}`);
-}
-export function validateGlobalAssertionOperator(assertion, checkKey) {
-    if (assertion.claims.length && PRESENCE_OR_UNARY.has(assertion.operator))
-        throw new Error(`claim_assertion_explicit_expected_required:GLOBAL:${checkKey}:${assertion.key}`);
-}
-function validateCheck(check, outcomeKey, report) {
-    for (const assertion of [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ]) {
-        if (!assertion.criterion)
-            issue(report, `assertion_criterion_required:${outcomeKey ?? "GLOBAL"}.${check.key}.${assertion.key}`);
-        if (check.runner.type === "playwright_test" && assertion.claims.length) {
-            const canonical = assertion.observation === `playwright.case.${assertion.key}.passed` &&
-                assertion.operator === "equals" &&
-                assertion.expected === true;
-            if (!canonical)
-                issue(report, `playwright_claim_assertion_invalid:${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}`);
-        }
-        if (outcomeKey === null)
-            captureOrReport(report, () => validateGlobalAssertionOperator(assertion, check.key));
-    }
-}
-function issue(report, message) {
-    if (!report)
-        throw new Error(message);
-    report(message);
-}
-function captureOrReport(report, action) {
-    if (!report) {
-        action();
-        return;
-    }
-    try {
-        action();
-    }
-    catch (error) {
-        report(error instanceof Error ? error.message : String(error));
-    }
-}

package/dist/lib/long-task-claims.d.ts

@@ -1,28 +0,0 @@
-import type { ClaimCoverageSummaryV2, DeliveryContractV2, GlobalClaimV2, ProductClaimV2 } from "./long-task-delivery-types.js";
-export interface CompiledClaimsV2 {
-    by_global: GlobalClaimV2[];
-    by_outcome: Record<string, ProductClaimV2[]>;
-    summary: ClaimCoverageSummaryV2;
-}
-interface ExternalConfirmationProjectionInput {
-    global: {
-        acceptance: {
-            external_confirmations: readonly {
-                blocks_target: boolean;
-                impact_claims: readonly string[];
-            }[];
-        };
-    };
-}
-interface AllOutcomeExternalConfirmationProjectionInput extends ExternalConfirmationProjectionInput {
-    outcomes: readonly {
-        key: string;
-    }[];
-}
-export declare function outcomeResultExternallyBlocked(contract: ExternalConfirmationProjectionInput, outcomeKey: string): boolean;
-export declare function allOutcomeResultsExternallyBlocked(contract: AllOutcomeExternalConfirmationProjectionInput): boolean;
-export declare function compileProductClaimCoverage(contract: DeliveryContractV2, options?: {
-    allow_uncovered?: boolean;
-}): CompiledClaimsV2;
-export declare function assertCompiledClaimsCovered(compiled: CompiledClaimsV2): void;
-export {};