project-tiny-context-harness 0.7.8 → 0.8.0

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

@@ -0,0 +1,74 @@
+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", "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.js

@@ -137,29 +137,29 @@ export function rollbackReductions(before, after) {
         : [];
 }
 export function counterfactualReductions(before, after) {
-    const next = new Map(after.acceptance.counterfactual_controls.map((control) => [
-        control.key,
-        control,
-    ]));
+    const next = after.acceptance.counterfactual_controls;
     return before.acceptance.counterfactual_controls
-        .filter((control) => {
-        const candidate = next.get(control.key);
-        return !candidate || !same(control, candidate);
-    })
+        .filter((control) => !counterfactualCoveragePreserved(control, next))
         .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,
-    ]));
+    const next = after.global.acceptance.counterfactual_controls;
     return (before.global.acceptance.counterfactual_controls ?? [])
-        .filter((control) => {
-        const candidate = next.get(control.key);
-        return !candidate || !same(control, candidate);
-    })
+        .filter((control) => !counterfactualCoveragePreserved(control, next))
         .map((control) => `GLOBAL:${control.key}`);
 }
+function counterfactualCoveragePreserved(previous, next) {
+    return next.some((candidate) => same(candidate.binding_key, previous.binding_key) &&
+        same(candidate.binding_ref, previous.binding_ref) &&
+        candidate.check_key === previous.check_key &&
+        same(candidate.mutation, previous.mutation) &&
+        includesEvery(candidate.claims, previous.claims) &&
+        includesEvery(candidate.expected_assertion_failures, previous.expected_assertion_failures));
+}
+function includesEvery(values, required) {
+    const available = new Set(values);
+    return required.every((value) => available.has(value));
+}
 export function expandedPatterns(label, before, after) {
     return after
         .filter((candidate) => !before.some((existing) => proveRepositoryPatternSubset(candidate, existing).status ===

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

@@ -2,7 +2,7 @@ import type { CheckExecutionResultV2, LongTaskFindingV2 } from "./long-task-deli
 import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
 export interface AuthorityRevisionDiagnosisV2 {
     schema_version: "long-task-authority-revision-diagnosis-v2";
-    status: "no_authority_change" | "monotonic_revision_available" | "scope_candidate_exercised" | "scope_candidate_previewed" | "protected_change_previewed" | "candidate_stale";
+    status: "no_authority_change" | "monotonic_revision_available" | "automatic_revision_available" | "scope_candidate_exercised" | "scope_candidate_previewed" | "protected_change_previewed" | "candidate_stale";
     active_compiled_identity: string;
     candidate_compiled_identity: string;
     revision: AuthorityRevisionDecisionV2 | null;

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

@@ -48,6 +48,14 @@ export async function diagnoseAuthorityRevision(workdirInput, selection = {}) {
             revision: decision,
             selection,
         });
+    if (proposal.change_class === "mechanically_bounded_repair")
+        return result({
+            status: "automatic_revision_available",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+        });
     if (proposal.change_class !== "scope_only_expansion")
         return result({
             status: "protected_change_previewed",

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

@@ -1,7 +1,7 @@
 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 { classifyAuthorityRevision, summarizeAuthorityRevision, } from "./long-task-authority-revision-summary.js";
+import { authorityRevisionUserDecisionReasons, classifyAuthorityRevision, summarizeAuthorityRevision, } from "./long-task-authority-revision-summary.js";
 import { authorityRevisionApproved, writePendingAuthorityRevision, } from "./long-task-state.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export function assertRiskNotDowngraded(previous, nextLevel, nextReasons) {
@@ -16,6 +16,8 @@ export function buildAuthorityRevisionProposal(previous, nextContract, nextHashe
     const previousMaterials = compiledAuthorityMaterials(previous);
     const diff = authorityRevisionDiff(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier);
     const changeClass = classifyAuthorityRevision(diff);
+    const userDecisionReasons = authorityRevisionUserDecisionReasons(diff);
+    const userDecisionRequired = userDecisionReasons.length > 0;
     const approvalSummary = summarizeAuthorityRevision(diff, nextContract.outcomes.map((outcome) => outcome.key));
     const unsignedRevision = {
         previous_hashes: previous.authority_hashes,
@@ -29,14 +31,16 @@ export function buildAuthorityRevisionProposal(previous, nextContract, nextHashe
         new_risk_floor: riskFloor,
         affected_outcomes_or_contracts: approvalSummary.affected_outcomes,
         change_class: changeClass,
-        approval_required: diff.reduction_reasons.length > 0,
+        user_decision_required: userDecisionRequired,
+        user_decision_reasons: userDecisionReasons,
+        approval_required: userDecisionRequired,
         approval_summary: approvalSummary,
     };
     const revisionIdentity = sha256Hex(canonicalValueJson(unsignedRevision));
     return { ...unsignedRevision, revision_identity: revisionIdentity };
 }
 export async function enforceAuthorityRevision(proposal, workdir) {
-    if (!proposal.approval_required)
+    if (!proposal.user_decision_required)
         return;
     if (!(await authorityRevisionApproved(workdir, proposal.revision_identity))) {
         await writePendingAuthorityRevision(workdir, {

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

@@ -1,11 +1,14 @@
 import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionV2, AuthorityRevisionDiffV2 } from "./long-task-authority-revision-types.js";
 export declare function classifyAuthorityRevision(diff: AuthorityRevisionDiffV2): AuthorityRevisionChangeClassV2;
+export declare function authorityRevisionUserDecisionReasons(diff: AuthorityRevisionDiffV2): string[];
 export declare function summarizeAuthorityRevision(diff: AuthorityRevisionDiffV2, outcomeKeys: string[]): AuthorityRevisionApprovalSummaryV2;
 export declare function projectAuthorityRevisionDecision(value: {
     revision_identity: string;
     revision_diff: AuthorityRevisionDiffV2;
     affected_outcomes_or_contracts: string[];
     change_class?: AuthorityRevisionChangeClassV2;
+    user_decision_required?: boolean;
+    user_decision_reasons?: string[];
     approval_required?: boolean;
     approval_summary?: AuthorityRevisionApprovalSummaryV2;
 }): AuthorityRevisionDecisionV2;

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

@@ -1,18 +1,59 @@
+import { buildAuthorityRevisionDecisionBrief } from "./long-task-authority-revision-brief.js";
 const SCOPE_EXPANSION_REASONS = new Set([
     "owner_path_expanded",
     "expected_change_path_expanded",
     "allowed_path_expanded",
 ]);
+const MECHANICALLY_BOUNDED_REASONS = new Set([
+    "source_file_content_changed",
+    "context_authority_changed",
+    "verification_input_removed_or_replaced",
+    "environment_requirement_removed",
+    "risk_changed_requires_review",
+]);
+const USER_DECISION_REASONS = new Set([
+    "product_claim_added",
+    "product_claim_removed",
+    "product_claim_changed",
+    "global_semantics_changed",
+    "source_claim_removed_or_changed",
+    "source_claim_added",
+    "source_path_removed_or_replaced",
+    "check_removed",
+    "negative_assertion_removed",
+    "acceptance_semantics_reduced",
+    "proof_surface_changed",
+    "input_path_coverage_reduced",
+    "expected_output_requirement_weakened",
+    "artifact_removed",
+    "owner_context_ref_removed",
+    "forbidden_path_removed",
+    "obligation_removed_or_weakened",
+    "rollback_or_recovery_weakened",
+    "counterfactual_removed",
+    "population_weakened",
+    "verifier_content_changed",
+    "external_confirmation_changed",
+]);
+const AUTOMATIC_RUNNER_FIELDS = new Set([
+    "target",
+    "argv",
+    "cwd",
+    "timeout_ms",
+    "retry_policy",
+    "idempotent",
+    "resolved_target",
+    "resolved_cwd",
+    "package_script",
+]);
 const PROOF_REDUCTION_REASONS = new Set([
     "check_removed",
     "negative_assertion_removed",
+    "acceptance_semantics_reduced",
     "proof_surface_changed",
-    "runner_definition_changed",
-    "verification_input_removed_or_replaced",
     "input_path_coverage_reduced",
     "expected_output_requirement_weakened",
     "artifact_removed",
-    "environment_requirement_removed",
     "binding_removed_or_expanded",
     "obligation_removed_or_weakened",
     "rollback_or_recovery_weakened",
@@ -24,13 +65,54 @@ const PROOF_REDUCTION_REASONS = new Set([
 export function classifyAuthorityRevision(diff) {
     if (!diff.reduction_reasons.length)
         return "monotonic_evidence_strengthening";
+    const userDecisionReasons = authorityRevisionUserDecisionReasons(diff);
     if (diff.reduction_reasons.every((reason) => SCOPE_EXPANSION_REASONS.has(reason)))
         return "scope_only_expansion";
+    if (!userDecisionReasons.length)
+        return "mechanically_bounded_repair";
     return "protected_semantic_or_proof_change";
 }
+export function authorityRevisionUserDecisionReasons(diff) {
+    const reasons = [];
+    for (const reason of diff.reduction_reasons) {
+        if (USER_DECISION_REASONS.has(reason)) {
+            reasons.push(reason);
+            continue;
+        }
+        if (SCOPE_EXPANSION_REASONS.has(reason) ||
+            MECHANICALLY_BOUNDED_REASONS.has(reason))
+            continue;
+        if (reason === "product_semantics_changed") {
+            if (diff.product_semantics_changed.some(isDecisionProductSemanticField))
+                reasons.push(reason);
+            continue;
+        }
+        if (reason === "runner_definition_changed") {
+            if (diff.runner_definitions_changed.some((entry) => !AUTOMATIC_RUNNER_FIELDS.has(lastAddressPart(entry))))
+                reasons.push(reason);
+            continue;
+        }
+        if (reason === "binding_removed_or_expanded") {
+            if (diff.bindings_removed_or_expanded.some((entry) => entry.endsWith(":removed") ||
+                entry.endsWith(":target_or_kind_changed")))
+                reasons.push(reason);
+            continue;
+        }
+        if (reason === "acceptance_not_monotonic") {
+            if (!hasMechanicallyExplainedAcceptanceChange(diff))
+                reasons.push(reason);
+            continue;
+        }
+        // New or unknown reason codes fail closed until this policy owner
+        // explicitly classifies them.
+        reasons.push(reason);
+    }
+    return uniqueSorted(reasons);
+}
 export function summarizeAuthorityRevision(diff, outcomeKeys) {
     const affectedOutcomes = scopeAffectedOutcomes(diff);
     const changeClass = classifyAuthorityRevision(diff);
+    const userDecisionReasons = authorityRevisionUserDecisionReasons(diff);
     return {
         product_semantics_changed: diff.product_claims_added.length > 0 ||
             diff.product_claims_removed.length > 0 ||
@@ -50,7 +132,7 @@ export function summarizeAuthorityRevision(diff, outcomeKeys) {
             diff.context_files_added.length > 0 ||
             diff.context_files_removed.length > 0 ||
             diff.context_files_changed.length > 0,
-        acceptance_or_proof_weakened: diff.reduction_reasons.some((reason) => PROOF_REDUCTION_REASONS.has(reason)),
+        acceptance_or_proof_weakened: userDecisionReasons.some((reason) => PROOF_REDUCTION_REASONS.has(reason)),
         verifier_or_runner_changed: diff.verifier_content_changed ||
             diff.verifier_runtime_locator_changed ||
             diff.runner_definitions_changed.length > 0,
@@ -79,6 +161,8 @@ export function summarizeAuthorityRevision(diff, outcomeKeys) {
         expanded_owner_paths: uniqueSorted(diff.owner_paths_expanded),
         expanded_expected_change_paths: uniqueSorted(diff.expected_change_paths_expanded),
         expanded_allowed_support_paths: uniqueSorted(diff.allowed_paths_expanded),
+        user_decision_reasons: userDecisionReasons,
+        mechanically_bounded_reasons: uniqueSorted(diff.reduction_reasons.filter((reason) => !userDecisionReasons.includes(reason))),
         protected_reasons: uniqueSorted(diff.reduction_reasons),
         affected_outcomes: changeClass === "scope_only_expansion" && affectedOutcomes.length > 0
             ? affectedOutcomes
@@ -90,32 +174,60 @@ export function projectAuthorityRevisionDecision(value) {
         ...value.revision_diff,
         verification_inputs_added: value.revision_diff.verification_inputs_added ?? [],
         input_paths_added: value.revision_diff.input_paths_added ?? [],
+        acceptance_semantics_reduced: value.revision_diff.acceptance_semantics_reduced ?? [],
         external_confirmations_changed: value.revision_diff.external_confirmations_changed ?? false,
         external_confirmation_changes: value.revision_diff.external_confirmation_changes ?? [],
     };
     const computedSummary = summarizeAuthorityRevision(diff, value.affected_outcomes_or_contracts);
     const storedSummary = value.approval_summary;
+    const approvalSummary = storedSummary
+        ? {
+            ...computedSummary,
+            ...storedSummary,
+            semantic_fields_changed: storedSummary.semantic_fields_changed ??
+                computedSummary.semantic_fields_changed,
+            source_claim_changes: storedSummary.source_claim_changes ??
+                computedSummary.source_claim_changes,
+            product_claim_changes: storedSummary.product_claim_changes ??
+                computedSummary.product_claim_changes,
+            proof_reductions: storedSummary.proof_reductions ?? computedSummary.proof_reductions,
+            external_confirmation_changes: storedSummary.external_confirmation_changes ??
+                computedSummary.external_confirmation_changes,
+            user_decision_reasons: storedSummary.user_decision_reasons ??
+                computedSummary.user_decision_reasons,
+            mechanically_bounded_reasons: storedSummary.mechanically_bounded_reasons ??
+                computedSummary.mechanically_bounded_reasons,
+        }
+        : computedSummary;
+    const changeClass = value.change_class ?? classifyAuthorityRevision(diff);
+    const computedUserDecisionReasons = authorityRevisionUserDecisionReasons(diff);
+    const userDecisionRequired = value.user_decision_required ??
+        value.approval_required ??
+        computedUserDecisionReasons.length > 0;
+    const userDecisionReasons = value.user_decision_reasons ??
+        approvalSummary.user_decision_reasons ??
+        computedUserDecisionReasons;
     return {
         revision_identity: value.revision_identity,
-        change_class: value.change_class ?? classifyAuthorityRevision(diff),
-        approval_required: value.approval_required ?? true,
-        approval_summary: storedSummary
-            ? {
-                ...computedSummary,
-                ...storedSummary,
-                semantic_fields_changed: storedSummary.semantic_fields_changed ??
-                    computedSummary.semantic_fields_changed,
-                source_claim_changes: storedSummary.source_claim_changes ??
-                    computedSummary.source_claim_changes,
-                product_claim_changes: storedSummary.product_claim_changes ??
-                    computedSummary.product_claim_changes,
-                proof_reductions: storedSummary.proof_reductions ?? computedSummary.proof_reductions,
-                external_confirmation_changes: storedSummary.external_confirmation_changes ??
-                    computedSummary.external_confirmation_changes,
-            }
-            : computedSummary,
+        change_class: changeClass,
+        user_decision_required: userDecisionRequired,
+        user_decision_reasons: userDecisionReasons,
+        approval_required: userDecisionRequired,
+        approval_summary: approvalSummary,
+        decision_brief: buildAuthorityRevisionDecisionBrief(approvalSummary, changeClass, userDecisionRequired),
     };
 }
+function isDecisionProductSemanticField(field) {
+    return (!/^stages\.[^.]+\.title$/u.test(field) &&
+        !/^outcomes\.[^.]+\.title$/u.test(field));
+}
+function lastAddressPart(value) {
+    return value.slice(value.lastIndexOf(":") + 1);
+}
+function hasMechanicallyExplainedAcceptanceChange(diff) {
+    return (diff.verification_inputs_removed_or_replaced.length > 0 ||
+        diff.environment_requirements_removed.length > 0);
+}
 function scopeAffectedOutcomes(diff) {
     return uniqueSorted([
         ...diff.owner_paths_expanded,

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

@@ -1,5 +1,5 @@
 import type { AuthorityHashesV2, AuthorityMaterialHashesV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-authority-types.js";
-export type AuthorityRevisionChangeClassV2 = "monotonic_evidence_strengthening" | "scope_only_expansion" | "protected_semantic_or_proof_change";
+export type AuthorityRevisionChangeClassV2 = "monotonic_evidence_strengthening" | "mechanically_bounded_repair" | "scope_only_expansion" | "protected_semantic_or_proof_change";
 export interface AuthorityRevisionApprovalSummaryV2 {
     product_semantics_changed: boolean;
     global_or_technical_semantics_changed: boolean;
@@ -19,6 +19,8 @@ export interface AuthorityRevisionApprovalSummaryV2 {
     expanded_owner_paths: string[];
     expanded_expected_change_paths: string[];
     expanded_allowed_support_paths: string[];
+    user_decision_reasons: string[];
+    mechanically_bounded_reasons: string[];
     protected_reasons: string[];
     affected_outcomes: string[];
 }
@@ -34,15 +36,30 @@ export interface AuthorityRevisionProposalV2 {
     new_risk_floor: "standard" | "strict";
     affected_outcomes_or_contracts: string[];
     change_class: AuthorityRevisionChangeClassV2;
+    user_decision_required: boolean;
+    user_decision_reasons: string[];
+    /** Compatibility alias for user_decision_required. */
     approval_required: boolean;
     approval_summary: AuthorityRevisionApprovalSummaryV2;
     revision_identity: string;
 }
+export interface AuthorityRevisionDecisionBriefV2 {
+    overview: string;
+    headline: string;
+    approval_reason: string;
+    material_changes: string[];
+    affected_outcomes: string[];
+    if_approved: string[];
+}
 export interface AuthorityRevisionDecisionV2 {
     revision_identity: string;
     change_class: AuthorityRevisionChangeClassV2;
+    user_decision_required: boolean;
+    user_decision_reasons: string[];
+    /** Compatibility alias for user_decision_required. */
     approval_required: boolean;
     approval_summary: AuthorityRevisionApprovalSummaryV2;
+    decision_brief: AuthorityRevisionDecisionBriefV2;
 }
 export interface AuthorityRevisionDiffV2 {
     product_claims_added: string[];
@@ -53,6 +70,7 @@ export interface AuthorityRevisionDiffV2 {
     checks_added: string[];
     checks_removed: string[];
     negative_assertions_removed: string[];
+    acceptance_semantics_reduced: string[];
     proof_surfaces_changed: string[];
     source_claims_added: string[];
     source_claims_removed_or_changed: string[];

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

@@ -39,6 +39,10 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         ...selectedRevisionReasons([
             ["check_removed", checksRemoved],
             ["negative_assertion_removed", checkChanges.negative_assertions_removed],
+            [
+                "acceptance_semantics_reduced",
+                checkChanges.acceptance_semantics_reduced,
+            ],
             ["proof_surface_changed", checkChanges.proof_surfaces_changed],
             ["source_claim_removed_or_changed", sourceClaimsRemovedOrChanged],
             ["source_claim_added", sourceClaimsAdded],
@@ -98,6 +102,7 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         checks_added: addedValues(new Set(beforeChecks.keys()), new Set(afterChecks.keys())),
         checks_removed: checksRemoved,
         negative_assertions_removed: checkChanges.negative_assertions_removed,
+        acceptance_semantics_reduced: checkChanges.acceptance_semantics_reduced,
         proof_surfaces_changed: checkChanges.proof_surfaces_changed,
         source_claims_added: sourceClaimsAdded,
         source_claims_removed_or_changed: sourceClaimsRemovedOrChanged,

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

@@ -1,5 +1,6 @@
 import type { ProofSurface } from "./long-task-contract-types.js";
 import type { DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
+import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
 export interface AuthorityHashesV2 {
@@ -59,6 +60,7 @@ export interface ProductSemanticProjectionV2 {
             feedback: string;
             accessibility: string;
         }>;
+        surface_bindings: DeliverySurfaceBindingV2[];
         non_completing_outcomes: Array<{
             key: string;
             statement: string;

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

@@ -79,7 +79,7 @@ export function isMonotonicAcceptanceStrengthening(previous, next) {
     if (!acceptanceSemanticsChanged(previous, next))
         return false;
     if (!same(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
-        !subset(previous.global.acceptance.counterfactual_controls ?? [], next.global.acceptance.counterfactual_controls) ||
+        !counterfactualsStrengthened(previous.global.acceptance.counterfactual_controls ?? [], next.global.acceptance.counterfactual_controls) ||
         !checksStrengthened(previous.global.acceptance.checks, next.global.acceptance.checks))
         return false;
     const nextOutcomes = new Map(next.outcomes.map((outcome) => [outcome.key, outcome]));
@@ -91,7 +91,7 @@ export function isMonotonicAcceptanceStrengthening(previous, next) {
             return false;
         if (!checksStrengthened(previousOutcome.acceptance.checks, nextOutcome.acceptance.checks) ||
             !optionalStrengthened(previousOutcome.acceptance.population, nextOutcome.acceptance.population) ||
-            !subset(previousOutcome.acceptance.counterfactual_controls, nextOutcome.acceptance.counterfactual_controls))
+            !counterfactualsStrengthened(previousOutcome.acceptance.counterfactual_controls, nextOutcome.acceptance.counterfactual_controls))
             return false;
     }
     return true;
@@ -154,6 +154,14 @@ function assertionsStrengthened(previous, next) {
     }
     return true;
 }
+function counterfactualsStrengthened(previous, next) {
+    return previous.every((control) => next.some((candidate) => same(candidate.binding_key, control.binding_key) &&
+        same(candidate.binding_ref, control.binding_ref) &&
+        candidate.check_key === control.check_key &&
+        same(candidate.mutation, control.mutation) &&
+        subset(control.claims, candidate.claims) &&
+        subset(control.expected_assertion_failures, candidate.expected_assertion_failures)));
+}
 function subset(previous, next) {
     const available = new Set(next.map((item) => canonicalValueJson(item)));
     return previous.every((item) => available.has(canonicalValueJson(item)));

package/dist/lib/long-task-check-execution-policy.js

@@ -19,6 +19,8 @@ export function rawExecutionInputProjection(check) {
     projection.evidence_adapter = check.evidence_adapter;
     projection.execution_target_definition = check.execution_target_definition;
     projection.known_execution_targets = check.known_execution_targets;
+    projection.design_conformance_targets =
+        check.design_conformance_targets ?? [];
     for (const field of Object.keys(CHECK_EXECUTION_INPUT_POLICY)) {
         const policy = CHECK_EXECUTION_INPUT_POLICY[field];
         if (policy === "raw_execution") {

package/dist/lib/long-task-claim-definitions.js

@@ -30,9 +30,7 @@ export function generateClaims(outcome) {
         ];
         for (const [field, value] of fields)
             if (value.trim())
-                claims.push(claim(outcome.key, `control.${control.key}.${field}`, "control", [
-                    "ui_browser",
-                ]));
+                claims.push(claim(outcome.key, `control.${control.key}.${field}`, "control"));
     }
     for (const item of outcome.product.non_completing_outcomes)
         claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing"));
@@ -54,8 +52,6 @@ export function validateGlobalProofPolarity(claim, proof) {
         fail("global_negative_claim_proof_required", `${claim.local_key}:${proof.check_key}`);
 }
 export function validateProofSurface(claim, proof, outcomeKey) {
-    if (claim.kind === "control" && proof.proof_surface !== "ui_browser")
-        fail("ui_claim_requires_ui_browser", `${outcomeKey}:${claim.local_key}`);
     if ((claim.kind === "non_completing" || claim.kind === "forbidden_shortcut") &&
         proof.polarity !== "negative" &&
         proof.polarity !== "counterfactual")

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

@@ -1,6 +1,7 @@
 import type { LongTaskRiskFacts, RequestedRiskLevel } from "./long-task-risk-types.js";
 import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./long-task-counterfactual-types.js";
 import type { CheckExecutionTargetV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
+import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
     refs: string[];
@@ -172,6 +173,7 @@ export interface DeliveryOutcomeV2 {
         requirements: DeliveryRequirementV2[];
         owner_surfaces: string[];
         controls: DeliveryControlV2[];
+        surface_bindings: DeliverySurfaceBindingV2[];
         non_completing_outcomes: KeyedStatementV2[];
     };
     technical: {

package/dist/lib/long-task-counterfactual-sandbox.d.ts

@@ -3,4 +3,11 @@ export interface CounterfactualSandboxV2 {
     root: string;
     dispose(): Promise<void>;
 }
+type RemoveTree = (target: string, options: {
+    recursive: true;
+    force: true;
+}) => Promise<void>;
+type Wait = (milliseconds: number) => Promise<void>;
 export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2): Promise<CounterfactualSandboxV2>;
+export declare function removeCounterfactualSandboxRoot(root: string, removeTree?: RemoveTree, wait?: Wait): Promise<void>;
+export {};

package/dist/lib/long-task-counterfactual-sandbox.js

@@ -2,6 +2,15 @@ import { copyFile, cp, lstat, mkdir, mkdtemp, readlink, realpath, rm, symlink, }
 import os from "node:os";
 import path from "node:path";
 import { matchesRepoPattern } from "./long-task-paths.js";
+const TRANSIENT_REMOVE_CODES = new Set([
+    "EBUSY",
+    "EMFILE",
+    "ENFILE",
+    "ENOTEMPTY",
+    "EPERM",
+]);
+const REMOVE_RETRY_LIMIT = process.platform === "win32" ? 6 : 2;
+const REMOVE_RETRY_DELAY_MS = 100;
 export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest) {
     const root = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-"));
     if (!manifest) {
@@ -81,7 +90,24 @@ function disposable(root) {
     return {
         root,
         async dispose() {
-            await rm(root, { recursive: true, force: true });
+            await removeCounterfactualSandboxRoot(root);
         },
     };
 }
+export async function removeCounterfactualSandboxRoot(root, removeTree = rm, wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await removeTree(root, { recursive: true, force: true });
+            return;
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error
+                ? String(error.code)
+                : "";
+            if (!TRANSIENT_REMOVE_CODES.has(code) ||
+                attempt >= REMOVE_RETRY_LIMIT)
+                throw error;
+            await wait(REMOVE_RETRY_DELAY_MS * (attempt + 1));
+        }
+    }
+}