project-tiny-context-harness 0.7.3 → 0.7.4

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[];

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,

package/dist/lib/long-task-check-shape.js

@@ -1,6 +1,14 @@
-import { array, fail, key, literal, object, parseEnvironmentRequirements, PROOF_SURFACES, repositoryCwd, repositoryFile, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
+import { array, EVIDENCE_CAPABILITIES, fail, key, JOURNEY_ROLES, literal, object, parseEnvironmentRequirements, PROOF_SURFACES, repositoryCwd, repositoryFile, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
 export function parseCheck(value, label) {
-    const row = object(value, label, ["key", "proof_surface", "runner", "verification_inputs"], [
+    const row = object(value, label, [
+        "key",
+        "journey_roles",
+        "execution_target",
+        "scenario",
+        "proof_surface",
+        "runner",
+        "verification_inputs",
+    ], [
         "input_paths",
         "expected_output_paths",
         "artifact_globs",
@@ -8,8 +16,19 @@ export function parseCheck(value, label) {
         "negative_assertions",
         "environment_requirements",
     ]);
+    const executionTarget = object(row.execution_target, `${label}.execution_target`, ["target_ref", "entrypoint"]);
+    const scenario = object(row.scenario, `${label}.scenario`, ["given", "when"]);
     return {
         key: key(row.key, `${label}.key`),
+        journey_roles: array(row.journey_roles, `${label}.journey_roles`).map((item, index) => literal(item, JOURNEY_ROLES, `${label}.journey_roles[${index}]`)),
+        execution_target: {
+            target_ref: key(executionTarget.target_ref, `${label}.execution_target.target_ref`),
+            entrypoint: literal(executionTarget.entrypoint, ["root", "internal"], `${label}.execution_target.entrypoint`),
+        },
+        scenario: {
+            given: parseScenarioSteps(scenario.given, `${label}.scenario.given`),
+            when: parseScenarioSteps(scenario.when, `${label}.scenario.when`),
+        },
         proof_surface: literal(row.proof_surface, PROOF_SURFACES, `${label}.proof_surface`),
         runner: parseRunner(row.runner, `${label}.runner`),
         verification_inputs: repositoryPatterns(row.verification_inputs, `${label}.verification_inputs`),
@@ -70,7 +89,7 @@ function parseRunner(value, label) {
 function parseAssertions(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "claims", "observation", "operator"], ["criterion", "expected"]);
+        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "expected"]);
         const operator = literal(row.operator, [
             "equals",
             "not_equals",
@@ -103,6 +122,7 @@ function parseAssertions(value, label) {
                 : {}),
             claims: strings(row.claims, `${itemLabel}.claims`),
             observation: string(row.observation, `${itemLabel}.observation`),
+            evidence_capabilities: array(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
             operator,
         };
         return isBinaryAssertionOperator(operator)
@@ -113,6 +133,16 @@ function parseAssertions(value, label) {
             };
     });
 }
+function parseScenarioSteps(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, ["key", "statement"]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            statement: string(row.statement, `${itemLabel}.statement`),
+        };
+    });
+}
 function isBinaryAssertionOperator(operator) {
     return !["exists", "truthy", "falsy"].includes(operator);
 }

package/dist/lib/long-task-conformance-policy.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledCheckV2, DeliveryContractV2, EffectiveRiskLevel } from "./long-task-delivery-types.js";
+type Reporter = (message: string) => void;
+export declare function semanticConformanceRequired(contract: DeliveryContractV2, _effectiveRisk?: EffectiveRiskLevel): boolean;
+export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter): void;
+export {};

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

@@ -0,0 +1,35 @@
+export function semanticConformanceRequired(contract, _effectiveRisk) {
+    const productFamilies = new Set(contract.task.execution_targets
+        .filter((target) => contract.task.target_profile.required_target_refs.includes(target.key))
+        .map((target) => target.runtime_family));
+    return (contract.risk.facts.weak_observability.length > 0 &&
+        (productFamilies.size > 1 || contract.stages.length > 1));
+}
+export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
+    const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
+    if (semanticConformanceRequired(contract, effectiveRisk) &&
+        !declared.length) {
+        issue(report, "semantic_conformance_check_required", contract.task.id);
+        return;
+    }
+    for (const check of declared) {
+        if (check.runner.effect !== "read_only")
+            issue(report, "conformance_check_must_be_read_only", check.key);
+        if (![...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime")))
+            issue(report, "conformance_target_runtime_evidence_required", check.key);
+        const compiled = compiledChecks.find((candidate) => candidate.outcome_key === null && candidate.key === check.key);
+        if (!compiled)
+            continue;
+        if (compiledChecks.some((candidate) => candidate.internal_id !== compiled.internal_id &&
+            candidate.outcome_key !== null &&
+            candidate.raw_execution_identity === compiled.raw_execution_identity))
+            issue(report, "conformance_raw_execution_must_be_independent", check.key);
+    }
+}
+function issue(report, code, detail) {
+    const message = `delivery_contract_invalid:${code}:${detail}`;
+    if (report)
+        report(message);
+    else
+        throw new Error(message);
+}