project-tiny-context-harness 0.8.17 → 0.11.0

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

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

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

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

package/dist/lib/long-task-proof-capability-floor.js

@@ -0,0 +1,137 @@
+import { controlFieldFacts } from "./long-task-control-fields.js";
+const CONTROL_EXISTS_FIELDS = new Set([
+    "surface",
+    "region",
+    "location",
+    "control_type",
+    "label_content",
+    "visibility",
+]);
+const CONTROL_STATE_FIELDS = new Set([
+    "availability",
+    "default_value",
+    "loading",
+    "empty",
+    "failure",
+    "permission",
+    "feedback",
+    "accessibility",
+]);
+const CONTROL_PRODUCT_EFFECT_FIELDS = new Set([
+    "user_task",
+    "trigger",
+    "input",
+    "validation",
+    "interaction",
+    "navigation_result",
+    "success",
+    "recovery",
+]);
+export function assertionCapabilityFloor(contract, outcomeKey, check, assertion, claim, expectations, semanticClaimFloor = new Set()) {
+    const result = externalClaimCapabilityFloor(contract, outcomeKey, assertion.claims[0], check.proof_surface, assertion.applicability_ref ?? null, check.key);
+    if (assertion.operator === "exists")
+        result.add("presence");
+    if ("kind" in claim && claim.kind === "result")
+        result.add("target_runtime");
+    addControlCapabilityFloor(result, contract, outcomeKey, claim);
+    addProofSurfaceFloor(result, check.proof_surface);
+    if (check.journey_roles.includes("recovery")) {
+        result.add("failure_injection");
+        result.add("recovery");
+    }
+    const outcome = outcomeKey
+        ? contract.outcomes.find((item) => item.key === outcomeKey)
+        : null;
+    if (outcome?.acceptance.population?.check_key === check.key &&
+        outcome.acceptance.population.claims.includes(assertion.claims[0]))
+        result.add("population_coverage");
+    if (assertion.evidence_capabilities.includes("visual_render") ||
+        assertion.evidence_capabilities.includes("design_conformance")) {
+        result.add("visual_render");
+        result.add("design_conformance");
+    }
+    const semantic = expectations.find((item) => item.assertion_ref === assertion.key);
+    if (semantic)
+        for (const capability of semanticFactCapabilityFloor(semantic, contract))
+            result.add(capability);
+    for (const capability of semanticClaimFloor)
+        result.add(capability);
+    return result;
+}
+export function externalClaimCapabilityFloor(contract, outcomeKey, localClaim, proofSurface, applicabilityRef, checkKey = null) {
+    const result = new Set();
+    if (localClaim === "result")
+        result.add("target_runtime");
+    addExternalControlCapabilityFloor(result, contract, outcomeKey, localClaim);
+    addProofSurfaceFloor(result, proofSurface);
+    const profile = applicabilityRef
+        ? (outcomeKey
+            ? contract.outcomes.find((item) => item.key === outcomeKey)
+                ?.applicability
+            : contract.global.applicability)?.find((item) => item.key === applicabilityRef)
+        : null;
+    if (profile?.journey_role === "recovery") {
+        result.add("failure_injection");
+        result.add("recovery");
+    }
+    const outcome = outcomeKey
+        ? contract.outcomes.find((item) => item.key === outcomeKey)
+        : null;
+    if (outcome?.acceptance.population &&
+        (!checkKey || outcome.acceptance.population.check_key === checkKey) &&
+        outcome.acceptance.population.claims.includes(localClaim))
+        result.add("population_coverage");
+    return result;
+}
+function addControlCapabilityFloor(result, contract, outcomeKey, claim) {
+    if (!("kind" in claim) || claim.kind !== "control" || !outcomeKey)
+        return;
+    addSpecifiedControlFloor(result, contract, outcomeKey, claim.local_key);
+}
+function addExternalControlCapabilityFloor(result, contract, outcomeKey, localClaim) {
+    if (!localClaim.startsWith("control.") || !outcomeKey)
+        return;
+    addSpecifiedControlFloor(result, contract, outcomeKey, localClaim);
+}
+function addSpecifiedControlFloor(result, contract, outcomeKey, localClaim) {
+    const field = localClaim.split(".").at(-1);
+    if (!controlClaimSpecified(contract, outcomeKey, localClaim))
+        return;
+    if (CONTROL_EXISTS_FIELDS.has(field))
+        result.add("presence");
+    if (CONTROL_STATE_FIELDS.has(field)) {
+        result.add("interaction_trace");
+        result.add("state_delta");
+    }
+    if (field === "permission") {
+        result.add("input_variation");
+        result.add("distinct_identity");
+        result.add("data_state");
+        result.add("target_runtime");
+    }
+    if (CONTROL_PRODUCT_EFFECT_FIELDS.has(field)) {
+        result.add("interaction_trace");
+        result.add("input_variation");
+        result.add("state_delta");
+    }
+}
+function addProofSurfaceFloor(result, proofSurface) {
+    if (proofSurface === "implementation_structure")
+        result.add("presence");
+    if (proofSurface === "data_state")
+        result.add("data_state");
+    if (proofSurface === "population_coverage")
+        result.add("population_coverage");
+}
+function semanticFactCapabilityFloor(expectation, contract) {
+    const outcome = contract.outcomes.find((item) => item.key === expectation.outcome_ref);
+    const binding = outcome?.semantic_fact_bindings.proofs.find((item) => item.proof_ref === expectation.proof_ref);
+    return new Set(binding?.evidence_capabilities ?? []);
+}
+function controlClaimSpecified(contract, outcomeKey, localClaim) {
+    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
+    const [, controlKey, field] = localClaim.split(".");
+    const control = outcome.product.controls.find((item) => item.key === controlKey);
+    return Boolean(control &&
+        controlFieldFacts(control).some((item) => item.claim_field === field && item.state === "specified"));
+}

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

@@ -0,0 +1,8 @@
+import type { CompiledCheckV2, CompiledDeliveryContractV2, ProgressRecordV2, RepairFrontierCheckV1, RepairFrontierSessionV1, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function checkDependencyPatterns(compiled: CompiledDeliveryContractV2, check: CompiledCheckV2): string[];
+export declare function checkDependencyPatternsForBinding(check: CompiledCheckV2, bindingRef: string): string[];
+export declare function freshDiagnosticEvidence(compiled: CompiledDeliveryContractV2, manifest: WorkspaceManifestV2, progress: Record<string, ProgressRecordV2>, selectedCheckRefs: Set<string>): Map<string, string>;
+export declare function rerunSessions(checks: RepairFrontierCheckV1[]): RepairFrontierSessionV1[];
+export declare function authorityPaths(compiled: CompiledDeliveryContractV2): string[];
+export declare function allChecks(compiled: CompiledDeliveryContractV2): CompiledCheckV2[];
+export declare function checkObligationRefs(check: CompiledCheckV2): string[];

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

@@ -0,0 +1,93 @@
+import { progressRecordFresh } from "./long-task-progress.js";
+import { checkRef, unique } from "./long-task-repair-frontier-utils.js";
+export function checkDependencyPatterns(compiled, check) {
+    const outcome = check.outcome_key
+        ? compiled.outcomes.find((item) => item.key === check.outcome_key)
+        : null;
+    const direct = [
+        ...check.input_paths,
+        ...check.verification_inputs,
+        ...check.expected_output_paths,
+        ...Object.keys(check.runner.frozen_files),
+        ...check.observation_authorities.flatMap((authority) => authority.carrier_refs.flatMap((carrier) => carrier.carrier_paths)),
+    ];
+    if (outcome)
+        direct.push(...outcome.product.owner.path_globs, ...outcome.technical.expected_change_paths, ...outcome.technical.allowed_support_paths, ...outcome.technical.bindings.flatMap((binding) => binding.kind === "file" || binding.kind === "path_glob"
+            ? [binding.target, ...binding.carrier_paths]
+            : binding.carrier_paths));
+    else
+        for (const control of compiled.global.acceptance.counterfactual_controls) {
+            if (control.check_key !== check.key)
+                continue;
+            direct.push(...bindingPatterns(compiled, control.binding_ref));
+        }
+    return unique(direct);
+}
+export function checkDependencyPatternsForBinding(check, bindingRef) {
+    return unique(check.observation_authorities
+        .flatMap((authority) => authority.carrier_refs)
+        .filter((carrier) => carrier.binding_ref === bindingRef)
+        .flatMap((carrier) => carrier.carrier_paths));
+}
+export function freshDiagnosticEvidence(compiled, manifest, progress, selectedCheckRefs) {
+    const result = new Map();
+    for (const check of allChecks(compiled)) {
+        const record = progress[check.internal_id];
+        if (!record ||
+            selectedCheckRefs.has(checkRef(check)) ||
+            !progressRecordFresh(record, compiled, manifest, check))
+            continue;
+        result.set(checkRef(check), `progress:${checkRef(check)}:${record.result}:${record.completed_at}`);
+    }
+    return result;
+}
+export function rerunSessions(checks) {
+    const groups = new Map();
+    for (const check of checks) {
+        const group = groups.get(check.raw_execution_identity);
+        if (group)
+            group.push(check);
+        else
+            groups.set(check.raw_execution_identity, [check]);
+    }
+    return [...groups.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([identity, rows]) => ({
+        raw_execution_identity: identity,
+        check_refs: unique(rows.map((row) => row.check_ref)),
+        obligation_refs: unique(rows.flatMap((row) => row.obligation_refs)),
+    }));
+}
+export function authorityPaths(compiled) {
+    return unique([
+        compiled.contract_file,
+        ...Object.keys(compiled.contract_files),
+        ...Object.keys(compiled.source_hashes),
+        ...compiled.context_snapshot.files,
+        ...compiled.task.source_paths,
+        compiled.semantic_fact_manifest.source_path,
+    ]);
+}
+export function allChecks(compiled) {
+    return [
+        ...compiled.global.acceptance.checks,
+        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
+    ];
+}
+export function checkObligationRefs(check) {
+    return unique([
+        ...check.semantic_fact_expectations.map((expectation) => expectation.proof_ref),
+        ...check.observation_authorities.map((authority) => authority.obligation_ref),
+    ]);
+}
+function bindingPatterns(compiled, bindingRef) {
+    const [outcomeKey, bindingKey] = bindingRef.split(".");
+    const binding = compiled.outcomes
+        .find((outcome) => outcome.key === outcomeKey)
+        ?.technical.bindings.find((candidate) => candidate.key === bindingKey);
+    if (!binding)
+        return [];
+    return binding.kind === "file" || binding.kind === "path_glob"
+        ? [binding.target, ...binding.carrier_paths]
+        : binding.carrier_paths;
+}

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

@@ -0,0 +1,2 @@
+import type { LongTaskFindingV2, RepairFrontierCheckV1, RepairFrontierGroupV1 } from "./long-task-delivery-types.js";
+export declare function groupRepairFindings(findings: LongTaskFindingV2[], checks: RepairFrontierCheckV1[], stillValidByCheck: Map<string, string>): RepairFrontierGroupV1[];

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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,132 @@
+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-risk.d.ts

@@ -1,4 +1,5 @@
-import type { DeliveryContractV2, EffectiveRiskLevel, RiskFactName } from "./long-task-delivery-types.js";
+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;
@@ -6,4 +7,4 @@ export interface RiskDecisionV2 {
     reasons_by_outcome: Record<string, RiskFactName[]>;
 }
 export declare function classifyLongTaskRisk(contract: DeliveryContractV2): RiskDecisionV2;
-export declare function validateRiskProof(contract: DeliveryContractV2, decision: RiskDecisionV2): void;
+export declare function validateRiskProof(contract: DeliveryContractV2, decision: RiskDecisionV2, reachability?: AcceptanceReachabilityV1 | null, compiledOutcomes?: readonly CompiledOutcomeV2[]): void;