project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,307 +0,0 @@
-const TASK_AUTHORITY_POLICY = {
-    id: "identity",
-    title: "descriptive_non_authoritative",
-    goal: "semantic_user_review",
-    source_paths: "scope",
-    context_refs: "scope",
-    context_snapshot_mode: "scope",
-    target_profile: "semantic_user_review",
-    execution_targets: "semantic_user_review",
-};
-const SOURCE_CLAIM_AUTHORITY_POLICY = {
-    key: "identity",
-    source_ref: "scope",
-    statement: "semantic_user_review",
-    disposition: "semantic_user_review",
-};
-const RISK_AUTHORITY_POLICY = {
-    requested_level: "semantic_user_review",
-    facts: "semantic_user_review",
-};
-const GLOBAL_AUTHORITY_POLICY = {
-    applicability: "semantic_user_review",
-    product: "semantic_user_review",
-    technical: "semantic_user_review",
-    acceptance: "proof_additive",
-};
-const GLOBAL_PRODUCT_AUTHORITY_POLICY = {
-    non_goals: "semantic_user_review",
-};
-const GLOBAL_TECHNICAL_AUTHORITY_POLICY = {
-    constraints: "semantic_user_review",
-    forbidden_paths: "scope",
-    forbidden_shortcuts: "semantic_user_review",
-};
-const GLOBAL_ACCEPTANCE_AUTHORITY_POLICY = {
-    checks: "proof_additive",
-    counterfactual_controls: "proof_additive",
-    external_confirmations: "semantic_user_review",
-};
-const OUTCOME_AUTHORITY_POLICY = {
-    key: "identity",
-    title: "descriptive_non_authoritative",
-    stage: "semantic_user_review",
-    depends_on: "readiness_only",
-    applicability: "semantic_user_review",
-    semantic_fact_bindings: "semantic_user_review",
-    product: "semantic_user_review",
-    technical: "semantic_user_review",
-    acceptance: "proof_additive",
-};
-const CLAIM_APPLICABILITY_AUTHORITY_POLICY = {
-    key: "identity",
-    target_ref: "semantic_user_review",
-    journey_role: "semantic_user_review",
-    dimensions: "semantic_user_review",
-    given_refs: "semantic_user_review",
-    when_refs: "semantic_user_review",
-};
-const APPLICABLE_STATEMENT_AUTHORITY_POLICY = {
-    key: "identity",
-    statement: "semantic_user_review",
-    applicability_refs: "semantic_user_review",
-};
-const OUTCOME_PRODUCT_AUTHORITY_POLICY = {
-    observable_result: "semantic_user_review",
-    result_applicability_refs: "semantic_user_review",
-    success_path_required: "semantic_user_review",
-    degradation_path_required: "semantic_user_review",
-    owner: "semantic_user_review",
-    requirements: "semantic_user_review",
-    owner_surfaces: "semantic_user_review",
-    controls: "semantic_user_review",
-    control_relation_closure: "semantic_user_review",
-    control_relations: "semantic_user_review",
-    surface_bindings: "semantic_user_review",
-    non_completing_outcomes: "semantic_user_review",
-};
-const REQUIREMENT_AUTHORITY_POLICY = {
-    key: "identity",
-    statement: "semantic_user_review",
-    required_proof_surfaces: "proof_additive",
-    applicability_refs: "semantic_user_review",
-};
-const OWNER_AUTHORITY_POLICY = {
-    label: "identity",
-    context_refs: "scope",
-    path_globs: "scope",
-};
-const CONTROL_AUTHORITY_POLICY = {
-    key: "identity",
-    surface: "semantic_user_review",
-    region: "semantic_user_review",
-    location: "semantic_user_review",
-    control_type: "semantic_user_review",
-    label_content: "semantic_user_review",
-    user_task: "semantic_user_review",
-    visibility: "semantic_user_review",
-    availability: "semantic_user_review",
-    trigger: "semantic_user_review",
-    input: "semantic_user_review",
-    validation: "semantic_user_review",
-    default_value: "semantic_user_review",
-    interaction: "semantic_user_review",
-    navigation_result: "semantic_user_review",
-    loading_state: "semantic_user_review",
-    empty_state: "semantic_user_review",
-    success_state: "semantic_user_review",
-    failure_state: "semantic_user_review",
-    recovery: "semantic_user_review",
-    permission: "semantic_user_review",
-    feedback: "semantic_user_review",
-    accessibility: "semantic_user_review",
-    field_coverage: "semantic_user_review",
-};
-const CONTROL_FIELD_COVERAGE_AUTHORITY_POLICY = {
-    fields: "semantic_user_review",
-    state: "semantic_user_review",
-    statement: "semantic_user_review",
-    applicability_refs: "semantic_user_review",
-};
-const CONTROL_RELATION_CLOSURE_AUTHORITY_POLICY = {
-    state: "semantic_user_review",
-    statement: "semantic_user_review",
-    applicability_refs: "semantic_user_review",
-};
-const CONTROL_RELATION_AUTHORITY_POLICY = {
-    key: "identity",
-    statement: "semantic_user_review",
-    applicability_refs: "semantic_user_review",
-    control_refs: "semantic_user_review",
-    required_proof_surfaces: "proof_additive",
-};
-const SURFACE_BINDING_AUTHORITY_POLICY = {
-    key: "identity",
-    surface_ref: "semantic_user_review",
-    target_ref: "semantic_user_review",
-    control_refs: "semantic_user_review",
-    route_binding_ref: "semantic_user_review",
-    component_binding_refs: "semantic_user_review",
-    root_journey_check_ref: "proof_additive",
-    entry_action_ref: "proof_additive",
-    design_targets: "semantic_user_review",
-    acceptance_blockers: "semantic_user_review",
-};
-const DESIGN_TARGET_AUTHORITY_POLICY = {
-    key: "identity",
-    fact_model: "semantic_user_review",
-    interpretation: "semantic_user_review",
-    source_paths: "scope",
-    condition_keys: "semantic_user_review",
-    claim_refs: "proof_additive",
-    conformance_check_ref: "proof_additive",
-    conformance_assertion_ref: "proof_additive",
-    verification_method_bindings: "proof_additive",
-    symbolic_method_bindings: "proof_additive",
-    symbolic_certificate_binding: "proof_additive",
-    actual_artifact_path: "output_requirement",
-    comparison_artifact_path: "output_requirement",
-};
-const DESIGN_VERIFICATION_BINDING_AUTHORITY_POLICY = {
-    method: "proof_additive",
-    assertion_ref: "proof_additive",
-    evidence_artifacts: "output_requirement",
-};
-const DESIGN_BLOCKER_AUTHORITY_POLICY = {
-    key: "identity",
-    status: "semantic_user_review",
-    refs: "semantic_user_review",
-    source_item_refs: "semantic_user_review",
-    verification_methods: "proof_additive",
-    required_capabilities: "semantic_user_review",
-    rationale: "semantic_user_review",
-};
-const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
-    obligations: "semantic_user_review",
-    expected_change_paths: "scope",
-    allowed_support_paths: "scope",
-    forbidden_paths: "scope",
-    bindings: "semantic_user_review",
-    forbidden_shortcuts: "semantic_user_review",
-    rollback_and_recovery: "semantic_user_review",
-};
-const OBLIGATION_AUTHORITY_POLICY = {
-    key: "identity",
-    statement: "semantic_user_review",
-    required_proof_surfaces: "proof_additive",
-    applicability_refs: "semantic_user_review",
-};
-const BINDING_AUTHORITY_POLICY = {
-    key: "identity",
-    kind: "semantic_user_review",
-    target: "semantic_user_review",
-    carrier_paths: "scope",
-    existence: "semantic_user_review",
-    verification_check_key: "proof_additive",
-};
-const ROLLBACK_AUTHORITY_POLICY = {
-    rollback: "semantic_user_review",
-    recovery: "semantic_user_review",
-    verification_check_keys: "proof_additive",
-};
-const OUTCOME_ACCEPTANCE_AUTHORITY_POLICY = {
-    checks: "proof_additive",
-    population: "proof_additive",
-    counterfactual_controls: "proof_additive",
-};
-export const CHECK_AUTHORITY_POLICY = {
-    key: "identity",
-    journey_roles: "proof_additive",
-    execution_target: "semantic_user_review",
-    scenario: "proof_additive",
-    proof_surface: "semantic_user_review",
-    runner: "runner_authority",
-    verification_inputs: "proof_additive",
-    input_paths: "input_coverage",
-    expected_output_paths: "output_requirement",
-    artifact_globs: "proof_additive",
-    positive_assertions: "proof_additive",
-    negative_assertions: "proof_additive",
-    environment_requirements: "proof_additive",
-};
-const ASSERTION_AUTHORITY_POLICY = {
-    key: "identity",
-    criterion: "semantic_user_review",
-    claims: "proof_additive",
-    applicability_ref: "proof_additive",
-    observation: "proof_additive",
-    evidence_capabilities: "proof_additive",
-    operator: "proof_additive",
-    expected: "proof_additive",
-};
-const RUNNER_AUTHORITY_POLICY = {
-    type: "runner_authority",
-    target: "runner_authority",
-    argv: "runner_authority",
-    cwd: "runner_authority",
-    timeout_ms: "runner_authority",
-    effect: "runner_authority",
-    retry_policy: "runner_authority",
-    idempotent: "runner_authority",
-};
-const POPULATION_AUTHORITY_POLICY = {
-    check_key: "proof_additive",
-    universe_binding_key: "proof_additive",
-    claims: "proof_additive",
-    observations: "proof_additive",
-    exclusion_rules: "proof_additive",
-};
-const COUNTERFACTUAL_AUTHORITY_POLICY = {
-    key: "identity",
-    binding_key: "proof_additive",
-    claims: "proof_additive",
-    check_key: "proof_additive",
-    mutation: "proof_additive",
-    expected_assertion_failures: "proof_additive",
-    preserved_assertions: "proof_additive",
-    allowed_fanout_assertions: "semantic_user_review",
-};
-const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
-    key: "identity",
-    binding_ref: "proof_additive",
-    claims: "proof_additive",
-    check_key: "proof_additive",
-    mutation: "proof_additive",
-    expected_assertion_failures: "proof_additive",
-    preserved_assertions: "proof_additive",
-    allowed_fanout_assertions: "semantic_user_review",
-};
-export const AUTHORITY_FIELD_POLICY_REGISTRIES = {
-    task: TASK_AUTHORITY_POLICY,
-    source_claim: SOURCE_CLAIM_AUTHORITY_POLICY,
-    risk: RISK_AUTHORITY_POLICY,
-    global: GLOBAL_AUTHORITY_POLICY,
-    global_product: GLOBAL_PRODUCT_AUTHORITY_POLICY,
-    global_technical: GLOBAL_TECHNICAL_AUTHORITY_POLICY,
-    global_acceptance: GLOBAL_ACCEPTANCE_AUTHORITY_POLICY,
-    outcome: OUTCOME_AUTHORITY_POLICY,
-    claim_applicability: CLAIM_APPLICABILITY_AUTHORITY_POLICY,
-    applicable_statement: APPLICABLE_STATEMENT_AUTHORITY_POLICY,
-    outcome_product: OUTCOME_PRODUCT_AUTHORITY_POLICY,
-    requirement: REQUIREMENT_AUTHORITY_POLICY,
-    owner: OWNER_AUTHORITY_POLICY,
-    control: CONTROL_AUTHORITY_POLICY,
-    control_field_coverage: CONTROL_FIELD_COVERAGE_AUTHORITY_POLICY,
-    control_relation_closure: CONTROL_RELATION_CLOSURE_AUTHORITY_POLICY,
-    control_relation: CONTROL_RELATION_AUTHORITY_POLICY,
-    surface_binding: SURFACE_BINDING_AUTHORITY_POLICY,
-    design_target: DESIGN_TARGET_AUTHORITY_POLICY,
-    design_verification_binding: DESIGN_VERIFICATION_BINDING_AUTHORITY_POLICY,
-    design_blocker: DESIGN_BLOCKER_AUTHORITY_POLICY,
-    outcome_technical: OUTCOME_TECHNICAL_AUTHORITY_POLICY,
-    obligation: OBLIGATION_AUTHORITY_POLICY,
-    binding: BINDING_AUTHORITY_POLICY,
-    rollback: ROLLBACK_AUTHORITY_POLICY,
-    outcome_acceptance: OUTCOME_ACCEPTANCE_AUTHORITY_POLICY,
-    check: CHECK_AUTHORITY_POLICY,
-    assertion: ASSERTION_AUTHORITY_POLICY,
-    runner: RUNNER_AUTHORITY_POLICY,
-    population: POPULATION_AUTHORITY_POLICY,
-    counterfactual: COUNTERFACTUAL_AUTHORITY_POLICY,
-    global_counterfactual: GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY,
-};
-export function projectFieldsByPolicy(value, policy, included) {
-    return Object.fromEntries(Object.keys(policy)
-        .filter((key) => included.has(policy[key]))
-        .map((key) => [key, value[key]]));
-}

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

@@ -1,34 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export interface CheckRevisionAnalysis {
-    negative_assertions_removed: string[];
-    acceptance_semantics_reduced: string[];
-    proof_surfaces_changed: string[];
-    runner_definitions_changed: string[];
-    verification_inputs_added: string[];
-    verification_inputs_removed_or_replaced: string[];
-    input_paths_added: string[];
-    input_paths_removed_or_narrowed: string[];
-    expected_output_paths_removed_or_weakened: string[];
-    artifacts_removed: string[];
-    environment_requirements_removed: string[];
-}
-export declare function analyzeCheckRevisions(beforeChecks: Map<string, CompiledCheckV2>, afterChecks: Map<string, CompiledCheckV2>): CheckRevisionAnalysis;
-export interface OutcomeRevisionAnalysis {
-    owner_paths_expanded: string[];
-    owner_context_refs_removed: string[];
-    expected_change_paths_expanded: string[];
-    allowed_paths_expanded: string[];
-    forbidden_paths_removed: string[];
-    bindings_removed_or_expanded: string[];
-    obligations_removed_or_weakened: string[];
-    rollback_or_recovery_weakened: string[];
-    counterfactuals_removed: string[];
-    population_weakened: string[];
-}
-export declare function analyzeOutcomeRevisions(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): OutcomeRevisionAnalysis;
-export declare function keyedAuthorityChanges(before: Array<{
-    key: string;
-}>, after: Array<{
-    key: string;
-}>): string[];
-export declare function selectedRevisionReasons(entries: Array<[reason: string, changed: boolean | unknown[]]>): string[];

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

@@ -1,121 +0,0 @@
-import { addedInputPaths, addedVerificationInputs, bindingReductions, changedRunnerFields, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, rollbackReductions, same, } from "./long-task-authority-revision-details.js";
-export function analyzeCheckRevisions(beforeChecks, afterChecks) {
-    const result = {
-        negative_assertions_removed: [],
-        acceptance_semantics_reduced: [],
-        proof_surfaces_changed: [],
-        runner_definitions_changed: [],
-        verification_inputs_added: [],
-        verification_inputs_removed_or_replaced: [],
-        input_paths_added: [],
-        input_paths_removed_or_narrowed: [],
-        expected_output_paths_removed_or_weakened: [],
-        artifacts_removed: [],
-        environment_requirements_removed: [],
-    };
-    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)))
-                result.negative_assertions_removed.push(`${identity}:${assertion.key}`);
-        if (!same(before.execution_target, after.execution_target))
-            result.acceptance_semantics_reduced.push(`${identity}:execution_target`);
-        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:journey_role`, before.journey_roles, after.journey_roles);
-        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:scenario.given`, before.scenario.given, after.scenario.given);
-        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:scenario.when`, before.scenario.when, after.scenario.when);
-        collectAssertionReductions(result.acceptance_semantics_reduced, identity, before.positive_assertions, after.positive_assertions);
-        if (before.proof_surface !== after.proof_surface)
-            result.proof_surfaces_changed.push(`${identity}:${before.proof_surface}->${after.proof_surface}`);
-        result.runner_definitions_changed.push(...changedRunnerFields(identity, before, after));
-        result.verification_inputs_added.push(...addedVerificationInputs(identity, before, after));
-        result.verification_inputs_removed_or_replaced.push(...removedOrReplacedVerificationInputs(identity, before, after));
-        result.input_paths_added.push(...addedInputPaths(identity, before, after));
-        result.input_paths_removed_or_narrowed.push(...removedOrNarrowedInputPaths(identity, before, after));
-        result.expected_output_paths_removed_or_weakened.push(...removedOrWeakenedExpectedOutputPaths(identity, before, after));
-        result.artifacts_removed.push(...removedExactValues(identity, before.artifact_globs, after.artifact_globs));
-        result.environment_requirements_removed.push(...removedStructuredValues(identity, before.environment_requirements, after.environment_requirements));
-    }
-    return result;
-}
-function collectRemovedValues(result, prefix, before, after) {
-    for (const value of before)
-        if (!after.some((candidate) => same(candidate, value)))
-            result.push(`${prefix}:${String(value)}`);
-}
-function collectAssertionReductions(result, identity, before, after) {
-    const next = new Map(after.map((assertion) => [assertion.key, assertion]));
-    for (const assertion of before) {
-        const candidate = next.get(assertion.key);
-        if (!candidate) {
-            result.push(`${identity}:positive_assertion.${assertion.key}:removed`);
-            continue;
-        }
-        const semanticChanged = assertion.criterion !== candidate.criterion ||
-            !same(assertion.claims, candidate.claims) ||
-            assertion.observation !== candidate.observation ||
-            assertion.operator !== candidate.operator ||
-            !same(assertion.expected, candidate.expected);
-        const capabilityRemoved = assertion.evidence_capabilities.some((capability) => !candidate.evidence_capabilities.includes(capability));
-        if (semanticChanged || capabilityRemoved)
-            result.push(`${identity}:positive_assertion.${assertion.key}:changed`);
-    }
-}
-export function analyzeOutcomeRevisions(previous, next) {
-    const result = {
-        owner_paths_expanded: [],
-        owner_context_refs_removed: [],
-        expected_change_paths_expanded: [],
-        allowed_paths_expanded: [],
-        forbidden_paths_removed: removedGlobalForbiddenPaths(previous, next),
-        bindings_removed_or_expanded: [],
-        obligations_removed_or_weakened: [],
-        rollback_or_recovery_weakened: [],
-        counterfactuals_removed: globalCounterfactualReductions(previous, next),
-        population_weakened: [],
-    };
-    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;
-        result.owner_paths_expanded.push(...expandedPatterns(after.key, before.product.owner.path_globs, after.product.owner.path_globs));
-        result.owner_context_refs_removed.push(...removedExactValues(after.key, before.product.owner.context_refs, after.product.owner.context_refs));
-        result.expected_change_paths_expanded.push(...expandedPatterns(after.key, before.technical.expected_change_paths, after.technical.expected_change_paths));
-        result.allowed_paths_expanded.push(...expandedPatterns(after.key, before.technical.allowed_support_paths, after.technical.allowed_support_paths));
-        result.forbidden_paths_removed.push(...removedExactValues(after.key, before.technical.forbidden_paths, after.technical.forbidden_paths));
-        result.bindings_removed_or_expanded.push(...bindingReductions(before, after));
-        result.obligations_removed_or_weakened.push(...obligationReductions(before, after));
-        result.rollback_or_recovery_weakened.push(...rollbackReductions(before, after));
-        result.counterfactuals_removed.push(...counterfactualReductions(before, after));
-        if (before.acceptance.population &&
-            (!after.acceptance.population ||
-                !same(before.acceptance.population, after.acceptance.population)))
-            result.population_weakened.push(after.key);
-    }
-    return result;
-}
-export function keyedAuthorityChanges(before, after) {
-    const beforeByKey = new Map(before.map((item) => [item.key, item]));
-    const afterByKey = new Map(after.map((item) => [item.key, item]));
-    return [
-        ...before
-            .filter((item) => !afterByKey.has(item.key))
-            .map((item) => `${item.key}:removed`),
-        ...after
-            .filter((item) => !beforeByKey.has(item.key))
-            .map((item) => `${item.key}:added`),
-        ...before
-            .filter((item) => {
-            const candidate = afterByKey.get(item.key);
-            return candidate !== undefined && !same(item, candidate);
-        })
-            .map((item) => `${item.key}:changed`),
-    ].sort();
-}
-export function selectedRevisionReasons(entries) {
-    return entries
-        .filter(([, changed]) => Array.isArray(changed) ? changed.length > 0 : changed)
-        .map(([reason]) => reason);
-}

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

@@ -1,3 +0,0 @@
-import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionBriefV2, AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-export declare function authorityRevisionDecisionNextAction(decision: AuthorityRevisionDecisionV2): string;
-export declare function buildAuthorityRevisionDecisionBrief(summary: AuthorityRevisionApprovalSummaryV2, changeClass: AuthorityRevisionChangeClassV2, approvalRequired: boolean): AuthorityRevisionDecisionBriefV2;

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

@@ -1,76 +0,0 @@
-export function authorityRevisionDecisionNextAction(decision) {
-    const brief = decision.decision_brief;
-    const outcomes = brief.affected_outcomes.length
-        ? brief.affected_outcomes.join(", ")
-        : "contract-wide or global authority";
-    if (!decision.user_decision_required)
-        return `Authority Revision brief: ${brief.overview} ${brief.headline} ${brief.approval_reason} Material changes: ${brief.material_changes.join(" ")} Affected Outcomes: ${outcomes}. ${brief.if_approved.join(" ")}`;
-    return `Authority Revision brief: ${brief.overview} ${brief.headline} ${brief.approval_reason} Material changes: ${brief.material_changes.join(" ")} Affected Outcomes: ${outcomes}. ${brief.if_approved.join(" ")} Present this brief first. If an explicit task-specific user instruction already covers every listed decision reason, mechanically relay that existing decision for exact Authority Revision ${decision.revision_identity} without asking again. A generic continue, blanket approval, recommendation or Agent inference does not count. Otherwise ask the user once to approve or reject this exact identity; keep the previous Authority active until approved and atomically adopted.`;
-}
-export function buildAuthorityRevisionDecisionBrief(summary, changeClass, approvalRequired) {
-    const categories = [];
-    const materialChanges = [];
-    addCategory(summary.product_semantics_changed, "product meaning", detail("Product Claims or semantics changed", summary.product_claim_changes));
-    addCategory(summary.global_or_technical_semantics_changed, "technical meaning", detail("Global or technical semantics changed", summary.semantic_fields_changed));
-    addCategory(summary.source_or_claims_changed, "Source/Claims", detail("Source or Claim authority changed", summary.source_claim_changes));
-    addCategory(summary.context_authority_changed, "Context authority", "Controlling Context authority changed.");
-    addCategory(summary.acceptance_or_proof_weakened, "acceptance/proof", detail("Acceptance or proof was reduced", summary.proof_reductions));
-    addCategory(summary.verifier_or_runner_changed, "verifier/runner", summary.verifier_content_changed
-        ? detail("Verifier content changed; prior evidence is invalid and semantic preservation is not independently established", summary.verifier_files_changed)
-        : "Verifier or runner authority changed.");
-    addCategory(summary.write_scope_expanded, "write scope", detail("Owner or allowed write scope expanded", uniqueSorted([
-        ...summary.expanded_owner_paths,
-        ...summary.expanded_expected_change_paths,
-        ...summary.expanded_allowed_support_paths,
-    ])));
-    addCategory(summary.risk_changed, "risk", "The effective risk authority changed.");
-    addCategory(summary.external_confirmations_changed, "external confirmations", detail("External-confirmation authority changed", summary.external_confirmation_changes));
-    if (summary.added_verification_dependencies.length)
-        materialChanges.push(detail("Verification dependencies were added", summary.added_verification_dependencies));
-    if (!materialChanges.length)
-        materialChanges.push(detail("Protected authority fields changed", summary.protected_reasons));
-    return {
-        overview: "An Authority Revision is a proposed replacement of the locked delivery contract or its protected inputs. It changes what future execution and proof are bound to, but adoption never completes delivery.",
-        headline: approvalRequired
-            ? `User decision required: ${categories.length ? categories.join(", ") : changeClass} changed.`
-            : "No user decision is required for this mechanically bounded Authority Revision.",
-        approval_reason: approvalRequired
-            ? changeClass === "scope_only_expansion"
-                ? "The candidate expands declared implementation ownership or write scope and cannot replace the active Authority without exact user approval."
-                : "The candidate changes protected delivery meaning, proof, risk, or execution authority and cannot replace the active Authority without exact user approval."
-            : changeClass === "scope_only_expansion"
-                ? "The candidate only expands repository-bound implementation scope; it changes no locked product Claim, target, acceptance capability, forbidden boundary or external confirmation."
-                : changeClass === "mechanically_bounded_repair"
-                    ? "The locked user-facing meaning and proof obligations are preserved; changed execution, Source/Context snapshot or equivalent failure interception must still be re-proven on the new snapshot."
-                    : "The change is a machine-proven monotonic strengthening.",
-        material_changes: materialChanges,
-        affected_outcomes: [...summary.affected_outcomes],
-        if_approved: approvalRequired
-            ? [
-                "The previous Authority remains active until exact approval and atomic adoption.",
-                "Approval and adoption do not complete delivery; execution returns to rolling implementation or repair.",
-                "A complete source-recompiled current-snapshot Final Gate remains mandatory.",
-            ]
-            : [
-                "The mechanically safe revision may be atomically adopted without user approval.",
-                "Adoption does not complete delivery; execution returns to rolling implementation or repair.",
-                "A complete source-recompiled current-snapshot Final Gate remains mandatory.",
-            ],
-    };
-    function addCategory(applies, category, materialChange) {
-        if (!applies)
-            return;
-        categories.push(category);
-        materialChanges.push(materialChange);
-    }
-}
-function detail(label, values) {
-    if (!values.length)
-        return `${label}.`;
-    const shown = values.slice(0, 3);
-    const remaining = values.length - shown.length;
-    return `${label}: ${shown.join(", ")}${remaining ? ` (+${remaining} more)` : ""}.`;
-}
-function uniqueSorted(values) {
-    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}

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

@@ -1,21 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, DeliveryOutcomeV2, SourceClaimV2 } from "./long-task-delivery-types.js";
-export declare function checkIndex(globalChecks: CompiledCheckV2[], outcomes: CompiledOutcomeV2[]): Map<string, CompiledCheckV2>;
-export declare function changedRunnerFields(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function removedOrReplacedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function addedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function addedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function removedOrNarrowedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function removedOrWeakenedExpectedOutputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function sourceClaimReductions(beforeClaims: SourceClaimV2[], afterClaims: SourceClaimV2[]): string[];
-export declare function removedGlobalForbiddenPaths(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): string[];
-export declare function bindingReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function obligationReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function rollbackReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function counterfactualReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function globalCounterfactualReductions(before: CompiledDeliveryContractV2, after: DeliveryContractV2): string[];
-export declare function expandedPatterns(label: string, before: string[], after: string[]): string[];
-export declare function removedExactValues(label: string, before: string[], after: string[]): string[];
-export declare function removedStructuredValues(label: string, before: unknown[], after: unknown[]): string[];
-export declare function removedValues(before: Set<string>, after: Set<string>): string[];
-export declare function addedValues(before: Set<string>, after: Set<string>): string[];
-export declare function same(left: unknown, right: unknown): boolean;