project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,318 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import path from "node:path";
-import { computeRawExecutionIdentity } from "./long-task-check-execution-policy.js";
-import { assertRepositoryPattern, classifyRepositoryPatternOverlap, matchesRepoPattern, normalizeRepositoryFile, proveRepositoryPatternSubset, } from "./long-task-paths.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { nearestRunnerFile, npmCliPath, npxCliPath, } from "./long-task-runner-files.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
-import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
-import { freezeLocalVerifierDependencyClosure, packageScriptVerifierRoots, } from "./long-task-verifier-dependency-closure.js";
-import { compileObservationAuthorityPlan, projectExternallyOwnedClaimAssertions, projectExternallyOwnedDesignAssertions, } from "./long-task-observation-authority.js";
-import { compileProcessRuntimeClosure } from "./long-task-process-runtime-closure.js";
-export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations, productionBindings, productionOwnerPaths, sourceBackedExecutionTarget, protectedAuthorityPaths = [], proofAdequacy = {
-    completion_role: "diagnostic",
-    expected_authority_refs: {},
-    required_evidence_capabilities: {},
-}, externalDesignObligationRefs = new Set(), externalClaimObligationRefsByAssertion = new Map()) {
-    const prefix = outcomeKey ? `CHECK.${outcomeKey}` : "CHECK.GLOBAL";
-    const expectedOutputs = check.expected_output_paths.map((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.expected_output_paths[${index}]`));
-    const protectedAuthorityFiles = [
-        ...new Set(protectedAuthorityPaths.map((file, index) => normalizeRepositoryFile(file, `${check.key}.protected_authority_paths[${index}]`))),
-    ].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
-    for (const [index, pattern] of check.input_paths.entries()) {
-        const normalized = assertRepositoryPattern(repository, pattern, `${check.key}.input_paths[${index}]`);
-        if (!baseline.files.some((file) => matchesRepoPattern(file.path, normalized)) &&
-            !protectedAuthorityFiles.some((file) => matchesRepoPattern(file, normalized)) &&
-            !expectedOutputs.some((output) => classifyRepositoryPatternOverlap(output, normalized).status ===
-                "proven_overlap") &&
-            !plannedBindingMayProvideInput(productionBindings, normalized))
-            throw new Error(`input_path_not_found:${check.key}:${pattern}`);
-    }
-    check.artifact_globs.forEach((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.artifact_globs[${index}]`));
-    const cwd = resolveInsideRepository(repository, check.runner.cwd, `${check.key}.cwd`);
-    if (!(await stat(cwd).catch(() => null))?.isDirectory())
-        throw new Error(`runner_cwd_not_found:${check.key}:${check.runner.cwd}`);
-    const target = await resolvedRunnerTarget(check, repository, cwd, executionTarget, productionBindings, sourceBackedExecutionTarget);
-    const verificationInputHashes = await freezeVerificationInputs(check, repository, baseline, cwd, target, executionTarget);
-    validateSemanticFactOracleInputs(check.key, semanticFactExpectations, verificationInputHashes);
-    const runner = await freezeRunner(check, repository, cwd, target, verificationInputHashes);
-    const observationAuthorities = compileObservationAuthorityPlan({
-        check,
-        outcome_key: outcomeKey,
-        runner,
-        execution_target: executionTarget,
-        design_targets: designConformanceTargets,
-        semantic_fact_expectations: semanticFactExpectations,
-        production_bindings: productionBindings,
-        production_owner_paths: productionOwnerPaths,
-        source_backed_execution_target: sourceBackedExecutionTarget,
-        workspace_manifest: baseline,
-        protected_authority_paths: protectedAuthorityFiles,
-        external_design_obligation_refs: externalDesignObligationRefs,
-        external_claim_obligation_refs_by_assertion: externalClaimObligationRefsByAssertion,
-    });
-    const designProjection = projectExternallyOwnedDesignAssertions(check, designConformanceTargets, observationAuthorities, externalDesignObligationRefs);
-    const claimProjection = projectExternallyOwnedClaimAssertions(designProjection.check, observationAuthorities, externalClaimObligationRefsByAssertion);
-    const machineCheck = claimProjection.check;
-    const processRuntimeClosure = compileProcessRuntimeClosure({
-        check: machineCheck,
-        runner,
-        execution_target: executionTarget,
-        observation_authorities: observationAuthorities,
-        production_bindings: productionBindings,
-        production_owner_paths: productionOwnerPaths,
-        source_backed_execution_target: sourceBackedExecutionTarget,
-        protected_authority_paths: protectedAuthorityFiles,
-    });
-    const compiled = {
-        ...machineCheck,
-        internal_id: `${prefix}.${check.key}`,
-        outcome_key: outcomeKey,
-        evidence_adapter: evidenceAdapterForRunner(machineCheck.runner.type),
-        runner,
-        verification_input_hashes: verificationInputHashes,
-        execution_target_definition: executionTarget,
-        known_execution_targets: knownExecutionTargets,
-        design_conformance_targets: designConformanceTargets,
-        semantic_fact_expectations: semanticFactExpectations,
-        observation_authorities: observationAuthorities,
-        protected_authority_paths: protectedAuthorityFiles,
-        process_runtime_closure: processRuntimeClosure,
-        completion_role: proofAdequacy.completion_role,
-        expected_authority_refs: proofAdequacy.expected_authority_refs,
-        required_evidence_capabilities: proofAdequacy.required_evidence_capabilities,
-    };
-    return {
-        ...compiled,
-        raw_execution_identity: computeRawExecutionIdentity(compiled),
-    };
-}
-function validateSemanticFactOracleInputs(checkKey, expectations, verificationInputHashes) {
-    const frozenOracles = new Map(expectations
-        .filter((expectation) => expectation.oracle.trust === "frozen_executable")
-        .map((expectation) => [expectation.oracle.key, expectation.oracle]));
-    for (const oracle of frozenOracles.values()) {
-        const frozenSha256 = verificationInputHashes[oracle.identity];
-        if (!frozenSha256)
-            throw new Error(`semantic_fact_oracle_verification_input_missing:${checkKey}:${oracle.key}:${oracle.identity}`);
-        if (frozenSha256 !== oracle.sha256)
-            throw new Error(`semantic_fact_oracle_verification_input_mismatch:${checkKey}:${oracle.key}:${oracle.identity}`);
-    }
-}
-async function resolvedRunnerTarget(check, repository, cwd, executionTarget, productionBindings, sourceBackedExecutionTarget) {
-    if (check.runner.type === "package_script") {
-        const packageFile = await nearestRunnerFile(cwd, repository, "package.json");
-        if (!packageFile)
-            throw new Error(`package_json_not_found:${check.key}:${check.runner.cwd}`);
-        return assertProtectedRepositoryFile(repository, packageFile, `${check.key}.package_json`);
-    }
-    const target = resolveInsideRepository(cwd, check.runner.target, `${check.key}.target`);
-    const targetInfo = await stat(target).catch(() => null);
-    if (!targetInfo?.isFile()) {
-        const relativeTarget = repoRelative(repository, target);
-        if (!targetInfo &&
-            plannedDirectProductRoot({
-                check,
-                executionTarget,
-                productionBindings,
-                sourceBackedExecutionTarget,
-                relativeTarget,
-            }))
-            return target;
-        throw new Error(`${check.runner.type}_path_not_found:${check.key}:${check.runner.target}`);
-    }
-    const protectedTarget = await assertProtectedRepositoryFile(repository, target, `${check.key}.runner_target`);
-    repoRelative(repository, protectedTarget);
-    return protectedTarget;
-}
-function plannedBindingMayProvideInput(bindings, inputPattern) {
-    return bindings.some((scoped) => scoped.binding.existence === "planned" &&
-        scoped.binding.carrier_paths.some((carrier) => isExactRepositoryFile(carrier, `${scoped.binding_ref}.carrier`) &&
-            proveRepositoryPatternSubset(carrier, inputPattern).status ===
-                "proven_subset"));
-}
-function plannedDirectProductRoot(input) {
-    return (input.check.runner.type === "project_binary" &&
-        input.check.execution_target.entrypoint === "root" &&
-        input.executionTarget.role === "product" &&
-        input.executionTarget.runtime_family === "process" &&
-        input.sourceBackedExecutionTarget?.target_ref ===
-            input.executionTarget.key &&
-        input.relativeTarget === input.executionTarget.root_entrypoint &&
-        input.productionBindings.some((scoped) => scoped.binding.existence === "planned" &&
-            scoped.binding.carrier_paths.some((carrier) => isExactRepositoryFile(carrier, `${scoped.binding_ref}.carrier`) &&
-                carrier === input.relativeTarget)));
-}
-function isExactRepositoryFile(value, label) {
-    try {
-        return normalizeRepositoryFile(value, label) === value;
-    }
-    catch {
-        return false;
-    }
-}
-async function freezeRunner(check, repository, cwd, target, verificationInputHashes) {
-    const runner = check.runner;
-    if (runner.argv.some((value) => value.includes("\0")))
-        throw new Error(`runner_argument_invalid:${check.key}`);
-    const resolvedCwd = repoRelative(repository, cwd);
-    const resolvedTarget = repoRelative(repository, target);
-    const frozenFiles = { ...verificationInputHashes };
-    let executable;
-    let prefix;
-    let packageScript = null;
-    if (runner.type === "package_script") {
-        const packageJson = JSON.parse(await readFile(target, "utf8"));
-        const script = packageJson.scripts?.[runner.target];
-        if (typeof script !== "string" || !script.trim())
-            throw new Error(`package_script_not_found:${check.key}:${runner.target}`);
-        packageScript = script;
-        executable = process.execPath;
-        prefix = [await npmCliPath(), "run", runner.target, "--"];
-    }
-    else {
-        const relativeFromCwd = path.relative(cwd, target).replace(/\\/gu, "/");
-        if (runner.type === "node_oracle") {
-            executable = process.execPath;
-            prefix = [relativeFromCwd];
-        }
-        else if (runner.type === "playwright_test") {
-            executable = process.execPath;
-            prefix = [
-                await npxCliPath(),
-                "--no-install",
-                "playwright",
-                "test",
-                relativeFromCwd,
-                "--reporter=json",
-            ];
-        }
-        else {
-            executable = resolvedTarget;
-            prefix = [];
-        }
-    }
-    const definition = sha256Hex(canonicalValueJson({
-        runner,
-        resolved_cwd: resolvedCwd,
-        resolved_target: resolvedTarget,
-        package_script: packageScript,
-    }));
-    return {
-        ...runner,
-        executable,
-        executable_argv_prefix: prefix,
-        resolved_cwd: resolvedCwd,
-        resolved_target: resolvedTarget,
-        definition_sha256: definition,
-        frozen_files: sortRecord(frozenFiles),
-        package_script: packageScript,
-        execution_identity: sha256Hex(canonicalValueJson({
-            runner,
-            executable,
-            prefix,
-            resolved_cwd: resolvedCwd,
-            resolved_target: resolvedTarget,
-            package_script: packageScript,
-            frozen_files: frozenFiles,
-        })),
-    };
-}
-async function freezeVerificationInputs(check, repository, manifest, cwd, target, executionTarget) {
-    const result = {};
-    for (const [index, source] of check.verification_inputs.entries()) {
-        const pattern = assertRepositoryPattern(repository, source, `${check.key}.verification_inputs[${index}]`);
-        const matches = manifest.files.filter((file) => matchesRepoPattern(file.path, pattern));
-        if (!matches.length)
-            throw new Error(`verification_input_not_found:${check.key}:${source}`);
-        for (const file of matches) {
-            const protectedFile = await assertProtectedRepositoryFile(repository, path.join(repository, ...file.path.split("/")), `${check.key}.verification_input`);
-            result[file.path] = sha256Hex(await readFile(protectedFile));
-        }
-    }
-    const directProductRoot = check.runner.type === "project_binary" &&
-        executionTarget.role === "product" &&
-        executionTarget.runtime_family === "process" &&
-        check.execution_target.entrypoint === "root";
-    const automatic = new Set(directProductRoot ? [] : [repoRelative(repository, target)]);
-    if (!directProductRoot) {
-        const packageFile = await nearestRunnerFile(cwd, repository, "package.json");
-        if (packageFile)
-            automatic.add(repoRelative(repository, packageFile));
-        for (const name of [
-            "package-lock.json",
-            "npm-shrinkwrap.json",
-            "pnpm-lock.yaml",
-            "yarn.lock",
-        ]) {
-            const file = await nearestRunnerFile(cwd, repository, name);
-            if (file)
-                automatic.add(repoRelative(repository, file));
-        }
-    }
-    if (check.runner.type === "playwright_test")
-        if (playwrightConfigArgument(check.runner.argv)) {
-            const file = resolveInsideRepository(cwd, playwrightConfigArgument(check.runner.argv), `${check.key}.playwright_config`);
-            automatic.add(repoRelative(repository, file));
-        }
-        else
-            for (const name of [
-                "playwright.config.ts",
-                "playwright.config.js",
-                "playwright.config.mjs",
-                "playwright.config.cjs",
-            ]) {
-                const file = await nearestRunnerFile(cwd, repository, name);
-                if (file)
-                    automatic.add(repoRelative(repository, file));
-            }
-    for (const relative of automatic) {
-        const file = manifest.files.find((candidate) => candidate.path === relative);
-        if (!file)
-            throw new Error(`verification_input_not_found:${check.key}:${relative}`);
-        const protectedFile = await assertProtectedRepositoryFile(repository, path.join(repository, ...relative.split("/")), `${check.key}.automatic_verification_input`);
-        result[relative] = sha256Hex(await readFile(protectedFile));
-    }
-    if (check.runner.type === "package_script") {
-        const packageJson = JSON.parse(await readFile(target, "utf8"));
-        const script = packageJson.scripts?.[check.runner.target];
-        if (typeof script !== "string" || !script.trim())
-            throw new Error(`package_script_not_found:${check.key}:${check.runner.target}`);
-        for (const relative of packageScriptVerifierRoots(script, repoRelative(repository, target), manifest)) {
-            const protectedFile = await assertProtectedRepositoryFile(repository, path.join(repository, ...relative.split("/")), `${check.key}.package_script_entry`);
-            result[relative] = sha256Hex(await readFile(protectedFile));
-        }
-    }
-    Object.assign(result, await freezeLocalVerifierDependencyClosure(repository, Object.keys(result), manifest, [
-        ...check.input_paths,
-        ...check.expected_output_paths,
-        ...check.artifact_globs,
-    ]));
-    return sortRecord(result);
-}
-export function playwrightConfigArgument(argv) {
-    const values = [];
-    for (let index = 0; index < argv.length; index += 1) {
-        const value = argv[index];
-        if (value === "--config") {
-            const next = argv[index + 1];
-            if (!next || next.startsWith("-"))
-                throw new Error("playwright_config_argument_missing");
-            values.push(next);
-            index += 1;
-        }
-        else if (value.startsWith("--config=")) {
-            const config = value.slice("--config=".length);
-            if (!config)
-                throw new Error("playwright_config_argument_missing");
-            values.push(config);
-        }
-    }
-    if (values.length > 1)
-        throw new Error("playwright_config_argument_ambiguous");
-    return values[0] ?? null;
-}
-function sortRecord(value) {
-    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
-}

package/dist/lib/long-task-runtime-types.d.ts

@@ -1,346 +0,0 @@
-import type { CompiledExternalConfirmationIdentityAssuranceV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, DeliveryRunnerV2, ProofSurface } from "./long-task-contract-types.js";
-import type { EvidenceCapabilityV2, ExecutionTargetV2 } from "./long-task-semantic-contract-types.js";
-import type { CompiledDesignTargetV2 } from "./long-task-ui-surface-types.js";
-import type { AuthorityHashesV2, ContextAuthoritySnapshotV2, InitialTaskBaseV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-authority-types.js";
-import type { EvidenceAdapter } from "./long-task-evidence-adapter-types.js";
-import type { EvidenceCapabilityRecordV2 } from "./long-task-evidence-capability-types.js";
-import type { EffectiveRiskLevel, RiskFactName } from "./long-task-risk-types.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability.js";
-import type { SemanticFactExpectationV2 } from "./semantic-fact-types.js";
-import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
-import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
-import type { JsonPointerExactObservation } from "./long-task-json-pointer-observation.js";
-import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
-export interface FrozenRunnerV2 extends DeliveryRunnerV2 {
-    executable: string;
-    executable_argv_prefix: string[];
-    resolved_cwd: string;
-    resolved_target: string;
-    definition_sha256: string;
-    frozen_files: Record<string, string>;
-    package_script: string | null;
-    execution_identity: string;
-}
-export type CompiledObservationAuthorityKindV2 = "package_static_json_exact" | "package_process_json_exact" | "external_confirmation";
-export type CompiledObservationActualProjectionV2 = "raw_exact" | "presence_boolean" | "truthy_boolean" | "falsy_boolean";
-export interface CompiledObservationAuthorityV2 {
-    obligation_ref: string;
-    fact_ref: string | null;
-    assertion_ref: string;
-    claim_refs: string[];
-    target_ref: string;
-    proof_surface: ProofSurface;
-    method: string;
-    evidence_capabilities: EvidenceCapabilityV2[];
-    authority: CompiledObservationAuthorityKindV2;
-    expected_identity: string;
-    expected_value_sha256: string;
-    expected_value?: unknown;
-    actual_projection: CompiledObservationActualProjectionV2;
-    observation_identity: string;
-    comparison: {
-        comparator: string;
-        mode: string;
-        parameters_sha256: string | null;
-        tolerance_sha256: string | null;
-        mask_sha256: string | null;
-    };
-    locator_policy: {
-        kind: "fixed_json_pointer";
-        value: string;
-    };
-    carrier_refs: Array<{
-        binding_ref: string;
-        carrier_paths: string[];
-    }>;
-    runtime_requirements: {
-        runtime_family: ExecutionTargetV2["runtime_family"];
-        target_role: ExecutionTargetV2["role"];
-        entrypoint: DeliveryCheckV2["execution_target"]["entrypoint"];
-        runner_type: DeliveryRunnerV2["type"];
-        resolved_runner_target: string;
-        declared_root_entrypoint: string;
-        resolved_runner_argv: string[];
-        declared_root_argv: string[] | null;
-        effect: DeliveryRunnerV2["effect"];
-        direct_root_match: boolean;
-    };
-}
-export interface SourceBackedExecutionTargetV2 {
-    target_ref: string;
-    canonical_target_ref: string;
-    source_claim_key: string;
-    source_item_key: string;
-    source_path: string;
-    source_text_sha256: string;
-    target_identity: string;
-}
-export interface CompiledProcessRuntimeClosureV2 {
-    target_ref: string;
-    source_target: SourceBackedExecutionTargetV2;
-    root_target: string;
-    root_argv_files: string[];
-    production_carrier_files: string[];
-    allowed_runtime_files: string[];
-    production_binding_refs: string[];
-    forbidden_role_matches: Array<{
-        path: string;
-        role: "expected_authority" | "verification" | "evidence";
-        pattern: string;
-    }>;
-    closure_identity: string;
-}
-export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
-    internal_id: string;
-    outcome_key: string | null;
-    runner: FrozenRunnerV2;
-    evidence_adapter: EvidenceAdapter;
-    verification_input_hashes: Record<string, string>;
-    raw_execution_identity: string;
-    execution_target_definition: ExecutionTargetV2;
-    known_execution_targets: ExecutionTargetV2[];
-    design_conformance_targets: CompiledDesignTargetV2[];
-    semantic_fact_expectations: SemanticFactExpectationV2[];
-    observation_authorities: CompiledObservationAuthorityV2[];
-    protected_authority_paths?: string[];
-    process_runtime_closure: CompiledProcessRuntimeClosureV2 | null;
-    completion_role: "semantic" | "diagnostic";
-    expected_authority_refs: Record<string, string>;
-    required_evidence_capabilities: Record<string, EvidenceCapabilityV2[]>;
-}
-export interface ProductClaimV2 {
-    id: string;
-    outcome_key: string;
-    local_key: string;
-    kind: "result" | "requirement" | "control" | "control_relation" | "non_completing" | "obligation" | "semantic_fact" | "forbidden_shortcut";
-    required_proof_surfaces: ProofSurface[];
-    required_polarity: "positive" | "negative";
-    applicability_refs: string[];
-}
-export interface GlobalClaimV2 {
-    id: string;
-    local_key: string;
-    kind: "global_non_goal" | "global_constraint" | "global_forbidden_shortcut";
-    required_polarity: "positive" | "negative";
-    applicability_refs: string[];
-}
-export interface ClaimProofV2 {
-    check_key: string;
-    assertion_key: string | null;
-    polarity: "positive" | "negative" | "population" | "counterfactual";
-    proof_surface: ProofSurface;
-    applicability_ref: string | null;
-}
-export interface ClaimCoverageSummaryV2 {
-    claims_total: number;
-    claims_covered: number;
-    uncovered_claims: string[];
-    claims_by_global: Record<string, {
-        covered: boolean;
-        applicability_refs: string[];
-        uncovered_applicability_refs: string[];
-        proofs: ClaimProofV2[];
-    }>;
-    claims_by_outcome: Record<string, Record<string, {
-        required_surfaces: ProofSurface[];
-        covered_surfaces: ProofSurface[];
-        missing_surfaces: ProofSurface[];
-        covered: boolean;
-        applicability_refs: string[];
-        uncovered_applicability_refs: string[];
-        proofs: ClaimProofV2[];
-    }>>;
-}
-export interface CompiledOutcomeV2 extends Omit<DeliveryOutcomeV2, "acceptance"> {
-    internal_id: string;
-    generated_claims: ProductClaimV2[];
-    risk_reasons: RiskFactName[];
-    acceptance: Omit<DeliveryOutcomeV2["acceptance"], "checks"> & {
-        checks: CompiledCheckV2[];
-    };
-}
-export interface CompiledDeliveryContractV2 {
-    schema_version: "compiled-long-task-delivery-v2";
-    compiled_identity: string;
-    repository_root: string;
-    workdir: string;
-    contract_file: string;
-    contract_sha256: string;
-    contract_files: Record<string, string>;
-    source_hashes: Record<string, string>;
-    source_items: CompiledSourceItemV2[];
-    context_snapshot: ContextAuthoritySnapshotV2;
-    project_design_authority?: DesignAuthorityIdentityV1 | null;
-    verifier_identity: VerifierIdentityV2;
-    effective_risk: EffectiveRiskLevel;
-    risk_reasons: string[];
-    baseline_workspace: WorkspaceManifestV2;
-    initial_task_base: InitialTaskBaseV2;
-    authority_hashes: AuthorityHashesV2;
-    authority_materials: NextAuthorityMaterialsV2;
-    authority_revision: number;
-    claim_coverage: ClaimCoverageSummaryV2;
-    acceptance_reachability: AcceptanceReachabilityV1;
-    external_confirmation_identity_assurances: Record<string, CompiledExternalConfirmationIdentityAssuranceV2>;
-    semantic_fact_manifest: DeliveryContractV2["semantic_fact_manifest"];
-    task: DeliveryContractV2["task"];
-    risk: DeliveryContractV2["risk"];
-    source_claims: DeliveryContractV2["source_claims"];
-    stages: DeliveryContractV2["stages"];
-    global: Omit<DeliveryContractV2["global"], "acceptance"> & {
-        acceptance: {
-            checks: CompiledCheckV2[];
-            counterfactual_controls: DeliveryContractV2["global"]["acceptance"]["counterfactual_controls"];
-            external_confirmations: DeliveryContractV2["global"]["acceptance"]["external_confirmations"];
-        };
-    };
-    outcomes: CompiledOutcomeV2[];
-}
-export interface LongTaskFindingV2 {
-    code: string;
-    outcome_key: string | null;
-    check_key: string | null;
-    source_claim_keys?: string[];
-    source_target_refs?: string[];
-    claim_keys?: string[];
-    assertion_key?: string;
-    binding_ref?: string;
-    owning_outcome_key?: string;
-    criterion?: string;
-    observation?: string;
-    owner_paths?: string[];
-    source_fragment_refs?: string[];
-    fact_refs?: string[];
-    proof_obligation_refs?: string[];
-    expected_authority_refs?: string[];
-    actual_evidence_refs?: string[];
-    implementation_owner?: {
-        label: string;
-        path_globs: string[];
-    };
-    verification_owner?: {
-        kind: "machine_check";
-        outcome_key: string | null;
-        check_key: string;
-        runner_target: string;
-        input_paths: string[];
-    } | {
-        kind: "external_confirmation";
-        confirmation_ref: string;
-        owner: string;
-        target_ref: string;
-    };
-    invalidation_reasons?: string[];
-    rerun_obligation_refs?: string[];
-    message: string;
-    expected?: unknown;
-    actual?: unknown;
-    next_action: string;
-}
-export type CheckExecutionStatusV2 = "passed" | "assertion_failed" | "test_failed" | "blocked_external" | "infrastructure_error" | "invalid_evidence";
-export interface AssertionResultV2 {
-    key: string;
-    criterion?: string;
-    polarity: "positive" | "negative";
-    passed: boolean;
-    claims: string[];
-    applicability_ref?: string;
-    observation: string;
-    evidence_capabilities: EvidenceCapabilityV2[];
-    evidence_complete: boolean;
-    status: "passed" | "observation_missing" | "observation_type_mismatch" | "assertion_value_mismatch";
-    expected?: unknown;
-    actual?: unknown;
-}
-export interface RawCommandExecutionV2 {
-    raw_execution_identity: string;
-    execution_identity: string;
-    execution_status: "completed" | "blocked_external" | "infrastructure_error" | "invalid_evidence";
-    exit_code: number;
-    observations: Record<string, unknown>;
-    evidence_records: EvidenceCapabilityRecordV2[];
-    stdout_sha256: string;
-    stderr_sha256: string;
-    attempts: number;
-    duration_ms: number;
-    error: string | null;
-    package_observations?: PackageObservationValueV2[];
-    host_execution_attestation?: HostExecutionAttestationV2 | null;
-}
-export interface PackageObservationValueV2 {
-    authority: Exclude<CompiledObservationAuthorityKindV2, "external_confirmation">;
-    observation_identity: string;
-    assertion_ref: string;
-    obligation_ref: string;
-    method: string;
-    raw_value: unknown;
-    observation: JsonPointerExactObservation | null;
-    reason: string | null;
-}
-export interface PackageProcessObservationV1 {
-    schema_version: "ty-context-product-observation-v1";
-    artifact_sha256: string;
-    observations: Record<string, unknown>;
-    value_sha256_by_identity: Record<string, string>;
-    package_observations: PackageObservationValueV2[];
-}
-export interface HostExecutionAttestationV2 {
-    raw_execution_identity: string;
-    executable_path: string;
-    declared_root_entrypoint: string;
-    actual_argv: string[];
-    declared_root_argv: string[];
-    direct_root_match: boolean;
-    pid: number;
-    started_at: string;
-    completed_at: string;
-    exit_code: number;
-    snapshot_sha256: string;
-    observation_execution_nonce: string;
-    observation_artifact_sha256: string;
-    process_runtime_closure_identity: string;
-}
-export interface CheckRunnerExecutionContextV2 {
-    snapshot_sha256?: string;
-    observation_authorities?: readonly CompiledObservationAuthorityV2[];
-    process_runtime_closure_identity?: string;
-}
-export interface CheckExecutionResultV2 {
-    internal_id: string;
-    outcome_key: string | null;
-    check_key: string;
-    status: CheckExecutionStatusV2;
-    evidence_adapter: EvidenceAdapter;
-    execution_identity: string;
-    assertion_results: AssertionResultV2[];
-    observations: Record<string, unknown>;
-    evidence_records: EvidenceCapabilityRecordV2[];
-    artifact_hashes: Record<string, string>;
-    claim_proofs: ClaimProofV2[];
-    findings: LongTaskFindingV2[];
-    attempts: number;
-    duration_ms: number;
-}
-export interface ProgressRecordV2 {
-    schema_version: "long-task-progress-record-v2";
-    compiled_identity: string;
-    outcome_authority_hash: string;
-    check_identity: string;
-    check_internal_id: string;
-    outcome_key: string | null;
-    check_key: string;
-    runner_verifier_identity: string;
-    relevant_context_identity: string;
-    resolved_input_path_hashes: Record<string, string>;
-    binding_carrier_path_hashes: Record<string, string>;
-    dependency_interface_identities: Record<string, string>;
-    result: CheckExecutionStatusV2;
-    check_result: CheckExecutionResultV2;
-    findings: LongTaskFindingV2[];
-    completed_at: string;
-}
-export type StrictRiskObligationV2 = {
-    outcome_key: string;
-    risk_fact: RiskFactName;
-    obligations: string[];
-};

package/dist/lib/long-task-runtime-types.js

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

package/dist/lib/long-task-scoped-binding.d.ts

@@ -1,13 +0,0 @@
-import type { DeliveryBindingV2 } from "./long-task-delivery-types.js";
-/**
- * Ephemeral compiler identity for one authored Outcome-local Binding.
- * Authored Contracts keep their existing local Binding keys.
- */
-export interface ScopedDeliveryBindingV2 {
-    outcome_key: string;
-    local_key: string;
-    binding_ref: string;
-    binding: DeliveryBindingV2;
-}
-export declare function scopeDeliveryBinding(outcomeKey: string, binding: DeliveryBindingV2): ScopedDeliveryBindingV2;
-export declare function scopeDeliveryBindings(outcomeKey: string, bindings: readonly DeliveryBindingV2[]): ScopedDeliveryBindingV2[];