project-tiny-context-harness 0.8.13 → 0.8.17

package/dist/lib/design-resource-implementation-feasibility-validation.js

@@ -0,0 +1,138 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceImplementationFeasibilityJson } from "./design-resource-implementation-feasibility-shape.js";
+import { loadDesignResourceFeasibilityDecisionSource, } from "./design-resource-implementation-feasibility-source-decision.js";
+import { validateFeasibilityDocument } from "./design-resource-implementation-feasibility-validation-document.js";
+import { invalidFeasibility, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+const FEASIBILITY_MAX_BYTES = 2_097_152;
+const TECHNICAL_SOURCE_MAX_BYTES = 16_777_216;
+export async function readAndValidateDesignResourceImplementationFeasibility(repository, handoffPath, inputs, targetModels, canonicalResourcePaths) {
+    unique(inputs.map((item) => item.key), "input_key_duplicate");
+    unique(inputs.map((item) => item.path), "input_path_duplicate");
+    unique(inputs.map((item) => item.target_ref), "input_target_duplicate");
+    for (const input of inputs)
+        if (!targetModels.has(input.target_ref))
+            invalidFeasibility("input_target_unknown", input.target_ref);
+    validateTargetInputCoverage(inputs, targetModels);
+    const loaded = [];
+    const sourcePathIdentities = new Map();
+    for (const input of inputs) {
+        const model = targetModels.get(input.target_ref);
+        if (!model)
+            invalidFeasibility("input_target_unknown", input.target_ref);
+        if (input.path === handoffPath)
+            invalidFeasibility("input_must_not_be_handoff", input.key);
+        if (canonicalResourcePaths.has(input.path))
+            invalidFeasibility("input_mixed_into_canonical_resources", input.path);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...input.path.split("/")), `design_resource_feasibility:${input.key}`);
+        const size = (await stat(file)).size;
+        if (size > FEASIBILITY_MAX_BYTES)
+            invalidFeasibility("input_byte_limit_exceeded", `${input.key}:bytes=${size}:limit=${FEASIBILITY_MAX_BYTES}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== input.sha256)
+            invalidFeasibility("input_digest_mismatch", `${input.key}:${input.sha256}:${digest}`);
+        const content = bytes.toString("utf8");
+        if (!Buffer.from(content, "utf8").equals(bytes))
+            invalidFeasibility("input_utf8_invalid", input.key);
+        const document = parseDesignResourceImplementationFeasibilityJson(content);
+        if (document.key !== input.key)
+            invalidFeasibility("input_key_mismatch", `${input.key}:${document.key}`);
+        if (document.target_ref !== input.target_ref)
+            invalidFeasibility("input_target_mismatch", `${input.target_ref}:${document.target_ref}`);
+        const decisionSources = await validateTechnicalSourceRecords(repository, handoffPath, input.path, document.source_records, canonicalResourcePaths, sourcePathIdentities);
+        await validateFeasibilityDocument(repository, document, model, decisionSources);
+        loaded.push({
+            index: input,
+            document,
+            identity: {
+                key: input.key,
+                target_ref: input.target_ref,
+                path: input.path,
+                sha256: digest,
+                realization_mode: document.realization_mode,
+                component_family_cells: document.component_family_cells.length,
+                blockers: document.blockers.length,
+            },
+        });
+    }
+    return loaded;
+}
+function validateTargetInputCoverage(inputs, targetModels) {
+    if (!inputs.length)
+        return;
+    const indexedTargets = new Set(inputs.map((item) => item.target_ref));
+    for (const model of targetModels.values())
+        if (model.source_profile_kind !== "reference" &&
+            !indexedTargets.has(model.target_ref))
+            invalidFeasibility("implementation_target_input_missing", model.target_ref);
+}
+async function validateTechnicalSourceRecords(repository, handoffPath, inputPath, records, canonicalResourcePaths, sharedPathIdentities) {
+    const decisionSources = new Map();
+    unique(records.map((item) => item.key), "source_record_key_duplicate");
+    unique(records.map((item) => `${item.path}\0${item.locator.kind}\0${item.locator.value}`), "source_record_locator_duplicate");
+    for (const record of records) {
+        if (!record.roles.length)
+            invalidFeasibility("source_record_roles_required", record.key);
+        unique(record.roles, "source_record_role_duplicate", record.key);
+        if (record.path === handoffPath || record.path === inputPath)
+            invalidFeasibility("source_record_self_reference", `${record.key}:${record.path}`);
+        if (canonicalResourcePaths.has(record.path))
+            invalidFeasibility("technical_source_mixed_into_canonical_resources", record.path);
+        validateSharedSourceIdentity(record, sharedPathIdentities);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...record.path.split("/")), `design_resource_feasibility_source:${record.key}`);
+        const size = (await stat(file)).size;
+        if (size > TECHNICAL_SOURCE_MAX_BYTES)
+            invalidFeasibility("source_record_byte_limit_exceeded", `${record.key}:bytes=${size}:limit=${TECHNICAL_SOURCE_MAX_BYTES}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== record.sha256)
+            invalidFeasibility("source_record_digest_mismatch", `${record.key}:${record.sha256}:${digest}`);
+        const decisionSource = validateSourceLocator(record, bytes);
+        if (decisionSource)
+            decisionSources.set(record.key, decisionSource);
+    }
+    return decisionSources;
+}
+function validateSharedSourceIdentity(record, sharedPathIdentities) {
+    const identity = `${record.media_type}\0${record.sha256}`;
+    const previous = sharedPathIdentities.get(record.path);
+    if (previous && previous !== identity)
+        invalidFeasibility("source_record_path_identity_conflict", record.path);
+    sharedPathIdentities.set(record.path, identity);
+}
+function validateSourceLocator(record, bytes) {
+    if (record.locator.kind === "whole_resource")
+        return null;
+    const content = bytes.toString("utf8");
+    if (!Buffer.from(content, "utf8").equals(bytes))
+        invalidFeasibility("source_record_utf8_invalid", record.key);
+    if (record.locator.kind === "source_item")
+        return loadDesignResourceFeasibilityDecisionSource(record, content);
+    if (record.locator.kind === "json_pointer") {
+        validateJsonPointer(record, content);
+        return null;
+    }
+    if (!content.includes(record.locator.value))
+        invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
+    return null;
+}
+function validateJsonPointer(record, content) {
+    let current;
+    try {
+        current = JSON.parse(content);
+    }
+    catch {
+        invalidFeasibility("source_record_json_invalid", record.key);
+    }
+    for (const raw of record.locator.value.slice(1).split("/")) {
+        const segment = raw.replace(/~1/gu, "/").replace(/~0/gu, "~");
+        if (!current ||
+            typeof current !== "object" ||
+            !Object.hasOwn(current, segment))
+            invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
+        current = current[segment];
+    }
+}

package/dist/lib/design-resource-symbolic-fact-shape.js

@@ -1,5 +1,6 @@
 import { parseDesignResourceHandoffResources } from "./design-resource-handoff-shape-structure.js";
 import { contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.js";
 import { array, literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
 export { parseDesignResourceObservableRuleManifestJson, parseDesignResourceObservableRuleManifestShape, } from "./design-resource-symbolic-manifest-shape.js";
 export function parseDesignResourceSymbolicHandoffShape(value) {
@@ -14,13 +15,14 @@ export function parseDesignResourceSymbolicHandoffShape(value) {
         "targets",
         "coverage",
         "proposal",
-    ]);
+    ], ["technical_feasibility_inputs"]);
     return {
         schema_version: literal(root.schema_version, ["design-resource-handoff-v2"], `${label}.schema_version`),
         representation: literal(root.representation, ["symbolic_rules_v2"], `${label}.representation`),
         intent: literal(root.intent, ["implementation_handoff"], `${label}.intent`),
         scope: parseScope(root.scope, label),
         provenance: parseProvenance(root.provenance, label),
+        technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? [], `${label}.technical_feasibility_inputs`),
         resources: parseDesignResourceHandoffResources(root.resources),
         targets: parseTargets(root.targets, label),
         coverage: parseCoverage(root.coverage, label),

package/dist/lib/design-resource-symbolic-fact-types.d.ts

@@ -3,6 +3,7 @@ import type { DesignResourceEnvironmentV1, DesignResourceFactLineageV1, DesignRe
 import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffResourceV1, DesignResourceHandoffSubjectV1, DesignResourceSourceProfileKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 import type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationDisposition, SymbolicDenotationPredicate, SymbolicExtensionalPointV1 } from "./symbolic-denotation-types.js";
 import type { DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-noninterference-types.js";
+import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
 export type { DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceEquivalenceCaseV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofMethodV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicStaticDependencyNodeV2, DesignResourceSymbolicStaticDependencyRootV2, } from "./design-resource-symbolic-noninterference-types.js";
 export interface DesignResourceSymbolicPopulationV2 {
     key: string;
@@ -175,6 +176,7 @@ export interface DesignResourceHandoffV2 {
         model: string;
         design_system_id: string;
     };
+    technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     targets: DesignResourceSymbolicHandoffTargetV2[];
     coverage: DesignResourceSymbolicHandoffCoverageV2[];
@@ -199,6 +201,9 @@ export interface DesignResourceHandoffPreflightV2 extends ParsedDesignResourceHa
     status: "ready";
     manifest: DesignResourceObservableRuleManifestV2;
     resource_hashes: Record<string, string>;
+    technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];
+    technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];
+    limitations: string[];
     rule_projections: DesignResourceSymbolicRuleProjectionV2[];
     metrics: {
         semantic_obligations: number;

package/dist/lib/design-resource-symbolic-fact-validation.js

@@ -7,6 +7,8 @@ import { validateSymbolicCoverage } from "./design-resource-symbolic-region-vali
 import { assertSameSet, invalid, requireExactRefs, unique, } from "./design-resource-symbolic-validation-support.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { sha256Hex } from "./strict-codec.js";
+import { createV2ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
 export { designResourceSymbolicCertificateKey, designResourceSymbolicCombinedRuleDigest, designResourceSymbolicDependencyEdge, designResourceSymbolicNoninterferenceProofDigest, designResourceSymbolicObligationKey, designResourceSymbolicRuleKey, } from "./design-resource-symbolic-validation-support.js";
 const V2_MANIFEST_MAX_BYTES = 8_388_608;
 export async function preflightParsedDesignResourceSymbolicHandoff(repository, parsed) {
@@ -37,12 +39,23 @@ export async function preflightParsedDesignResourceSymbolicHandoff(repository, p
         invalid("v2_manifest_identity_mismatch", `${manifest.scope_key}:${manifest.target_key}`);
     const validated = validateDesignResourceSymbolicManifest(manifest, parsed, resources, contents);
     validateSymbolicCoverage(parsed, manifest);
+    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map([
+        [
+            target.key,
+            createV2ImplementationFeasibilityTargetModel(target, manifest),
+        ],
+    ]), new Set(handoff.resources.map((resource) => resource.path)));
     return {
         ...parsed,
         preflight_schema_version: "design-resource-handoff-preflight-v2",
         status: "ready",
         manifest,
         resource_hashes: resourceHashes,
+        technical_feasibility_documents: feasibility.map((item) => item.document),
+        technical_feasibility_identities: feasibility.map((item) => item.identity),
+        limitations: target.source_profile.kind !== "reference" && !feasibility.length
+            ? ["technical feasibility not declared"]
+            : [],
         rule_projections: validated.ruleProjections,
         metrics: validated.metrics,
     };

package/dist/lib/long-task-activation-validation.js

@@ -19,11 +19,14 @@ import { captureWorkspaceManifest, repoRelative, } from "./long-task-workspace.j
 export async function validateContractForActivation(options) {
     const { contract, repository, workdir, mode } = options;
     const diagnostics = options.diagnostics ?? [];
+    const structureOptions = {
+        allowDeferredDesignComponentBindingClosure: true,
+    };
     if (mode === "collect")
-        for (const error of deliveryContractStructureDiagnostics(contract))
+        for (const error of deliveryContractStructureDiagnostics(contract, structureOptions))
             addDiagnosticError(diagnostics, error);
     else
-        validateDeliveryContractStructure(contract);
+        validateDeliveryContractStructure(contract, structureOptions);
     const claims = await attempt(mode, diagnostics, () => compileProductClaimCoverage(contract));
     if (mode === "fail_fast") {
         const decisions = contract.source_claims
@@ -45,7 +48,7 @@ export async function validateContractForActivation(options) {
             : undefined);
         return items;
     });
-    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository));
+    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems ?? []));
     const risk = await attempt(mode, diagnostics, () => {
         const decision = classifyLongTaskRisk(contract);
         validateRiskProof(contract, decision);
@@ -83,11 +86,15 @@ export async function validateContractForActivation(options) {
     const outcomes = [];
     for (const outcome of contract.outcomes) {
         const checks = [];
+        const blockedDesignAssertionRefsByCheck = new Map();
         for (const check of outcome.acceptance.checks) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
+            const blockedDesignAssertionRefs = externallyBlockedDesignAssertionRefs(outcome, check, contract.global.acceptance.external_confirmations);
+            blockedDesignAssertionRefsByCheck.set(check.key, blockedDesignAssertionRefs);
+            const machineCheck = projectMachineCheck(check, blockedDesignAssertionRefs);
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(machineCheck, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key, contract.global.acceptance.external_confirmations), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
             if (frozen)
                 checks.push(frozen);
         }
@@ -96,7 +103,12 @@ export async function validateContractForActivation(options) {
             internal_id: `OUT.${outcome.key}`,
             generated_claims: claims?.by_outcome[outcome.key] ?? [],
             risk_reasons: risk?.reasons_by_outcome[outcome.key] ?? [],
-            acceptance: { ...outcome.acceptance, checks },
+            acceptance: {
+                ...outcome.acceptance,
+                checks,
+                counterfactual_controls: outcome.acceptance.counterfactual_controls.map((control) => projectCounterfactualControl(control, outcome.acceptance.checks.find((check) => check.key === control.check_key), blockedDesignAssertionRefsByCheck.get(control.check_key) ??
+                    new Set())),
+            },
         });
     }
     const allChecks = [
@@ -130,9 +142,11 @@ export async function validateContractForActivation(options) {
         outcomes,
     };
 }
-function designTargetsForCheck(outcome, checkKey) {
+function designTargetsForCheck(outcome, checkKey, confirmations) {
     return (outcome.product.surface_bindings ?? []).flatMap((binding) => binding.design_targets
-        .filter((target) => target.conformance_check_ref === checkKey)
+        .filter((target) => target.conformance_check_ref === checkKey &&
+        !confirmations.some((confirmation) => confirmation.blocks_target &&
+            confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`))))
         .map((target) => ({
         ...target,
         surface_binding_ref: binding.key,
@@ -140,6 +154,62 @@ function designTargetsForCheck(outcome, checkKey) {
         target_ref: binding.target_ref,
     })));
 }
+function externallyBlockedDesignAssertionRefs(outcome, check, confirmations) {
+    const refs = new Set();
+    const impactedClaims = new Set();
+    for (const binding of outcome.product.surface_bindings ?? [])
+        for (const target of binding.design_targets) {
+            if (target.conformance_check_ref !== check.key)
+                continue;
+            const blocked = confirmations.some((confirmation) => confirmation.blocks_target &&
+                confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`)));
+            if (!blocked)
+                continue;
+            for (const confirmation of confirmations)
+                if (confirmation.blocks_target &&
+                    confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`)))
+                    for (const claimRef of confirmation.impact_claims)
+                        impactedClaims.add(claimRef);
+            refs.add(target.conformance_assertion_ref);
+            for (const method of target.verification_method_bindings)
+                refs.add(method.assertion_ref);
+            for (const method of target.symbolic_method_bindings ?? [])
+                refs.add(method.assertion_ref);
+            if (target.symbolic_certificate_binding)
+                refs.add(target.symbolic_certificate_binding.assertion_ref);
+        }
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ])
+        if (assertion.evidence_capabilities.includes("state_delta") &&
+            assertion.claims.length > 0 &&
+            assertion.claims.every((claimRef) => impactedClaims.has(`${outcome.key}.${claimRef}`)))
+            refs.add(assertion.key);
+    return refs;
+}
+function projectMachineCheck(check, externallyBlockedAssertionRefs) {
+    if (!externallyBlockedAssertionRefs.size)
+        return check;
+    return {
+        ...check,
+        positive_assertions: check.positive_assertions.filter((assertion) => !externallyBlockedAssertionRefs.has(assertion.key)),
+        negative_assertions: check.negative_assertions.filter((assertion) => !externallyBlockedAssertionRefs.has(assertion.key)),
+    };
+}
+function projectCounterfactualControl(control, check, externallyBlockedAssertionRefs) {
+    if (!check || !externallyBlockedAssertionRefs.size)
+        return control;
+    const externallyBlockedClaims = new Set([...check.positive_assertions, ...check.negative_assertions]
+        .filter((assertion) => externallyBlockedAssertionRefs.has(assertion.key))
+        .flatMap((assertion) => assertion.claims));
+    return {
+        ...control,
+        claims: control.claims.filter((claimRef) => !externallyBlockedClaims.has(claimRef)),
+        expected_assertion_failures: control.expected_assertion_failures.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
+        preserved_assertions: control.preserved_assertions.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
+    };
+}
 async function attempt(mode, diagnostics, action, outcomeKey, checkKey) {
     try {
         return await action();

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

@@ -15,7 +15,9 @@ export function buildAuthorityRevisionDecisionBrief(summary, changeClass, approv
     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.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,

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

@@ -59,7 +59,6 @@ const PROOF_REDUCTION_REASONS = new Set([
     "rollback_or_recovery_weakened",
     "counterfactual_removed",
     "population_weakened",
-    "verifier_content_changed",
     "acceptance_not_monotonic",
 ]);
 export function classifyAuthorityRevision(diff) {
@@ -136,6 +135,8 @@ export function summarizeAuthorityRevision(diff, outcomeKeys) {
         verifier_or_runner_changed: diff.verifier_content_changed ||
             diff.verifier_runtime_locator_changed ||
             diff.runner_definitions_changed.length > 0,
+        verifier_content_changed: diff.verifier_content_changed,
+        verifier_files_changed: uniqueSorted(diff.verifier_files_changed),
         write_scope_expanded: diff.owner_or_path_boundary_changed,
         risk_changed: diff.risk_changed,
         external_confirmations_changed: diff.external_confirmations_changed,
@@ -184,13 +185,16 @@ export function projectAuthorityRevisionDecision(value) {
         ? {
             ...computedSummary,
             ...storedSummary,
+            acceptance_or_proof_weakened: computedSummary.acceptance_or_proof_weakened,
+            verifier_content_changed: computedSummary.verifier_content_changed,
+            verifier_files_changed: computedSummary.verifier_files_changed,
             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,
+            proof_reductions: computedSummary.proof_reductions,
             external_confirmation_changes: storedSummary.external_confirmation_changes ??
                 computedSummary.external_confirmation_changes,
             user_decision_reasons: storedSummary.user_decision_reasons ??

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

@@ -7,6 +7,8 @@ export interface AuthorityRevisionApprovalSummaryV2 {
     context_authority_changed: boolean;
     acceptance_or_proof_weakened: boolean;
     verifier_or_runner_changed: boolean;
+    verifier_content_changed: boolean;
+    verifier_files_changed: string[];
     write_scope_expanded: boolean;
     risk_changed: boolean;
     external_confirmations_changed: boolean;