project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-repair-frontier-groups.js

@@ -1,64 +0,0 @@
-import { intersects, normalizedClaimRefs, rootCauseKey, unique, } from "./long-task-repair-frontier-utils.js";
-export function groupRepairFindings(findings, checks, stillValidByCheck) {
-    const grouped = new Map();
-    for (const finding of findings) {
-        const root = rootCauseKey(finding);
-        const group = grouped.get(root);
-        if (group)
-            group.push(finding);
-        else
-            grouped.set(root, [finding]);
-    }
-    return [...grouped.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([root, rows]) => repairFrontierGroup(root, rows, checks, stillValidByCheck));
-}
-function repairFrontierGroup(root, rows, checks, stillValidByCheck) {
-    const matchingChecks = checks.filter((check) => rows.some((row) => findingMatchesCheck(row, check)));
-    return {
-        root_cause_key: root,
-        finding_codes: unique(rows.map((row) => row.code)),
-        source_fragment_refs: unique(rows.flatMap((row) => row.source_fragment_refs ?? [])),
-        affected_fact_refs: unique(rows.flatMap((row) => row.fact_refs ?? [])),
-        affected_proof_obligation_refs: unique(rows.flatMap((row) => row.proof_obligation_refs ?? [])),
-        affected_claim_refs: unique(rows.flatMap((row) => normalizedClaimRefs(row))),
-        expected_authority_refs: unique(rows.flatMap((row) => row.expected_authority_refs ?? [])),
-        actual_evidence_refs: unique(rows.flatMap((row) => row.actual_evidence_refs ?? [])),
-        suggested_implementation_owners: unique(rows.flatMap((row) => row.implementation_owner ? [row.implementation_owner.label] : [])),
-        suggested_owner_paths: unique(rows.flatMap((row) => row.implementation_owner?.path_globs ?? row.owner_paths ?? [])),
-        verification_owners: unique(rows.flatMap((row) => verificationOwnerRefs(row))),
-        invalidation_reasons: unique(rows.flatMap((row) => row.invalidation_reasons ?? [row.code])),
-        rerun_obligation_refs: unique(rows.flatMap((row) => row.rerun_obligation_refs ?? [])),
-        minimum_diagnostic_reverify: matchingChecks.map((check) => check.check_ref),
-        still_valid_diagnostic_evidence: groupStillValidEvidence(rows, stillValidByCheck),
-    };
-}
-function findingMatchesCheck(finding, check) {
-    return ((finding.check_key !== null &&
-        finding.check_key === check.check_key &&
-        (finding.outcome_key ?? null) === check.outcome_key) ||
-        intersects(finding.rerun_obligation_refs ?? [], check.obligation_refs));
-}
-function groupStillValidEvidence(rows, stillValidByCheck) {
-    const outcomeKeys = new Set(rows
-        .map((row) => row.outcome_key ?? row.owning_outcome_key)
-        .filter((value) => Boolean(value)));
-    return unique([...stillValidByCheck.entries()]
-        .filter(([ref]) => {
-        const outcome = ref.startsWith("GLOBAL.")
-            ? null
-            : ref.slice(0, ref.indexOf("."));
-        return outcome === null
-            ? outcomeKeys.size === 0
-            : outcomeKeys.has(outcome);
-    })
-        .map(([, evidence]) => evidence));
-}
-function verificationOwnerRefs(finding) {
-    const owner = finding.verification_owner;
-    if (owner?.kind === "machine_check")
-        return [`${owner.outcome_key ?? "GLOBAL"}.${owner.check_key}`];
-    if (owner?.kind === "external_confirmation")
-        return [`EXTERNAL.${owner.confirmation_ref}:${owner.owner}`];
-    return [];
-}

package/dist/lib/long-task-repair-frontier-utils.d.ts

@@ -1,6 +0,0 @@
-import type { CompiledCheckV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
-export declare function normalizedClaimRefs(finding: LongTaskFindingV2): string[];
-export declare function checkRef(check: Pick<CompiledCheckV2, "outcome_key" | "key">): string;
-export declare function rootCauseKey(finding: LongTaskFindingV2): string;
-export declare function intersects(left: string[], right: string[]): boolean;
-export declare function unique(values: string[]): string[];

package/dist/lib/long-task-repair-frontier-utils.js

@@ -1,27 +0,0 @@
-export function normalizedClaimRefs(finding) {
-    return unique((finding.claim_keys ?? []).map((claim) => finding.outcome_key && !claim.startsWith(`${finding.outcome_key}.`)
-        ? `${finding.outcome_key}.${claim}`
-        : claim));
-}
-export function checkRef(check) {
-    return `${check.outcome_key ?? "GLOBAL"}.${check.key}`;
-}
-export function rootCauseKey(finding) {
-    const scope = finding.outcome_key ?? finding.owning_outcome_key ?? "GLOBAL";
-    if (finding.check_key)
-        return `${scope}.${finding.check_key}`;
-    if (finding.binding_ref)
-        return `${scope}.binding:${finding.binding_ref}`;
-    if (finding.proof_obligation_refs?.length)
-        return `${scope}.proof:${finding.proof_obligation_refs[0]}`;
-    if (finding.fact_refs?.length)
-        return `${scope}.fact:${finding.fact_refs[0]}`;
-    return `${scope}.finding:${finding.code}`;
-}
-export function intersects(left, right) {
-    const rightSet = new Set(right);
-    return left.some((value) => rightSet.has(value));
-}
-export function unique(values) {
-    return [...new Set(values.filter(Boolean))].sort();
-}

package/dist/lib/long-task-repair-frontier.d.ts

@@ -1,14 +0,0 @@
-import type { CompiledDeliveryContractV2, LongTaskFindingV2, ProgressRecordV2, RepairFrontierV1, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export interface RepairFrontierInputV1 {
-    compiled: CompiledDeliveryContractV2;
-    manifest: WorkspaceManifestV2;
-    progress: Record<string, ProgressRecordV2>;
-    findings: LongTaskFindingV2[];
-    generated_at?: string;
-}
-/**
- * Builds a disposable diagnostic projection over the current candidate.
- * The projection deliberately has no persistence or acceptance path: Final
- * Gate must still rerun every declared Check on one snapshot.
- */
-export declare function deriveRepairFrontier(input: RepairFrontierInputV1): RepairFrontierV1;

package/dist/lib/long-task-repair-frontier.js

@@ -1,132 +0,0 @@
-import { enrichFinding } from "./long-task-finding-context.js";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { progressRecordFresh } from "./long-task-progress.js";
-import { allChecks, authorityPaths, checkDependencyPatterns, checkDependencyPatternsForBinding, checkObligationRefs, freshDiagnosticEvidence, rerunSessions, } from "./long-task-repair-frontier-checks.js";
-import { groupRepairFindings } from "./long-task-repair-frontier-groups.js";
-import { checkRef, normalizedClaimRefs, unique, } from "./long-task-repair-frontier-utils.js";
-import { changedWorkspacePaths } from "./long-task-workspace-manifest.js";
-/**
- * Builds a disposable diagnostic projection over the current candidate.
- * The projection deliberately has no persistence or acceptance path: Final
- * Gate must still rerun every declared Check on one snapshot.
- */
-export function deriveRepairFrontier(input) {
-    const findings = input.findings.map((finding) => enrichFinding(input.compiled, finding));
-    const checks = allChecks(input.compiled);
-    const changedPaths = changedWorkspacePaths(input.compiled.initial_task_base.workspace_manifest, input.manifest);
-    const reasonsByCheck = new Map();
-    for (const finding of findings)
-        for (const check of checks)
-            for (const reason of findingCheckReasons(finding, check))
-                addCheckReason(reasonsByCheck, check.internal_id, reason);
-    for (const check of checks) {
-        const changedInputs = changedPaths.filter((changedPath) => checkDependencyPatterns(input.compiled, check).some((pattern) => matchesRepoPattern(changedPath, pattern)));
-        for (const changedPath of changedInputs)
-            addCheckReason(reasonsByCheck, check.internal_id, `changed_input:${changedPath}`);
-        const record = input.progress[check.internal_id];
-        if (record &&
-            !progressRecordFresh(record, input.compiled, input.manifest, check))
-            addCheckReason(reasonsByCheck, check.internal_id, `stale_progress:${checkRef(check)}`);
-    }
-    const selectedChecks = selectedRepairChecks(checks, reasonsByCheck);
-    const selectedCheckRefs = new Set(selectedChecks.map((check) => check.check_ref));
-    const stillValidByCheck = freshDiagnosticEvidence(input.compiled, input.manifest, input.progress, selectedCheckRefs);
-    const groups = groupRepairFindings(findings, selectedChecks, stillValidByCheck);
-    const stillValidEvidence = unique([...stillValidByCheck.values()]);
-    return {
-        schema_version: "long-task-repair-frontier-v1",
-        authority_scope: "derived_diagnostic_only",
-        acceptance_authorized: false,
-        persisted: false,
-        compiled_identity: input.compiled.compiled_identity,
-        authority_revision: input.compiled.authority_revision,
-        candidate_snapshot_sha256: input.manifest.snapshot_sha256,
-        changed_paths: changedPaths,
-        summary: {
-            finding_groups: groups.length,
-            affected_facts: unique(groups.flatMap((group) => group.affected_fact_refs)).length,
-            affected_proof_obligations: unique(groups.flatMap((group) => group.affected_proof_obligation_refs)).length,
-            minimum_checks: selectedChecks.length,
-            still_valid_progress_records: stillValidEvidence.length,
-        },
-        groups,
-        minimum_diagnostic_reverify: selectedChecks,
-        rerun_sessions: rerunSessions(selectedChecks),
-        still_valid_diagnostic_evidence: stillValidEvidence,
-        forbidden_authority_changes_without_revision: {
-            fields: [
-                "Source",
-                "Expected",
-                "Claim",
-                "proof_method_or_capability",
-                "external_confirmation_scope_or_owner",
-                "comparator_tolerance_or_mask",
-                "applicability",
-            ],
-            protected_paths: authorityPaths(input.compiled),
-        },
-        final_gate_requirement: "complete_one_snapshot_rerun_still_required",
-        generated_at: input.generated_at ?? new Date().toISOString(),
-    };
-}
-function selectedRepairChecks(checks, reasonsByCheck) {
-    return checks
-        .filter((check) => reasonsByCheck.has(check.internal_id))
-        .map((check) => ({
-        check_ref: checkRef(check),
-        outcome_key: check.outcome_key,
-        check_key: check.key,
-        raw_execution_identity: check.raw_execution_identity,
-        obligation_refs: checkObligationRefs(check),
-        reasons: [...reasonsByCheck.get(check.internal_id)].sort(),
-    }))
-        .sort((left, right) => left.check_ref.localeCompare(right.check_ref));
-}
-function findingCheckReasons(finding, check) {
-    const reasons = [];
-    if (finding.check_key !== null &&
-        finding.check_key === check.key &&
-        (finding.outcome_key ?? null) === check.outcome_key)
-        reasons.push(`finding:${finding.code}`);
-    const facts = new Set(finding.fact_refs ?? []);
-    const proofs = new Set(finding.proof_obligation_refs ?? []);
-    const claims = new Set(normalizedClaimRefs(finding));
-    const reruns = new Set(finding.rerun_obligation_refs ?? []);
-    for (const expectation of check.semantic_fact_expectations)
-        reasons.push(...semanticExpectationReasons(expectation, facts, proofs, claims, reruns));
-    for (const authority of check.observation_authorities)
-        reasons.push(...observationAuthorityReasons(authority, facts, proofs, claims, reruns));
-    if (finding.binding_ref &&
-        checkDependencyPatternsForBinding(check, finding.binding_ref).length)
-        reasons.push(`affected_binding:${finding.binding_ref}`);
-    return unique(reasons);
-}
-function semanticExpectationReasons(expectation, facts, proofs, claims, reruns) {
-    const reasons = [];
-    if (facts.has(expectation.fact_ref))
-        reasons.push(`affected_fact:${expectation.fact_ref}`);
-    if (proofs.has(expectation.proof_ref) || reruns.has(expectation.proof_ref))
-        reasons.push(`affected_proof:${expectation.proof_ref}`);
-    if (claims.has(expectation.claim_ref))
-        reasons.push(`affected_claim:${expectation.claim_ref}`);
-    return reasons;
-}
-function observationAuthorityReasons(authority, facts, proofs, claims, reruns) {
-    const reasons = [];
-    if (authority.fact_ref && facts.has(authority.fact_ref))
-        reasons.push(`affected_fact:${authority.fact_ref}`);
-    if (proofs.has(authority.obligation_ref) ||
-        reruns.has(authority.obligation_ref))
-        reasons.push(`affected_proof:${authority.obligation_ref}`);
-    for (const claim of authority.claim_refs)
-        if (claims.has(claim))
-            reasons.push(`affected_claim:${claim}`);
-    return reasons;
-}
-function addCheckReason(target, internalId, reason) {
-    const reasons = target.get(internalId);
-    if (reasons)
-        reasons.add(reason);
-    else
-        target.set(internalId, new Set([reason]));
-}

package/dist/lib/long-task-required-proof-surfaces.d.ts

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

package/dist/lib/long-task-required-proof-surfaces.js

@@ -1,13 +0,0 @@
-import { array, fail, literal, PROOF_SURFACES, } from "./long-task-shape-primitives.js";
-export function parseRequiredProofSurfaces(value, label) {
-    const surfaces = array(value, label).map((surface, index) => literal(surface, PROOF_SURFACES, `${label}[${index}]`));
-    if (!surfaces.length)
-        fail("required_proof_surfaces_empty", label);
-    const seen = new Set();
-    for (const surface of surfaces) {
-        if (seen.has(surface))
-            fail("required_proof_surface_duplicate", `${label}:${surface}`);
-        seen.add(surface);
-    }
-    return surfaces;
-}

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

@@ -1,2 +0,0 @@
-import type { DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
-export declare function parseRequirements(value: unknown, label: string): DeliveryOutcomeV2["product"]["requirements"];

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

@@ -1,21 +0,0 @@
-import { parseKeyRefs } from "./long-task-applicability-shape.js";
-import { parseRequiredProofSurfaces } from "./long-task-required-proof-surfaces.js";
-import { array, key, object, string } from "./long-task-shape-primitives.js";
-export function parseRequirements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "statement",
-            "required_proof_surfaces",
-            "applicability_refs",
-        ]);
-        const surfaces = parseRequiredProofSurfaces(row.required_proof_surfaces, `${itemLabel}.required_proof_surfaces`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            required_proof_surfaces: surfaces,
-            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
-        };
-    });
-}

package/dist/lib/long-task-risk-surfaces.d.ts

@@ -1,2 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function validateActualRiskSurfaces(repository: string, changedPaths: string[], contract: DeliveryContractV2): Promise<void>;

package/dist/lib/long-task-risk-surfaces.js

@@ -1,60 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { parseStrictYaml } from "./strict-codec.js";
-export async function validateActualRiskSurfaces(repository, changedPaths, contract) {
-    const inferred = new Set();
-    const surfaces = await readRiskSurfaces(repository);
-    for (const surface of surfaces)
-        if (changedPaths.some((changed) => surface.paths.some((pattern) => matchesRepoPattern(changed, pattern)))) {
-            if (surface.risk === "classification_required")
-                throw new Error("risk_classification_required");
-            inferred.add(surface.risk);
-        }
-    for (const fact of inferred)
-        if (contract.risk.facts[fact].length === 0)
-            throw new Error(`risk_fact_underdeclared:${fact}`);
-}
-async function readRiskSurfaces(repository) {
-    const file = path.join(repository, "project_context", "risk-surfaces.yaml");
-    let raw;
-    try {
-        raw = await readFile(file, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const value = parseStrictYaml(raw);
-    if (!Array.isArray(value))
-        throw new Error("risk_surfaces_invalid:root");
-    const facts = new Set([
-        "public_api_or_schema_change",
-        "persistent_data_change",
-        "data_migration",
-        "security_boundary_change",
-        "permission_boundary_change",
-        "irreversible_external_effect",
-        "critical_user_path",
-        "full_population_operation",
-        "multi_repository_change",
-        "weak_observability",
-        "classification_required",
-    ]);
-    return value.map((item, index) => {
-        if (!item || typeof item !== "object" || Array.isArray(item))
-            throw new Error(`risk_surfaces_invalid:${index}`);
-        const row = item;
-        if (Object.keys(row).some((key) => !["risk", "paths"].includes(key)) ||
-            typeof row.risk !== "string" ||
-            !facts.has(row.risk) ||
-            !Array.isArray(row.paths) ||
-            row.paths.some((value) => typeof value !== "string" || !value))
-            throw new Error(`risk_surfaces_invalid:${index}`);
-        return {
-            risk: row.risk,
-            paths: row.paths,
-        };
-    });
-}

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

@@ -1,5 +0,0 @@
-export type RequestedRiskLevel = "auto" | "standard" | "strict";
-export type EffectiveRiskLevel = "standard" | "strict";
-export declare const RISK_FACT_NAMES: readonly ["public_api_or_schema_change", "persistent_data_change", "data_migration", "security_boundary_change", "permission_boundary_change", "irreversible_external_effect", "critical_user_path", "full_population_operation", "multi_repository_change", "weak_observability"];
-export type RiskFactName = (typeof RISK_FACT_NAMES)[number];
-export type LongTaskRiskFacts = Record<RiskFactName, string[]>;

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

@@ -1,12 +0,0 @@
-export const RISK_FACT_NAMES = [
-    "public_api_or_schema_change",
-    "persistent_data_change",
-    "data_migration",
-    "security_boundary_change",
-    "permission_boundary_change",
-    "irreversible_external_effect",
-    "critical_user_path",
-    "full_population_operation",
-    "multi_repository_change",
-    "weak_observability",
-];

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

@@ -1,10 +0,0 @@
-import type { DeliveryContractV2, CompiledOutcomeV2, EffectiveRiskLevel, RiskFactName } from "./long-task-delivery-types.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-export interface RiskDecisionV2 {
-    effective_level: EffectiveRiskLevel;
-    minimum_level: EffectiveRiskLevel;
-    reasons: string[];
-    reasons_by_outcome: Record<string, RiskFactName[]>;
-}
-export declare function classifyLongTaskRisk(contract: DeliveryContractV2): RiskDecisionV2;
-export declare function validateRiskProof(contract: DeliveryContractV2, decision: RiskDecisionV2, reachability?: AcceptanceReachabilityV1 | null, compiledOutcomes?: readonly CompiledOutcomeV2[]): void;

package/dist/lib/long-task-risk.js

@@ -1,186 +0,0 @@
-import { machineAuthorizedAssertionExists } from "./long-task-acceptance-reachability-helpers.js";
-import { outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked, outcomeResultFullyEffectivelyExternallyBlocked, } from "./long-task-effective-external-takeover.js";
-import { outcomeUiProofFullyEffectivelyExternallyBlocked } from "./long-task-effective-external-ui-takeover.js";
-const STRICT_FACTS = new Set([
-    "public_api_or_schema_change",
-    "persistent_data_change",
-    "data_migration",
-    "security_boundary_change",
-    "permission_boundary_change",
-    "irreversible_external_effect",
-    "full_population_operation",
-    "multi_repository_change",
-]);
-export function classifyLongTaskRisk(contract) {
-    const outcomeKeys = new Set(contract.outcomes.map((outcome) => outcome.key));
-    const reasonsByOutcome = Object.fromEntries(contract.outcomes.map((outcome) => [outcome.key, []]));
-    for (const [fact, outcomes] of Object.entries(contract.risk.facts)) {
-        for (const outcome of outcomes) {
-            if (!outcomeKeys.has(outcome))
-                throw new Error(`risk_outcome_unknown:${fact}:${outcome}`);
-            reasonsByOutcome[outcome].push(fact);
-        }
-    }
-    if (contract.risk.facts.multi_repository_change.length)
-        throw new Error("multi_repository_delivery_not_supported_v2");
-    const reasons = Object.entries(reasonsByOutcome)
-        .flatMap(([outcome, facts]) => facts
-        .filter((fact) => STRICT_FACTS.has(fact))
-        .map((fact) => `${fact}:${outcome}`))
-        .concat(contract.outcomes
-        .filter((outcome) => contract.risk.facts.critical_user_path.includes(outcome.key) &&
-        contract.risk.facts.weak_observability.includes(outcome.key))
-        .map((outcome) => `critical_user_path_with_weak_observability:${outcome.key}`));
-    const minimum = reasons.length ? "strict" : "standard";
-    if (contract.risk.requested_level === "standard" && minimum === "strict")
-        throw new Error(`risk_level_below_required:${reasons.join(",")}`);
-    return {
-        minimum_level: minimum,
-        effective_level: contract.risk.requested_level === "strict" ? "strict" : minimum,
-        reasons,
-        reasons_by_outcome: reasonsByOutcome,
-    };
-}
-export function validateRiskProof(contract, decision, reachability, compiledOutcomes) {
-    const errors = [];
-    if (!contract.outcomes.length)
-        errors.push("outcome_required");
-    for (const check of contract.global.acceptance.checks)
-        validateCheck(check, "global", errors);
-    for (const outcome of contract.outcomes)
-        validateOutcome(contract, outcome, errors, reachability, compiledOutcomes?.find((candidate) => candidate.key === outcome.key), compiledOutcomes !== undefined);
-    if (decision.effective_level === "strict")
-        validateStrict(contract, decision, errors, reachability, compiledOutcomes);
-    if (errors.length)
-        throw new Error(`delivery_contract_preflight_failed:\n${errors.join("\n")}`);
-}
-function validateOutcome(contract, outcome, errors, reachability, compiledOutcome, useCompiledAuthority = false) {
-    const declaredChecks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
-    const resultExternallyBlocked = outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability);
-    const hasMachineProof = useCompiledAuthority
-        ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], { authority_scope: "ordinary_claim", outcome_key: outcome.key })
-        : declaredChecks.size > 0;
-    if (!hasMachineProof && !resultExternallyBlocked)
-        errors.push(`outcome_without_executable_check:${outcome.key}`);
-    if (!outcome.technical.expected_change_paths.length)
-        errors.push(`expected_change_paths_empty:${outcome.key}`);
-    for (const check of declaredChecks.values())
-        validateCheck(check, outcome.key, errors);
-    const hasMachineUiProof = useCompiledAuthority
-        ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], {
-            authority_scope: "ordinary_claim",
-            outcome_key: outcome.key,
-            proof_surface: "ui_browser",
-        })
-        : [...declaredChecks.values()].some((check) => check.proof_surface === "ui_browser");
-    const uiProofExternallyBlocked = useCompiledAuthority &&
-        outcomeUiProofFullyEffectivelyExternallyBlocked(contract, outcome, reachability);
-    if ((outcome.product.owner_surfaces.length ||
-        outcome.product.controls.length) &&
-        !hasMachineUiProof &&
-        !uiProofExternallyBlocked)
-        errors.push(`ui_outcome_requires_ui_browser_proof:${outcome.key}`);
-    const referenced = [
-        ...(outcome.acceptance.population
-            ? [outcome.acceptance.population.check_key]
-            : []),
-        ...outcome.acceptance.counterfactual_controls.map((control) => control.check_key),
-        ...(outcome.technical.rollback_and_recovery?.verification_check_keys ?? []),
-        ...outcome.technical.bindings.flatMap((binding) => binding.verification_check_key ? [binding.verification_check_key] : []),
-    ];
-    for (const checkKey of referenced)
-        if (!declaredChecks.has(checkKey))
-            errors.push(`outcome_check_reference_unknown:${outcome.key}:${checkKey}`);
-}
-function validateStrict(contract, decision, errors, reachability, compiledOutcomes) {
-    const explicitStrictWithoutFacts = contract.risk.requested_level === "strict" && decision.reasons.length === 0;
-    for (const outcome of contract.outcomes) {
-        if (outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability))
-            continue;
-        const compiledOutcome = compiledOutcomes?.find((candidate) => candidate.key === outcome.key);
-        const useCompiledAuthority = compiledOutcomes !== undefined;
-        const facts = new Set(decision.reasons_by_outcome[outcome.key]);
-        const checks = outcome.acceptance.checks;
-        const hasNegative = useCompiledAuthority
-            ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], {
-                authority_scope: "ordinary_claim",
-                outcome_key: outcome.key,
-                polarity: "negative",
-            })
-            : checks.some((check) => check.negative_assertions.length > 0);
-        const hasCounterfactual = useCompiledAuthority
-            ? hasMachineCounterfactual(compiledOutcome)
-            : outcome.acceptance.counterfactual_controls.length > 0;
-        if (explicitStrictWithoutFacts) {
-            if (!hasNegative)
-                errors.push(`strict_negative_assertion_required:${outcome.key}`);
-            if (!hasCounterfactual)
-                errors.push(`strict_counterfactual_control_required:${outcome.key}`);
-        }
-        if (facts.has("security_boundary_change") ||
-            facts.has("permission_boundary_change"))
-            requireStrictProof(outcome, "security_boundary", hasMachineSurfaceProof(outcome, compiledOutcome, "security_boundary", useCompiledAuthority), hasNegative, hasCounterfactual, errors);
-        if (facts.has("public_api_or_schema_change"))
-            requireStrictProof(outcome, "api_contract", hasMachineSurfaceProof(outcome, compiledOutcome, "api_contract", useCompiledAuthority), hasNegative, hasCounterfactual, errors);
-        if (facts.has("persistent_data_change") || facts.has("data_migration")) {
-            requireStrictProof(outcome, "data_state", hasMachineSurfaceProof(outcome, compiledOutcome, "data_state", useCompiledAuthority), hasNegative, hasCounterfactual, errors);
-            if (!outcome.technical.rollback_and_recovery)
-                errors.push(`strict_rollback_and_recovery_required:${outcome.key}`);
-        }
-        if (facts.has("irreversible_external_effect") &&
-            !outcome.technical.rollback_and_recovery)
-            errors.push(`strict_rollback_and_recovery_required:${outcome.key}`);
-        if (facts.has("full_population_operation")) {
-            if (!strictPopulationCoverageProofSatisfied(outcome, compiledOutcome, reachability, useCompiledAuthority))
-                errors.push(`strict_population_coverage_proof_required:${outcome.key}`);
-            if (!outcome.acceptance.population)
-                errors.push(`strict_population_declaration_required:${outcome.key}`);
-        }
-        if (facts.has("critical_user_path") &&
-            facts.has("weak_observability") &&
-            !(hasMachineSurfaceProof(outcome, compiledOutcome, "ui_browser", useCompiledAuthority) ||
-                hasMachineSurfaceProof(outcome, compiledOutcome, "runtime_behavior", useCompiledAuthority)))
-            errors.push(`strict_critical_path_observable_proof_required:${outcome.key}`);
-    }
-}
-function strictPopulationCoverageProofSatisfied(outcome, compiledOutcome, reachability, useCompiledAuthority) {
-    return (hasMachineSurfaceProof(outcome, compiledOutcome, "population_coverage", useCompiledAuthority) ||
-        (useCompiledAuthority &&
-            outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome, reachability)));
-}
-function hasMachineSurfaceProof(outcome, compiledOutcome, surface, useCompiledAuthority) {
-    return useCompiledAuthority
-        ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], {
-            authority_scope: "ordinary_claim",
-            outcome_key: outcome.key,
-            proof_surface: surface,
-        })
-        : outcome.acceptance.checks.some((check) => check.proof_surface === surface);
-}
-function hasMachineCounterfactual(outcome) {
-    if (!outcome)
-        return false;
-    return outcome.acceptance.counterfactual_controls.some((control) => control.claims.length > 0 &&
-        control.expected_assertion_failures.some((assertionRef) => machineAuthorizedAssertionExists(outcome.acceptance.checks, {
-            authority_scope: "ordinary_claim",
-            outcome_key: outcome.key,
-            check_key: control.check_key,
-            assertion_key: assertionRef,
-        })));
-}
-function requireStrictProof(outcome, surface, hasSurfaceProof, hasNegative, hasCounterfactual, errors) {
-    if (!hasSurfaceProof)
-        errors.push(`strict_${surface}_proof_required:${outcome.key}`);
-    if (!hasNegative)
-        errors.push(`strict_negative_assertion_required:${outcome.key}`);
-    if (!hasCounterfactual)
-        errors.push(`strict_counterfactual_control_required:${outcome.key}`);
-}
-function validateCheck(check, owner, errors) {
-    if (!check.verification_inputs.length)
-        errors.push(`verification_inputs_empty:${owner}:${check.key}`);
-    if (check.runner.retry_policy === "transient_once" &&
-        (!check.runner.idempotent ||
-            !["read_only", "test_sandbox"].includes(check.runner.effect)))
-        errors.push(`unsafe_retry_policy:${owner}:${check.key}`);
-}

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

@@ -1,5 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function parseTask(value: unknown): DeliveryContractV2["task"];
-export declare function parseStages(value: unknown): DeliveryContractV2["stages"];
-export declare function parseRisk(value: unknown): DeliveryContractV2["risk"];
-export declare function parseGlobal(value: unknown): DeliveryContractV2["global"];