project-tiny-context-harness 0.2.84 → 0.6.0

package/dist/lib/long-task-authority-revision-details.js

@@ -0,0 +1,192 @@
+import { proveRepositoryPatternSubset } from "./long-task-paths.js";
+import { canonicalValueJson } from "./strict-codec.js";
+export function checkIndex(globalChecks, outcomes) {
+    return new Map([
+        ...globalChecks.map((check) => [`GLOBAL.${check.key}`, check]),
+        ...outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [`${outcome.key}.${check.key}`, check])),
+    ]);
+}
+export function changedRunnerFields(identity, before, after) {
+    const beforeRunner = declaredRunner(before);
+    const afterRunner = declaredRunner(after);
+    const changed = Object.keys(beforeRunner)
+        .filter((field) => !same(beforeRunner[field], afterRunner[field]))
+        .map((field) => `${identity}:${field}`);
+    if (before.runner.resolved_target !== after.runner.resolved_target)
+        changed.push(`${identity}:resolved_target`);
+    if (before.runner.resolved_cwd !== after.runner.resolved_cwd)
+        changed.push(`${identity}:resolved_cwd`);
+    if (before.runner.package_script !== after.runner.package_script)
+        changed.push(`${identity}:package_script`);
+    return changed;
+}
+export function removedOrReplacedVerificationInputs(identity, before, after) {
+    return Object.entries(before.verification_input_hashes)
+        .filter(([file, hash]) => after.verification_input_hashes[file] !== hash)
+        .map(([file]) => `${identity}:${file}`);
+}
+export function removedOrNarrowedInputPaths(identity, before, after) {
+    return before.input_paths
+        .filter((oldPattern) => !after.input_paths.some((newPattern) => proveRepositoryPatternSubset(oldPattern, newPattern).status ===
+        "proven_subset"))
+        .map((pattern) => `${identity}:${pattern}`);
+}
+export function removedOrWeakenedExpectedOutputPaths(identity, before, after) {
+    return before.expected_output_paths
+        .filter((oldPattern) => !after.expected_output_paths.some((newPattern) => proveRepositoryPatternSubset(newPattern, oldPattern).status ===
+        "proven_subset"))
+        .map((pattern) => `${identity}:${pattern}`);
+}
+export function sourceClaimReductions(beforeClaims, afterClaims) {
+    const after = new Map(afterClaims.map((claim) => [claim.key, claim]));
+    const changed = [];
+    for (const claim of beforeClaims) {
+        const candidate = after.get(claim.key);
+        if (!candidate) {
+            changed.push(`${claim.key}:removed`);
+            continue;
+        }
+        if (claim.statement !== candidate.statement ||
+            claim.source_ref !== candidate.source_ref ||
+            claim.disposition.type !== candidate.disposition.type) {
+            changed.push(`${claim.key}:authority_changed`);
+            continue;
+        }
+        if ((claim.disposition.type === "claim" ||
+            claim.disposition.type === "global_constraint" ||
+            claim.disposition.type === "risk_fact") &&
+            (candidate.disposition.type === "claim" ||
+                candidate.disposition.type === "global_constraint" ||
+                candidate.disposition.type === "risk_fact")) {
+            const nextRefs = new Set(candidate.disposition.refs);
+            if (claim.disposition.refs.some((reference) => !nextRefs.has(reference)))
+                changed.push(`${claim.key}:disposition_refs_removed_or_replaced`);
+        }
+        else if (!same(claim.disposition, candidate.disposition))
+            changed.push(`${claim.key}:disposition_changed`);
+    }
+    return changed;
+}
+export function removedGlobalForbiddenPaths(previous, next) {
+    const after = new Map(next.global.technical.forbidden_paths.map((item) => [item.key, item.path]));
+    return previous.global.technical.forbidden_paths
+        .filter((item) => after.get(item.key) !== item.path)
+        .map((item) => `GLOBAL:${item.key}:${item.path}`);
+}
+export function bindingReductions(before, after) {
+    const nextBindings = new Map(after.technical.bindings.map((binding) => [binding.key, binding]));
+    const reductions = [];
+    for (const binding of before.technical.bindings) {
+        const candidate = nextBindings.get(binding.key);
+        if (!candidate) {
+            reductions.push(`${after.key}:${binding.key}:removed`);
+            continue;
+        }
+        if (binding.kind !== candidate.kind ||
+            binding.target !== candidate.target ||
+            binding.existence !== candidate.existence ||
+            binding.verification_check_key !== candidate.verification_check_key)
+            reductions.push(`${after.key}:${binding.key}:target_or_kind_changed`);
+        reductions.push(...expandedPatterns(`${after.key}:${binding.key}`, binding.carrier_paths, candidate.carrier_paths));
+    }
+    return reductions;
+}
+export function obligationReductions(before, after) {
+    const nextObligations = new Map(after.technical.obligations.map((obligation) => [
+        obligation.key,
+        obligation,
+    ]));
+    const reductions = [];
+    for (const obligation of before.technical.obligations) {
+        const candidate = nextObligations.get(obligation.key);
+        if (!candidate) {
+            reductions.push(`${after.key}:${obligation.key}:removed`);
+            continue;
+        }
+        if (obligation.statement !== candidate.statement)
+            reductions.push(`${after.key}:${obligation.key}:statement_changed`);
+        const nextSurfaces = new Set(candidate.required_proof_surfaces);
+        if (obligation.required_proof_surfaces.some((surface) => !nextSurfaces.has(surface)))
+            reductions.push(`${after.key}:${obligation.key}:proof_surface_removed`);
+    }
+    return reductions;
+}
+export function rollbackReductions(before, after) {
+    const previous = before.technical.rollback_and_recovery;
+    const next = after.technical.rollback_and_recovery;
+    if (!previous)
+        return [];
+    if (!next)
+        return [`${after.key}:removed`];
+    if (previous.rollback !== next.rollback ||
+        previous.recovery !== next.recovery)
+        return [`${after.key}:statement_changed`];
+    const nextChecks = new Set(next.verification_check_keys);
+    return previous.verification_check_keys.some((key) => !nextChecks.has(key))
+        ? [`${after.key}:verification_check_removed`]
+        : [];
+}
+export function counterfactualReductions(before, after) {
+    const next = new Map(after.acceptance.counterfactual_controls.map((control) => [
+        control.key,
+        control,
+    ]));
+    return before.acceptance.counterfactual_controls
+        .filter((control) => {
+        const candidate = next.get(control.key);
+        return !candidate || !same(control, candidate);
+    })
+        .map((control) => `${after.key}:${control.key}`);
+}
+export function globalCounterfactualReductions(before, after) {
+    const next = new Map(after.global.acceptance.counterfactual_controls.map((control) => [
+        control.key,
+        control,
+    ]));
+    return (before.global.acceptance.counterfactual_controls ?? [])
+        .filter((control) => {
+        const candidate = next.get(control.key);
+        return !candidate || !same(control, candidate);
+    })
+        .map((control) => `GLOBAL:${control.key}`);
+}
+export function expandedPatterns(label, before, after) {
+    return after
+        .filter((candidate) => !before.some((existing) => proveRepositoryPatternSubset(candidate, existing).status ===
+        "proven_subset"))
+        .map((candidate) => `${label}:${candidate}`);
+}
+export function removedExactValues(label, before, after) {
+    const available = new Set(after);
+    return before
+        .filter((value) => !available.has(value))
+        .map((value) => `${label}:${value}`);
+}
+export function removedStructuredValues(label, before, after) {
+    const available = new Set(after.map(canonicalValueJson));
+    return before
+        .filter((value) => !available.has(canonicalValueJson(value)))
+        .map((value) => `${label}:${canonicalValueJson(value)}`);
+}
+export function removedValues(before, after) {
+    return [...before].filter((value) => !after.has(value)).sort();
+}
+export function addedValues(before, after) {
+    return [...after].filter((value) => !before.has(value)).sort();
+}
+export function same(left, right) {
+    return canonicalValueJson(left) === canonicalValueJson(right);
+}
+function declaredRunner(check) {
+    const runner = check.runner;
+    return {
+        type: runner.type,
+        target: runner.target,
+        argv: runner.argv,
+        cwd: runner.cwd,
+        timeout_ms: runner.timeout_ms,
+        effect: runner.effect,
+        retry_policy: runner.retry_policy,
+        idempotent: runner.idempotent,
+    };
+}

package/dist/lib/long-task-authority-revision-enforcement.d.ts

@@ -0,0 +1,3 @@
+import type { AuthorityHashesV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
+export declare function assertRiskNotDowngraded(previous: CompiledDeliveryContractV2, nextLevel: "standard" | "strict", nextReasons: string[]): void;
+export declare function enforceAuthorityRevision(previous: CompiledDeliveryContractV2, nextContract: DeliveryContractV2, nextHashes: AuthorityHashesV2, nextMaterials: NextAuthorityMaterialsV2, nextGlobalChecks: CompiledDeliveryContractV2["global"]["acceptance"]["checks"], nextOutcomes: CompiledOutcomeV2[], nextVerifier: VerifierIdentityV2, workdir: string, riskFloor: "standard" | "strict"): Promise<void>;

package/dist/lib/long-task-authority-revision-enforcement.js

@@ -0,0 +1,41 @@
+import { changedAuthoritySections } from "./long-task-authority.js";
+import { authorityMaterialHashes, compiledAuthorityMaterials, } from "./long-task-authority-materials.js";
+import { authorityRevisionDiff, } from "./long-task-authority-revision.js";
+import { authorityRevisionApproved, writePendingAuthorityRevision, } from "./long-task-state.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function assertRiskNotDowngraded(previous, nextLevel, nextReasons) {
+    if (previous.effective_risk === "strict" && nextLevel !== "strict")
+        throw new Error("authority_risk_downgrade_rejected:strict_to_standard");
+    const next = new Set(nextReasons);
+    const removed = previous.risk_reasons.filter((reason) => !next.has(reason));
+    if (removed.length)
+        throw new Error(`authority_risk_downgrade_rejected:${removed.join(",")}`);
+}
+export async function enforceAuthorityRevision(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier, workdir, riskFloor) {
+    const previousMaterials = compiledAuthorityMaterials(previous);
+    const diff = authorityRevisionDiff(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier);
+    if (!diff.reduction_reasons.length)
+        return;
+    const unsignedRevision = {
+        previous_hashes: previous.authority_hashes,
+        next_hashes: nextHashes,
+        previous_materials: previousMaterials,
+        next_materials: nextMaterials,
+        previous_material_hashes: authorityMaterialHashes(previousMaterials),
+        next_material_hashes: authorityMaterialHashes(nextMaterials),
+        changed_authority_sections: changedAuthoritySections(previous.authority_hashes, nextHashes),
+        revision_diff: diff,
+        new_risk_floor: riskFloor,
+        affected_outcomes_or_contracts: nextContract.outcomes.map((outcome) => outcome.key),
+    };
+    const revisionIdentity = sha256Hex(canonicalValueJson(unsignedRevision));
+    if (!(await authorityRevisionApproved(workdir, revisionIdentity))) {
+        await writePendingAuthorityRevision(workdir, {
+            schema_version: "long-task-authority-revision-pending-v2",
+            ...unsignedRevision,
+            revision_identity: revisionIdentity,
+            created_at: new Date().toISOString(),
+        });
+        throw new Error(`authority_change_requires_user_decision:${revisionIdentity}`);
+    }
+}

package/dist/lib/long-task-authority-revision-types.d.ts

@@ -0,0 +1,50 @@
+import type { VerifierIdentityV2 } from "./long-task-authority-types.js";
+export interface AuthorityRevisionDiffV2 {
+    product_claims_added: string[];
+    product_claims_removed: string[];
+    product_claims_changed: string[];
+    product_semantics_changed: string[];
+    global_semantics_changed: string[];
+    checks_added: string[];
+    checks_removed: string[];
+    negative_assertions_removed: string[];
+    proof_surfaces_changed: string[];
+    source_claims_added: string[];
+    source_claims_removed_or_changed: string[];
+    source_paths_removed_or_replaced: string[];
+    source_files_added: string[];
+    source_files_removed: string[];
+    source_files_changed: string[];
+    context_snapshot_mode_changed: boolean;
+    context_topology_changed: boolean;
+    context_files_added: string[];
+    context_files_removed: string[];
+    context_files_changed: string[];
+    owner_paths_expanded: string[];
+    owner_context_refs_removed: string[];
+    expected_change_paths_expanded: string[];
+    allowed_paths_expanded: string[];
+    forbidden_paths_removed: string[];
+    runner_definitions_changed: string[];
+    verification_inputs_removed_or_replaced: string[];
+    input_paths_removed_or_narrowed: string[];
+    expected_output_paths_removed_or_weakened: string[];
+    artifacts_removed: string[];
+    environment_requirements_removed: string[];
+    bindings_removed_or_expanded: string[];
+    obligations_removed_or_weakened: string[];
+    rollback_or_recovery_weakened: string[];
+    counterfactuals_removed: string[];
+    population_weakened: string[];
+    verifier_content_changed: boolean;
+    verifier_runtime_locator_changed: boolean;
+    verifier_files_changed: string[];
+    previous_verifier: VerifierIdentityV2;
+    next_verifier: VerifierIdentityV2;
+    source_claims_changed: boolean;
+    risk_changed: boolean;
+    owner_or_path_boundary_changed: boolean;
+    runner_or_verification_inputs_changed: boolean;
+    technical_obligations_changed: boolean;
+    reduction_reasons: string[];
+}

package/dist/lib/long-task-authority-revision-types.js

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

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

@@ -0,0 +1,4 @@
+import type { AuthorityHashesV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
+import type { AuthorityRevisionDiffV2 } from "./long-task-authority-revision-types.js";
+export type { AuthorityRevisionDiffV2 } from "./long-task-authority-revision-types.js";
+export declare function authorityRevisionDiff(previous: CompiledDeliveryContractV2, next: DeliveryContractV2, nextHashes: AuthorityHashesV2, nextMaterials: NextAuthorityMaterialsV2, nextGlobalChecks: CompiledCheckV2[], nextOutcomes: CompiledOutcomeV2[], nextVerifier: VerifierIdentityV2): AuthorityRevisionDiffV2;

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

@@ -0,0 +1,188 @@
+import { acceptanceSemanticsChanged, isMonotonicAcceptanceStrengthening, } from "./long-task-authority.js";
+import { authorityMaterialRevisionDiff, changedProductClaimSemantics, sourceClaimAdditions, } from "./long-task-authority-material-diff.js";
+import { compileProductClaimCoverage } from "./long-task-claims.js";
+import { addedValues, bindingReductions, changedRunnerFields, checkIndex, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, removedValues, rollbackReductions, same, sourceClaimReductions, } from "./long-task-authority-revision-details.js";
+import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
+export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier) {
+    const materialDiff = authorityMaterialRevisionDiff(previous, nextMaterials);
+    const nextClaims = compileProductClaimCoverage(next).by_outcome;
+    const beforeClaimIds = new Set(previous.outcomes.flatMap((outcome) => outcome.generated_claims.map((claim) => claim.id)));
+    const afterClaimIds = new Set(Object.values(nextClaims)
+        .flat()
+        .map((claim) => claim.id));
+    const beforeChecks = checkIndex(previous.global.acceptance.checks, previous.outcomes);
+    const afterChecks = checkIndex(nextGlobalChecks, nextOutcomes);
+    const productClaimsRemoved = removedValues(beforeClaimIds, afterClaimIds);
+    const productClaimsAdded = addedValues(beforeClaimIds, afterClaimIds);
+    const productClaimsChanged = changedProductClaimSemantics(previous, next);
+    const checksRemoved = removedValues(new Set(beforeChecks.keys()), new Set(afterChecks.keys()));
+    const negativeAssertionsRemoved = [];
+    const proofSurfacesChanged = [];
+    const runnerDefinitionsChanged = [];
+    const verificationInputsRemovedOrReplaced = [];
+    const inputPathsRemovedOrNarrowed = [];
+    const expectedOutputPathsRemovedOrWeakened = [];
+    const artifactsRemoved = [];
+    const environmentRequirementsRemoved = [];
+    for (const [identity, before] of beforeChecks) {
+        const after = afterChecks.get(identity);
+        if (!after)
+            continue;
+        for (const assertion of before.negative_assertions)
+            if (!after.negative_assertions.some((item) => same(item, assertion)))
+                negativeAssertionsRemoved.push(`${identity}:${assertion.key}`);
+        if (before.proof_surface !== after.proof_surface)
+            proofSurfacesChanged.push(`${identity}:${before.proof_surface}->${after.proof_surface}`);
+        runnerDefinitionsChanged.push(...changedRunnerFields(identity, before, after));
+        verificationInputsRemovedOrReplaced.push(...removedOrReplacedVerificationInputs(identity, before, after));
+        inputPathsRemovedOrNarrowed.push(...removedOrNarrowedInputPaths(identity, before, after));
+        expectedOutputPathsRemovedOrWeakened.push(...removedOrWeakenedExpectedOutputPaths(identity, before, after));
+        artifactsRemoved.push(...removedExactValues(identity, before.artifact_globs, after.artifact_globs));
+        environmentRequirementsRemoved.push(...removedStructuredValues(identity, before.environment_requirements, after.environment_requirements));
+    }
+    const sourceClaimsRemovedOrChanged = sourceClaimReductions(previous.source_claims, next.source_claims);
+    const sourceClaimsAdded = sourceClaimAdditions(previous.source_claims, next.source_claims);
+    const sourcePathsRemovedOrReplaced = removedExactValues("task", previous.task.source_paths, next.task.source_paths);
+    const ownerPathsExpanded = [];
+    const ownerContextRefsRemoved = [];
+    const expectedChangePathsExpanded = [];
+    const allowedPathsExpanded = [];
+    const forbiddenPathsRemoved = removedGlobalForbiddenPaths(previous, next);
+    const bindingsRemovedOrExpanded = [];
+    const obligationsRemovedOrWeakened = [];
+    const rollbackOrRecoveryWeakened = [];
+    const counterfactualsRemoved = globalCounterfactualReductions(previous, next);
+    const populationWeakened = [];
+    const verifierDiff = verifierAuthorityDiff(previous.verifier_identity, nextVerifier);
+    const previousOutcomes = new Map(previous.outcomes.map((outcome) => [outcome.key, outcome]));
+    for (const after of next.outcomes) {
+        const before = previousOutcomes.get(after.key);
+        if (!before)
+            continue;
+        ownerPathsExpanded.push(...expandedPatterns(after.key, before.product.owner.path_globs, after.product.owner.path_globs));
+        ownerContextRefsRemoved.push(...removedExactValues(after.key, before.product.owner.context_refs, after.product.owner.context_refs));
+        expectedChangePathsExpanded.push(...expandedPatterns(after.key, before.technical.expected_change_paths, after.technical.expected_change_paths));
+        allowedPathsExpanded.push(...expandedPatterns(after.key, before.technical.allowed_support_paths, after.technical.allowed_support_paths));
+        forbiddenPathsRemoved.push(...removedExactValues(after.key, before.technical.forbidden_paths, after.technical.forbidden_paths));
+        bindingsRemovedOrExpanded.push(...bindingReductions(before, after));
+        obligationsRemovedOrWeakened.push(...obligationReductions(before, after));
+        rollbackOrRecoveryWeakened.push(...rollbackReductions(before, after));
+        counterfactualsRemoved.push(...counterfactualReductions(before, after));
+        if (before.acceptance.population &&
+            (!after.acceptance.population ||
+                !same(before.acceptance.population, after.acceptance.population)))
+            populationWeakened.push(after.key);
+    }
+    const riskChanged = previous.authority_hashes.risk_authority_hash !==
+        nextHashes.risk_authority_hash;
+    const acceptanceChanged = acceptanceSemanticsChanged(previous, next);
+    const monotonic = isMonotonicAcceptanceStrengthening(previous, next);
+    const reductionReasons = [
+        ...(productClaimsAdded.length ? ["product_claim_added"] : []),
+        ...(productClaimsRemoved.length ? ["product_claim_removed"] : []),
+        ...(productClaimsChanged.length ? ["product_claim_changed"] : []),
+        ...materialDiff.reduction_reasons,
+        ...(checksRemoved.length ? ["check_removed"] : []),
+        ...(negativeAssertionsRemoved.length ? ["negative_assertion_removed"] : []),
+        ...(proofSurfacesChanged.length ? ["proof_surface_changed"] : []),
+        ...(sourceClaimsRemovedOrChanged.length
+            ? ["source_claim_removed_or_changed"]
+            : []),
+        ...(sourceClaimsAdded.length ? ["source_claim_added"] : []),
+        ...(sourcePathsRemovedOrReplaced.length
+            ? ["source_path_removed_or_replaced"]
+            : []),
+        ...(ownerPathsExpanded.length ? ["owner_path_expanded"] : []),
+        ...(ownerContextRefsRemoved.length ? ["owner_context_ref_removed"] : []),
+        ...(expectedChangePathsExpanded.length
+            ? ["expected_change_path_expanded"]
+            : []),
+        ...(allowedPathsExpanded.length ? ["allowed_path_expanded"] : []),
+        ...(forbiddenPathsRemoved.length ? ["forbidden_path_removed"] : []),
+        ...(runnerDefinitionsChanged.length ? ["runner_definition_changed"] : []),
+        ...(verificationInputsRemovedOrReplaced.length
+            ? ["verification_input_removed_or_replaced"]
+            : []),
+        ...(inputPathsRemovedOrNarrowed.length
+            ? ["input_path_coverage_reduced"]
+            : []),
+        ...(expectedOutputPathsRemovedOrWeakened.length
+            ? ["expected_output_requirement_weakened"]
+            : []),
+        ...(artifactsRemoved.length ? ["artifact_removed"] : []),
+        ...(environmentRequirementsRemoved.length
+            ? ["environment_requirement_removed"]
+            : []),
+        ...(bindingsRemovedOrExpanded.length
+            ? ["binding_removed_or_expanded"]
+            : []),
+        ...(obligationsRemovedOrWeakened.length
+            ? ["obligation_removed_or_weakened"]
+            : []),
+        ...(rollbackOrRecoveryWeakened.length
+            ? ["rollback_or_recovery_weakened"]
+            : []),
+        ...(counterfactualsRemoved.length ? ["counterfactual_removed"] : []),
+        ...(populationWeakened.length ? ["population_weakened"] : []),
+        ...(verifierDiff.verifier_content_changed
+            ? ["verifier_content_changed"]
+            : []),
+        ...(riskChanged ? ["risk_changed_requires_review"] : []),
+        ...(acceptanceChanged && !monotonic ? ["acceptance_not_monotonic"] : []),
+    ];
+    return {
+        product_claims_added: productClaimsAdded,
+        product_claims_removed: productClaimsRemoved,
+        product_claims_changed: productClaimsChanged,
+        product_semantics_changed: materialDiff.product_semantics_changed,
+        global_semantics_changed: materialDiff.global_semantics_changed,
+        checks_added: addedValues(new Set(beforeChecks.keys()), new Set(afterChecks.keys())),
+        checks_removed: checksRemoved,
+        negative_assertions_removed: negativeAssertionsRemoved,
+        proof_surfaces_changed: proofSurfacesChanged,
+        source_claims_added: sourceClaimsAdded,
+        source_claims_removed_or_changed: sourceClaimsRemovedOrChanged,
+        source_paths_removed_or_replaced: sourcePathsRemovedOrReplaced,
+        source_files_added: materialDiff.source_files_added,
+        source_files_removed: materialDiff.source_files_removed,
+        source_files_changed: materialDiff.source_files_changed,
+        context_snapshot_mode_changed: materialDiff.context_snapshot_mode_changed,
+        context_topology_changed: materialDiff.context_topology_changed,
+        context_files_added: materialDiff.context_files_added,
+        context_files_removed: materialDiff.context_files_removed,
+        context_files_changed: materialDiff.context_files_changed,
+        owner_paths_expanded: ownerPathsExpanded,
+        owner_context_refs_removed: ownerContextRefsRemoved,
+        expected_change_paths_expanded: expectedChangePathsExpanded,
+        allowed_paths_expanded: allowedPathsExpanded,
+        forbidden_paths_removed: forbiddenPathsRemoved,
+        runner_definitions_changed: runnerDefinitionsChanged,
+        verification_inputs_removed_or_replaced: verificationInputsRemovedOrReplaced,
+        input_paths_removed_or_narrowed: inputPathsRemovedOrNarrowed,
+        expected_output_paths_removed_or_weakened: expectedOutputPathsRemovedOrWeakened,
+        artifacts_removed: artifactsRemoved,
+        environment_requirements_removed: environmentRequirementsRemoved,
+        bindings_removed_or_expanded: bindingsRemovedOrExpanded,
+        obligations_removed_or_weakened: obligationsRemovedOrWeakened,
+        rollback_or_recovery_weakened: rollbackOrRecoveryWeakened,
+        counterfactuals_removed: counterfactualsRemoved,
+        population_weakened: populationWeakened,
+        ...verifierDiff,
+        source_claims_changed: previous.authority_hashes.source_authority_hash !==
+            nextHashes.source_authority_hash,
+        risk_changed: riskChanged,
+        owner_or_path_boundary_changed: ownerPathsExpanded.length > 0 ||
+            ownerContextRefsRemoved.length > 0 ||
+            expectedChangePathsExpanded.length > 0 ||
+            allowedPathsExpanded.length > 0 ||
+            forbiddenPathsRemoved.length > 0 ||
+            bindingsRemovedOrExpanded.length > 0,
+        runner_or_verification_inputs_changed: runnerDefinitionsChanged.length > 0 ||
+            verificationInputsRemovedOrReplaced.length > 0 ||
+            inputPathsRemovedOrNarrowed.length > 0 ||
+            expectedOutputPathsRemovedOrWeakened.length > 0,
+        technical_obligations_changed: obligationsRemovedOrWeakened.length > 0 ||
+            rollbackOrRecoveryWeakened.length > 0,
+        reduction_reasons: [...new Set(reductionReasons)],
+    };
+}

package/dist/lib/long-task-authority-transition-policy.d.ts

@@ -0,0 +1,62 @@
+export declare const ACTIVE_AUTHORITY_TRANSITION_POLICY: {
+    readonly compile_first: {
+        readonly reads_authority: "none";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_null";
+    };
+    readonly compile_revise: {
+        readonly reads_authority: "active_snapshot";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_identity";
+    };
+    readonly verify: {
+        readonly reads_authority: "active_snapshot";
+        readonly modifies_authority: false;
+        readonly requires_lock: false;
+        readonly cas: "recheck_before_progress_write";
+    };
+    readonly final_gate: {
+        readonly reads_authority: "active_snapshot";
+        readonly modifies_authority: false;
+        readonly requires_lock: false;
+        readonly cas: "recheck_before_acceptance";
+    };
+    readonly stop_accepted_clear: {
+        readonly reads_authority: "accepted_identity";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_identity";
+    };
+    readonly close_accepted_clear: {
+        readonly reads_authority: "accepted_identity";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_identity";
+    };
+    readonly abandon_valid: {
+        readonly reads_authority: "active_snapshot";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_identity";
+    };
+    readonly abandon_corrupt: {
+        readonly reads_authority: "deterministic_local_paths";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "explicit_force";
+    };
+    readonly legacy_migration: {
+        readonly reads_authority: "legacy_plus_matching_cache";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_legacy_identity";
+    };
+    readonly verifier_migration: {
+        readonly reads_authority: "active_snapshot";
+        readonly modifies_authority: true;
+        readonly requires_lock: true;
+        readonly cas: "expected_identity";
+    };
+};

package/dist/lib/long-task-authority-transition-policy.js

@@ -0,0 +1,62 @@
+export const ACTIVE_AUTHORITY_TRANSITION_POLICY = {
+    compile_first: {
+        reads_authority: "none",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_null",
+    },
+    compile_revise: {
+        reads_authority: "active_snapshot",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_identity",
+    },
+    verify: {
+        reads_authority: "active_snapshot",
+        modifies_authority: false,
+        requires_lock: false,
+        cas: "recheck_before_progress_write",
+    },
+    final_gate: {
+        reads_authority: "active_snapshot",
+        modifies_authority: false,
+        requires_lock: false,
+        cas: "recheck_before_acceptance",
+    },
+    stop_accepted_clear: {
+        reads_authority: "accepted_identity",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_identity",
+    },
+    close_accepted_clear: {
+        reads_authority: "accepted_identity",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_identity",
+    },
+    abandon_valid: {
+        reads_authority: "active_snapshot",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_identity",
+    },
+    abandon_corrupt: {
+        reads_authority: "deterministic_local_paths",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "explicit_force",
+    },
+    legacy_migration: {
+        reads_authority: "legacy_plus_matching_cache",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_legacy_identity",
+    },
+    verifier_migration: {
+        reads_authority: "active_snapshot",
+        modifies_authority: true,
+        requires_lock: true,
+        cas: "expected_identity",
+    },
+};