project-tiny-context-harness 0.7.3 → 0.7.5

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

@@ -0,0 +1,91 @@
+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: [],
+        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 (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;
+}
+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.js

@@ -1,7 +1,8 @@
 import { acceptanceSemanticsChanged, isMonotonicAcceptanceStrengthening, } from "./long-task-authority.js";
 import { authorityMaterialRevisionDiff, changedProductClaimSemantics, sourceClaimAdditions, } from "./long-task-authority-material-diff.js";
+import { analyzeCheckRevisions, analyzeOutcomeRevisions, keyedAuthorityChanges, selectedRevisionReasons, } from "./long-task-authority-revision-analysis.js";
+import { addedValues, checkIndex, removedExactValues, removedValues, sourceClaimReductions, } from "./long-task-authority-revision-details.js";
 import { compileProductClaimCoverage } from "./long-task-claims.js";
-import { addedInputPaths, addedVerificationInputs, addedValues, bindingReductions, changedRunnerFields, checkIndex, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, removedValues, rollbackReductions, same, sourceClaimReductions, } from "./long-task-authority-revision-details.js";
 import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
 export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier) {
     const materialDiff = authorityMaterialRevisionDiff(previous, nextMaterials);
@@ -16,67 +17,12 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
     const productClaimsAdded = addedValues(beforeClaimIds, afterClaimIds);
     const productClaimsChanged = changedProductClaimSemantics(previous, next);
     const checksRemoved = removedValues(new Set(beforeChecks.keys()), new Set(afterChecks.keys()));
-    const negativeAssertionsRemoved = [];
-    const proofSurfacesChanged = [];
-    const runnerDefinitionsChanged = [];
-    const verificationInputsAdded = [];
-    const verificationInputsRemovedOrReplaced = [];
-    const inputPathsAdded = [];
-    const inputPathsRemovedOrNarrowed = [];
-    const expectedOutputPathsRemovedOrWeakened = [];
-    const artifactsRemoved = [];
-    const environmentRequirementsRemoved = [];
-    for (const [identity, before] of beforeChecks) {
-        const after = afterChecks.get(identity);
-        if (!after)
-            continue;
-        for (const assertion of before.negative_assertions)
-            if (!after.negative_assertions.some((item) => same(item, assertion)))
-                negativeAssertionsRemoved.push(`${identity}:${assertion.key}`);
-        if (before.proof_surface !== after.proof_surface)
-            proofSurfacesChanged.push(`${identity}:${before.proof_surface}->${after.proof_surface}`);
-        runnerDefinitionsChanged.push(...changedRunnerFields(identity, before, after));
-        verificationInputsAdded.push(...addedVerificationInputs(identity, before, after));
-        verificationInputsRemovedOrReplaced.push(...removedOrReplacedVerificationInputs(identity, before, after));
-        inputPathsAdded.push(...addedInputPaths(identity, before, after));
-        inputPathsRemovedOrNarrowed.push(...removedOrNarrowedInputPaths(identity, before, after));
-        expectedOutputPathsRemovedOrWeakened.push(...removedOrWeakenedExpectedOutputPaths(identity, before, after));
-        artifactsRemoved.push(...removedExactValues(identity, before.artifact_globs, after.artifact_globs));
-        environmentRequirementsRemoved.push(...removedStructuredValues(identity, before.environment_requirements, after.environment_requirements));
-    }
+    const checkChanges = analyzeCheckRevisions(beforeChecks, afterChecks);
     const sourceClaimsRemovedOrChanged = sourceClaimReductions(previous.source_claims, next.source_claims);
     const sourceClaimsAdded = sourceClaimAdditions(previous.source_claims, next.source_claims);
     const sourcePathsRemovedOrReplaced = removedExactValues("task", previous.task.source_paths, next.task.source_paths);
-    const ownerPathsExpanded = [];
-    const ownerContextRefsRemoved = [];
-    const expectedChangePathsExpanded = [];
-    const allowedPathsExpanded = [];
-    const forbiddenPathsRemoved = removedGlobalForbiddenPaths(previous, next);
-    const bindingsRemovedOrExpanded = [];
-    const obligationsRemovedOrWeakened = [];
-    const rollbackOrRecoveryWeakened = [];
-    const counterfactualsRemoved = globalCounterfactualReductions(previous, next);
-    const populationWeakened = [];
+    const outcomeChanges = analyzeOutcomeRevisions(previous, next);
     const verifierDiff = verifierAuthorityDiff(previous.verifier_identity, nextVerifier);
-    const previousOutcomes = new Map(previous.outcomes.map((outcome) => [outcome.key, outcome]));
-    for (const after of next.outcomes) {
-        const before = previousOutcomes.get(after.key);
-        if (!before)
-            continue;
-        ownerPathsExpanded.push(...expandedPatterns(after.key, before.product.owner.path_globs, after.product.owner.path_globs));
-        ownerContextRefsRemoved.push(...removedExactValues(after.key, before.product.owner.context_refs, after.product.owner.context_refs));
-        expectedChangePathsExpanded.push(...expandedPatterns(after.key, before.technical.expected_change_paths, after.technical.expected_change_paths));
-        allowedPathsExpanded.push(...expandedPatterns(after.key, before.technical.allowed_support_paths, after.technical.allowed_support_paths));
-        forbiddenPathsRemoved.push(...removedExactValues(after.key, before.technical.forbidden_paths, after.technical.forbidden_paths));
-        bindingsRemovedOrExpanded.push(...bindingReductions(before, after));
-        obligationsRemovedOrWeakened.push(...obligationReductions(before, after));
-        rollbackOrRecoveryWeakened.push(...rollbackReductions(before, after));
-        counterfactualsRemoved.push(...counterfactualReductions(before, after));
-        if (before.acceptance.population &&
-            (!after.acceptance.population ||
-                !same(before.acceptance.population, after.acceptance.population)))
-            populationWeakened.push(after.key);
-    }
     const riskChanged = previous.authority_hashes.risk_authority_hash !==
         nextHashes.risk_authority_hash;
     const acceptanceChanged = acceptanceSemanticsChanged(previous, next);
@@ -84,57 +30,64 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
     const externalConfirmationsChanged = externalConfirmationChanges.length > 0;
     const monotonic = isMonotonicAcceptanceStrengthening(previous, next);
     const reductionReasons = [
-        ...(productClaimsAdded.length ? ["product_claim_added"] : []),
-        ...(productClaimsRemoved.length ? ["product_claim_removed"] : []),
-        ...(productClaimsChanged.length ? ["product_claim_changed"] : []),
+        ...selectedRevisionReasons([
+            ["product_claim_added", productClaimsAdded],
+            ["product_claim_removed", productClaimsRemoved],
+            ["product_claim_changed", productClaimsChanged],
+        ]),
         ...materialDiff.reduction_reasons,
-        ...(checksRemoved.length ? ["check_removed"] : []),
-        ...(negativeAssertionsRemoved.length ? ["negative_assertion_removed"] : []),
-        ...(proofSurfacesChanged.length ? ["proof_surface_changed"] : []),
-        ...(sourceClaimsRemovedOrChanged.length
-            ? ["source_claim_removed_or_changed"]
-            : []),
-        ...(sourceClaimsAdded.length ? ["source_claim_added"] : []),
-        ...(sourcePathsRemovedOrReplaced.length
-            ? ["source_path_removed_or_replaced"]
-            : []),
-        ...(ownerPathsExpanded.length ? ["owner_path_expanded"] : []),
-        ...(ownerContextRefsRemoved.length ? ["owner_context_ref_removed"] : []),
-        ...(expectedChangePathsExpanded.length
-            ? ["expected_change_path_expanded"]
-            : []),
-        ...(allowedPathsExpanded.length ? ["allowed_path_expanded"] : []),
-        ...(forbiddenPathsRemoved.length ? ["forbidden_path_removed"] : []),
-        ...(runnerDefinitionsChanged.length ? ["runner_definition_changed"] : []),
-        ...(verificationInputsRemovedOrReplaced.length
-            ? ["verification_input_removed_or_replaced"]
-            : []),
-        ...(inputPathsRemovedOrNarrowed.length
-            ? ["input_path_coverage_reduced"]
-            : []),
-        ...(expectedOutputPathsRemovedOrWeakened.length
-            ? ["expected_output_requirement_weakened"]
-            : []),
-        ...(artifactsRemoved.length ? ["artifact_removed"] : []),
-        ...(environmentRequirementsRemoved.length
-            ? ["environment_requirement_removed"]
-            : []),
-        ...(bindingsRemovedOrExpanded.length
-            ? ["binding_removed_or_expanded"]
-            : []),
-        ...(obligationsRemovedOrWeakened.length
-            ? ["obligation_removed_or_weakened"]
-            : []),
-        ...(rollbackOrRecoveryWeakened.length
-            ? ["rollback_or_recovery_weakened"]
-            : []),
-        ...(counterfactualsRemoved.length ? ["counterfactual_removed"] : []),
-        ...(populationWeakened.length ? ["population_weakened"] : []),
-        ...(verifierDiff.verifier_content_changed
-            ? ["verifier_content_changed"]
-            : []),
-        ...(riskChanged ? ["risk_changed_requires_review"] : []),
-        ...(acceptanceChanged && !monotonic ? ["acceptance_not_monotonic"] : []),
+        ...selectedRevisionReasons([
+            ["check_removed", checksRemoved],
+            ["negative_assertion_removed", checkChanges.negative_assertions_removed],
+            ["proof_surface_changed", checkChanges.proof_surfaces_changed],
+            ["source_claim_removed_or_changed", sourceClaimsRemovedOrChanged],
+            ["source_claim_added", sourceClaimsAdded],
+            ["source_path_removed_or_replaced", sourcePathsRemovedOrReplaced],
+            ["owner_path_expanded", outcomeChanges.owner_paths_expanded],
+            ["owner_context_ref_removed", outcomeChanges.owner_context_refs_removed],
+            [
+                "expected_change_path_expanded",
+                outcomeChanges.expected_change_paths_expanded,
+            ],
+            ["allowed_path_expanded", outcomeChanges.allowed_paths_expanded],
+            ["forbidden_path_removed", outcomeChanges.forbidden_paths_removed],
+            ["runner_definition_changed", checkChanges.runner_definitions_changed],
+            [
+                "verification_input_removed_or_replaced",
+                checkChanges.verification_inputs_removed_or_replaced,
+            ],
+            [
+                "input_path_coverage_reduced",
+                checkChanges.input_paths_removed_or_narrowed,
+            ],
+            [
+                "expected_output_requirement_weakened",
+                checkChanges.expected_output_paths_removed_or_weakened,
+            ],
+            ["artifact_removed", checkChanges.artifacts_removed],
+            [
+                "environment_requirement_removed",
+                checkChanges.environment_requirements_removed,
+            ],
+            [
+                "binding_removed_or_expanded",
+                outcomeChanges.bindings_removed_or_expanded,
+            ],
+            [
+                "obligation_removed_or_weakened",
+                outcomeChanges.obligations_removed_or_weakened,
+            ],
+            [
+                "rollback_or_recovery_weakened",
+                outcomeChanges.rollback_or_recovery_weakened,
+            ],
+            ["counterfactual_removed", outcomeChanges.counterfactuals_removed],
+            ["population_weakened", outcomeChanges.population_weakened],
+            ["verifier_content_changed", verifierDiff.verifier_content_changed],
+            ["risk_changed_requires_review", riskChanged],
+            ["external_confirmation_changed", externalConfirmationsChanged],
+            ["acceptance_not_monotonic", acceptanceChanged && !monotonic],
+        ]),
     ];
     return {
         product_claims_added: productClaimsAdded,
@@ -144,8 +97,8 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         global_semantics_changed: materialDiff.global_semantics_changed,
         checks_added: addedValues(new Set(beforeChecks.keys()), new Set(afterChecks.keys())),
         checks_removed: checksRemoved,
-        negative_assertions_removed: negativeAssertionsRemoved,
-        proof_surfaces_changed: proofSurfacesChanged,
+        negative_assertions_removed: checkChanges.negative_assertions_removed,
+        proof_surfaces_changed: checkChanges.proof_surfaces_changed,
         source_claims_added: sourceClaimsAdded,
         source_claims_removed_or_changed: sourceClaimsRemovedOrChanged,
         source_paths_removed_or_replaced: sourcePathsRemovedOrReplaced,
@@ -157,60 +110,42 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         context_files_added: materialDiff.context_files_added,
         context_files_removed: materialDiff.context_files_removed,
         context_files_changed: materialDiff.context_files_changed,
-        owner_paths_expanded: ownerPathsExpanded,
-        owner_context_refs_removed: ownerContextRefsRemoved,
-        expected_change_paths_expanded: expectedChangePathsExpanded,
-        allowed_paths_expanded: allowedPathsExpanded,
-        forbidden_paths_removed: forbiddenPathsRemoved,
-        runner_definitions_changed: runnerDefinitionsChanged,
-        verification_inputs_added: verificationInputsAdded,
-        verification_inputs_removed_or_replaced: verificationInputsRemovedOrReplaced,
-        input_paths_added: inputPathsAdded,
-        input_paths_removed_or_narrowed: inputPathsRemovedOrNarrowed,
-        expected_output_paths_removed_or_weakened: expectedOutputPathsRemovedOrWeakened,
-        artifacts_removed: artifactsRemoved,
-        environment_requirements_removed: environmentRequirementsRemoved,
-        bindings_removed_or_expanded: bindingsRemovedOrExpanded,
-        obligations_removed_or_weakened: obligationsRemovedOrWeakened,
-        rollback_or_recovery_weakened: rollbackOrRecoveryWeakened,
-        counterfactuals_removed: counterfactualsRemoved,
-        population_weakened: populationWeakened,
+        owner_paths_expanded: outcomeChanges.owner_paths_expanded,
+        owner_context_refs_removed: outcomeChanges.owner_context_refs_removed,
+        expected_change_paths_expanded: outcomeChanges.expected_change_paths_expanded,
+        allowed_paths_expanded: outcomeChanges.allowed_paths_expanded,
+        forbidden_paths_removed: outcomeChanges.forbidden_paths_removed,
+        runner_definitions_changed: checkChanges.runner_definitions_changed,
+        verification_inputs_added: checkChanges.verification_inputs_added,
+        verification_inputs_removed_or_replaced: checkChanges.verification_inputs_removed_or_replaced,
+        input_paths_added: checkChanges.input_paths_added,
+        input_paths_removed_or_narrowed: checkChanges.input_paths_removed_or_narrowed,
+        expected_output_paths_removed_or_weakened: checkChanges.expected_output_paths_removed_or_weakened,
+        artifacts_removed: checkChanges.artifacts_removed,
+        environment_requirements_removed: checkChanges.environment_requirements_removed,
+        bindings_removed_or_expanded: outcomeChanges.bindings_removed_or_expanded,
+        obligations_removed_or_weakened: outcomeChanges.obligations_removed_or_weakened,
+        rollback_or_recovery_weakened: outcomeChanges.rollback_or_recovery_weakened,
+        counterfactuals_removed: outcomeChanges.counterfactuals_removed,
+        population_weakened: outcomeChanges.population_weakened,
         external_confirmations_changed: externalConfirmationsChanged,
         external_confirmation_changes: externalConfirmationChanges,
         ...verifierDiff,
         source_claims_changed: previous.authority_hashes.source_authority_hash !==
             nextHashes.source_authority_hash,
         risk_changed: riskChanged,
-        owner_or_path_boundary_changed: ownerPathsExpanded.length > 0 ||
-            ownerContextRefsRemoved.length > 0 ||
-            expectedChangePathsExpanded.length > 0 ||
-            allowedPathsExpanded.length > 0 ||
-            forbiddenPathsRemoved.length > 0 ||
-            bindingsRemovedOrExpanded.length > 0,
-        runner_or_verification_inputs_changed: runnerDefinitionsChanged.length > 0 ||
-            verificationInputsRemovedOrReplaced.length > 0 ||
-            inputPathsRemovedOrNarrowed.length > 0 ||
-            expectedOutputPathsRemovedOrWeakened.length > 0,
-        technical_obligations_changed: obligationsRemovedOrWeakened.length > 0 ||
-            rollbackOrRecoveryWeakened.length > 0,
+        owner_or_path_boundary_changed: outcomeChanges.owner_paths_expanded.length > 0 ||
+            outcomeChanges.owner_context_refs_removed.length > 0 ||
+            outcomeChanges.expected_change_paths_expanded.length > 0 ||
+            outcomeChanges.allowed_paths_expanded.length > 0 ||
+            outcomeChanges.forbidden_paths_removed.length > 0 ||
+            outcomeChanges.bindings_removed_or_expanded.length > 0,
+        runner_or_verification_inputs_changed: checkChanges.runner_definitions_changed.length > 0 ||
+            checkChanges.verification_inputs_removed_or_replaced.length > 0 ||
+            checkChanges.input_paths_removed_or_narrowed.length > 0 ||
+            checkChanges.expected_output_paths_removed_or_weakened.length > 0,
+        technical_obligations_changed: outcomeChanges.obligations_removed_or_weakened.length > 0 ||
+            outcomeChanges.rollback_or_recovery_weakened.length > 0,
         reduction_reasons: [...new Set(reductionReasons)],
     };
 }
-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();
-}

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

@@ -1,4 +1,5 @@
 import type { ProofSurface } from "./long-task-contract-types.js";
+import type { DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-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 {
@@ -10,6 +11,9 @@ export interface AuthorityHashesV2 {
 }
 export interface ProductSemanticProjectionV2 {
     task_goal: string;
+    target_profile: TargetProfileV2;
+    execution_targets: ExecutionTargetV2[];
+    stages: DeliveryStageV2[];
     global_non_goals: Array<{
         key: string;
         statement: string;
@@ -17,7 +21,10 @@ export interface ProductSemanticProjectionV2 {
     outcomes: Array<{
         key: string;
         title: string;
+        stage: string;
         observable_result: string;
+        success_path_required: boolean;
+        degradation_path_required: boolean;
         owner: {
             label: string;
             owner_surfaces: string[];
@@ -29,14 +36,28 @@ export interface ProductSemanticProjectionV2 {
         }>;
         controls: Array<{
             key: string;
+            surface: string;
+            region: string;
             location: string;
+            control_type: string;
+            label_content: string;
+            user_task: string;
+            visibility: string;
+            availability: string;
             trigger: string;
             input: string;
+            validation: string;
+            default_value: string;
+            interaction: string;
+            navigation_result: string;
             loading_state: string;
             empty_state: string;
             success_state: string;
             failure_state: string;
+            recovery: string;
+            permission: string;
             feedback: string;
+            accessibility: string;
         }>;
         non_completing_outcomes: Array<{
             key: string;

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

@@ -20,9 +20,13 @@ export function computeAuthorityHashes(contract) {
         }),
         product_authority_hash: hash({
             goal: contract.task.goal,
+            target_profile: contract.task.target_profile,
+            execution_targets: contract.task.execution_targets,
+            stages: contract.stages,
             global: contract.global.product,
             outcomes: contract.outcomes.map((outcome) => ({
                 key: outcome.key,
+                stage: outcome.stage,
                 product: outcome.product,
             })),
         }),
@@ -51,6 +55,7 @@ export function computeAuthorityHashes(contract) {
 }
 export function outcomeAuthorityHash(outcome) {
     return hash({
+        stage: outcome.stage,
         product: outcome.product,
         acceptance: {
             checks: outcome.acceptance.checks.map(acceptanceCheck),
@@ -73,7 +78,7 @@ export function acceptanceSemanticsChanged(previous, next) {
 export function isMonotonicAcceptanceStrengthening(previous, next) {
     if (!acceptanceSemanticsChanged(previous, next))
         return false;
-    if (!subset(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
+    if (!same(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
         !subset(previous.global.acceptance.counterfactual_controls ?? [], next.global.acceptance.counterfactual_controls) ||
         !checksStrengthened(previous.global.acceptance.checks, next.global.acceptance.checks))
         return false;
@@ -119,8 +124,32 @@ function checksStrengthened(previous, next) {
         const nextCheck = nextChecks.get(previousCheck.key);
         if (!nextCheck ||
             previousCheck.proof_surface !== nextCheck.proof_surface ||
-            !subset(previousCheck.positive_assertions, nextCheck.positive_assertions) ||
-            !subset(previousCheck.negative_assertions, nextCheck.negative_assertions))
+            !same(previousCheck.execution_target, nextCheck.execution_target) ||
+            !subset(previousCheck.journey_roles, nextCheck.journey_roles) ||
+            !subset(previousCheck.scenario.given, nextCheck.scenario.given) ||
+            !subset(previousCheck.scenario.when, nextCheck.scenario.when) ||
+            !subset(previousCheck.verification_inputs, nextCheck.verification_inputs) ||
+            !subset(previousCheck.input_paths, nextCheck.input_paths) ||
+            !subset(previousCheck.expected_output_paths, nextCheck.expected_output_paths) ||
+            !subset(previousCheck.artifact_globs, nextCheck.artifact_globs) ||
+            !subset(previousCheck.environment_requirements, nextCheck.environment_requirements) ||
+            !assertionsStrengthened(previousCheck.positive_assertions, nextCheck.positive_assertions) ||
+            !assertionsStrengthened(previousCheck.negative_assertions, nextCheck.negative_assertions))
+            return false;
+    }
+    return true;
+}
+function assertionsStrengthened(previous, next) {
+    const nextAssertions = new Map(next.map((assertion) => [assertion.key, assertion]));
+    for (const previousAssertion of previous) {
+        const nextAssertion = nextAssertions.get(previousAssertion.key);
+        if (!nextAssertion ||
+            previousAssertion.criterion !== nextAssertion.criterion ||
+            !same(previousAssertion.claims, nextAssertion.claims) ||
+            previousAssertion.observation !== nextAssertion.observation ||
+            previousAssertion.operator !== nextAssertion.operator ||
+            !same(previousAssertion.expected, nextAssertion.expected) ||
+            !subset(previousAssertion.evidence_capabilities, nextAssertion.evidence_capabilities))
             return false;
     }
     return true;

package/dist/lib/long-task-check-evidence-decoder.d.ts

@@ -1,3 +1,3 @@
 import type { CompiledCheckV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
-export declare function decodeCheckEvidence(check: CompiledCheckV2, exitCode: number, stdout: Buffer, stderr: Buffer): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "error">;
-export declare function invalidEvidence(exitCode: number, error: string): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "error">;
+export declare function decodeCheckEvidence(check: CompiledCheckV2, exitCode: number, stdout: Buffer, stderr: Buffer): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "evidence_records" | "error">;
+export declare function invalidEvidence(exitCode: number, error: string): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "evidence_records" | "error">;

package/dist/lib/long-task-check-evidence-decoder.js

@@ -1,4 +1,5 @@
 import { extractPlaywrightEvidence } from "./long-task-playwright-evidence.js";
+import { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-policy.js";
 export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
     if (check.runner.type === "playwright_test")
         return decodePlaywright(check, exitCode, stdout, stderr);
@@ -9,13 +10,15 @@ export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
         .filter(Boolean);
     try {
         const payload = JSON.parse(lines.at(-1) ?? "");
-        if (payload.schema_version !== "long-task-check-result-v2")
+        if (payload.schema_version !== "long-task-check-result-v2" &&
+            payload.schema_version !== "long-task-check-result-v3")
             return invalidEvidence(exitCode, "check_evidence_schema_invalid");
         if (payload.execution_status === "blocked_external")
             return {
                 execution_status: "blocked_external",
                 exit_code: exitCode,
                 observations: {},
+                evidence_records: [],
                 error: `blocked_external:${String(payload.reason ?? "unspecified")}`,
             };
         if (payload.execution_status !== "completed")
@@ -24,10 +27,14 @@ export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
             typeof payload.observations !== "object" ||
             Array.isArray(payload.observations))
             return invalidEvidence(exitCode, "check_evidence_observations_invalid");
+        const evidenceRecords = payload.schema_version === "long-task-check-result-v3"
+            ? decodeEvidenceCapabilityRecords(payload.evidence_records)
+            : [];
         return {
             execution_status: "completed",
             exit_code: exitCode,
             observations: payload.observations,
+            evidence_records: evidenceRecords,
             error: null,
         };
     }
@@ -40,6 +47,7 @@ export function invalidEvidence(exitCode, error) {
         execution_status: "invalid_evidence",
         exit_code: exitCode,
         observations: {},
+        evidence_records: [],
         error,
     };
 }
@@ -53,6 +61,7 @@ function decodePlaywright(check, exitCode, stdout, stderr) {
             execution_status: "completed",
             exit_code: exitCode,
             observations: extracted.observations,
+            evidence_records: extracted.evidence_records,
             error: null,
         };
     }
@@ -64,6 +73,7 @@ function decodePlaywright(check, exitCode, stdout, stderr) {
                 execution_status: "infrastructure_error",
                 exit_code: exitCode,
                 observations: {},
+                evidence_records: [],
                 error: `playwright_startup_failed:${message(error)}`,
             };
         return invalidEvidence(exitCode, `playwright_report_invalid:${message(error)}`);

package/dist/lib/long-task-check-execution-policy.d.ts

@@ -2,6 +2,9 @@ import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
 export type CheckExecutionInputPolicy = "raw_execution" | "raw_execution_via_runner_freeze" | "per_check_evidence" | "progress_scope" | "final_gate_evidence" | "authority_metadata";
 export declare const CHECK_EXECUTION_INPUT_POLICY: {
     key: "authority_metadata";
+    journey_roles: "authority_metadata";
+    execution_target: "raw_execution";
+    scenario: "per_check_evidence";
     proof_surface: "authority_metadata";
     runner: "raw_execution";
     verification_inputs: "raw_execution_via_runner_freeze";

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

@@ -1,6 +1,9 @@
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export const CHECK_EXECUTION_INPUT_POLICY = {
     key: "authority_metadata",
+    journey_roles: "authority_metadata",
+    execution_target: "raw_execution",
+    scenario: "per_check_evidence",
     proof_surface: "authority_metadata",
     runner: "raw_execution",
     verification_inputs: "raw_execution_via_runner_freeze",
@@ -14,6 +17,8 @@ export const CHECK_EXECUTION_INPUT_POLICY = {
 export function rawExecutionInputProjection(check) {
     const projection = {};
     projection.evidence_adapter = check.evidence_adapter;
+    projection.execution_target_definition = check.execution_target_definition;
+    projection.known_execution_targets = check.known_execution_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-check-runner.js

@@ -17,6 +17,7 @@ export async function executeCheckRunner(check, snapshotRoot) {
             execution_status: "blocked_external",
             exit_code: -1,
             observations: {},
+            evidence_records: [],
             stdout_sha256: sha256Hex(""),
             stderr_sha256: sha256Hex(""),
             attempts: 0,
@@ -55,6 +56,7 @@ export async function executeCheckRunner(check, snapshotRoot) {
                 execution_status: "infrastructure_error",
                 exit_code: -1,
                 observations: {},
+                evidence_records: [],
                 stdout_sha256: sha256Hex(""),
                 stderr_sha256: sha256Hex(reason),
                 attempts: attempt,