project-tiny-context-harness 0.8.0 → 0.8.2

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

@@ -18,6 +18,12 @@ const RISK_AUTHORITY_POLICY = {
     requested_level: "semantic_user_review",
     facts: "semantic_user_review",
 };
+const GLOBAL_AUTHORITY_POLICY = {
+    applicability: "semantic_user_review",
+    product: "semantic_user_review",
+    technical: "semantic_user_review",
+    acceptance: "proof_additive",
+};
 const GLOBAL_PRODUCT_AUTHORITY_POLICY = {
     non_goals: "semantic_user_review",
 };
@@ -36,18 +42,35 @@ const OUTCOME_AUTHORITY_POLICY = {
     title: "descriptive_non_authoritative",
     stage: "semantic_user_review",
     depends_on: "readiness_only",
+    applicability: "semantic_user_review",
     product: "semantic_user_review",
     technical: "semantic_user_review",
     acceptance: "proof_additive",
 };
+const CLAIM_APPLICABILITY_AUTHORITY_POLICY = {
+    key: "identity",
+    target_ref: "semantic_user_review",
+    journey_role: "semantic_user_review",
+    dimensions: "semantic_user_review",
+    given_refs: "semantic_user_review",
+    when_refs: "semantic_user_review",
+};
+const APPLICABLE_STATEMENT_AUTHORITY_POLICY = {
+    key: "identity",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+};
 const OUTCOME_PRODUCT_AUTHORITY_POLICY = {
     observable_result: "semantic_user_review",
+    result_applicability_refs: "semantic_user_review",
     success_path_required: "semantic_user_review",
     degradation_path_required: "semantic_user_review",
     owner: "semantic_user_review",
     requirements: "semantic_user_review",
     owner_surfaces: "semantic_user_review",
     controls: "semantic_user_review",
+    control_relation_closure: "semantic_user_review",
+    control_relations: "semantic_user_review",
     surface_bindings: "semantic_user_review",
     non_completing_outcomes: "semantic_user_review",
 };
@@ -55,6 +78,7 @@ const REQUIREMENT_AUTHORITY_POLICY = {
     key: "identity",
     statement: "semantic_user_review",
     required_proof_surfaces: "proof_additive",
+    applicability_refs: "semantic_user_review",
 };
 const OWNER_AUTHORITY_POLICY = {
     label: "identity",
@@ -85,6 +109,25 @@ const CONTROL_AUTHORITY_POLICY = {
     permission: "semantic_user_review",
     feedback: "semantic_user_review",
     accessibility: "semantic_user_review",
+    field_coverage: "semantic_user_review",
+};
+const CONTROL_FIELD_COVERAGE_AUTHORITY_POLICY = {
+    fields: "semantic_user_review",
+    state: "semantic_user_review",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+};
+const CONTROL_RELATION_CLOSURE_AUTHORITY_POLICY = {
+    state: "semantic_user_review",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+};
+const CONTROL_RELATION_AUTHORITY_POLICY = {
+    key: "identity",
+    statement: "semantic_user_review",
+    applicability_refs: "semantic_user_review",
+    control_refs: "semantic_user_review",
+    required_proof_surfaces: "proof_additive",
 };
 const SURFACE_BINDING_AUTHORITY_POLICY = {
     key: "identity",
@@ -110,12 +153,18 @@ const DESIGN_TARGET_AUTHORITY_POLICY = {
     actual_artifact_path: "output_requirement",
     comparison_artifact_path: "output_requirement",
 };
+const DESIGN_VERIFICATION_BINDING_AUTHORITY_POLICY = {
+    method: "proof_additive",
+    assertion_ref: "proof_additive",
+    evidence_artifacts: "output_requirement",
+};
 const DESIGN_BLOCKER_AUTHORITY_POLICY = {
     key: "identity",
     status: "semantic_user_review",
     refs: "semantic_user_review",
     source_item_refs: "semantic_user_review",
     verification_methods: "proof_additive",
+    required_capabilities: "semantic_user_review",
     rationale: "semantic_user_review",
 };
 const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
@@ -131,6 +180,7 @@ const OBLIGATION_AUTHORITY_POLICY = {
     key: "identity",
     statement: "semantic_user_review",
     required_proof_surfaces: "proof_additive",
+    applicability_refs: "semantic_user_review",
 };
 const BINDING_AUTHORITY_POLICY = {
     key: "identity",
@@ -169,6 +219,7 @@ const ASSERTION_AUTHORITY_POLICY = {
     key: "identity",
     criterion: "semantic_user_review",
     claims: "proof_additive",
+    applicability_ref: "proof_additive",
     observation: "proof_additive",
     evidence_capabilities: "proof_additive",
     operator: "proof_additive",
@@ -186,6 +237,7 @@ const RUNNER_AUTHORITY_POLICY = {
 };
 const POPULATION_AUTHORITY_POLICY = {
     check_key: "proof_additive",
+    universe_binding_key: "proof_additive",
     claims: "proof_additive",
     observations: "proof_additive",
     exclusion_rules: "proof_additive",
@@ -197,6 +249,7 @@ const COUNTERFACTUAL_AUTHORITY_POLICY = {
     check_key: "proof_additive",
     mutation: "proof_additive",
     expected_assertion_failures: "proof_additive",
+    preserved_assertions: "proof_additive",
 };
 const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
     key: "identity",
@@ -205,21 +258,29 @@ const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
     check_key: "proof_additive",
     mutation: "proof_additive",
     expected_assertion_failures: "proof_additive",
+    preserved_assertions: "proof_additive",
 };
 export const AUTHORITY_FIELD_POLICY_REGISTRIES = {
     task: TASK_AUTHORITY_POLICY,
     source_claim: SOURCE_CLAIM_AUTHORITY_POLICY,
     risk: RISK_AUTHORITY_POLICY,
+    global: GLOBAL_AUTHORITY_POLICY,
     global_product: GLOBAL_PRODUCT_AUTHORITY_POLICY,
     global_technical: GLOBAL_TECHNICAL_AUTHORITY_POLICY,
     global_acceptance: GLOBAL_ACCEPTANCE_AUTHORITY_POLICY,
     outcome: OUTCOME_AUTHORITY_POLICY,
+    claim_applicability: CLAIM_APPLICABILITY_AUTHORITY_POLICY,
+    applicable_statement: APPLICABLE_STATEMENT_AUTHORITY_POLICY,
     outcome_product: OUTCOME_PRODUCT_AUTHORITY_POLICY,
     requirement: REQUIREMENT_AUTHORITY_POLICY,
     owner: OWNER_AUTHORITY_POLICY,
     control: CONTROL_AUTHORITY_POLICY,
+    control_field_coverage: CONTROL_FIELD_COVERAGE_AUTHORITY_POLICY,
+    control_relation_closure: CONTROL_RELATION_CLOSURE_AUTHORITY_POLICY,
+    control_relation: CONTROL_RELATION_AUTHORITY_POLICY,
     surface_binding: SURFACE_BINDING_AUTHORITY_POLICY,
     design_target: DESIGN_TARGET_AUTHORITY_POLICY,
+    design_verification_binding: DESIGN_VERIFICATION_BINDING_AUTHORITY_POLICY,
     design_blocker: DESIGN_BLOCKER_AUTHORITY_POLICY,
     outcome_technical: OUTCOME_TECHNICAL_AUTHORITY_POLICY,
     obligation: OBLIGATION_AUTHORITY_POLICY,

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

@@ -1,5 +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 { DeliveryControlV2, DeliveryOutcomeV2, ProofSurface } from "./long-task-contract-types.js";
+import type { ClaimApplicabilityV2, DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
@@ -18,12 +18,15 @@ export interface ProductSemanticProjectionV2 {
     global_non_goals: Array<{
         key: string;
         statement: string;
+        applicability_refs: string[];
     }>;
     outcomes: Array<{
         key: string;
         title: string;
         stage: string;
+        applicability: ClaimApplicabilityV2[];
         observable_result: string;
+        result_applicability_refs: string[];
         success_path_required: boolean;
         degradation_path_required: boolean;
         owner: {
@@ -34,6 +37,7 @@ export interface ProductSemanticProjectionV2 {
             key: string;
             statement: string;
             required_proof_surfaces: ProofSurface[];
+            applicability_refs: string[];
         }>;
         controls: Array<{
             key: string;
@@ -59,7 +63,10 @@ export interface ProductSemanticProjectionV2 {
             permission: string;
             feedback: string;
             accessibility: string;
+            field_coverage: DeliveryControlV2["field_coverage"];
         }>;
+        control_relation_closure: DeliveryOutcomeV2["product"]["control_relation_closure"];
+        control_relations: DeliveryOutcomeV2["product"]["control_relations"];
         surface_bindings: DeliverySurfaceBindingV2[];
         non_completing_outcomes: Array<{
             key: string;
@@ -68,13 +75,16 @@ export interface ProductSemanticProjectionV2 {
     }>;
 }
 export interface GlobalSemanticProjectionV2 {
+    applicability: ClaimApplicabilityV2[];
     constraints: Array<{
         key: string;
         statement: string;
+        applicability_refs: string[];
     }>;
     forbidden_shortcuts: Array<{
         key: string;
         statement: string;
+        applicability_refs: string[];
     }>;
 }
 export interface ContextAuthoritySnapshotV2 {

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

@@ -23,10 +23,14 @@ export function computeAuthorityHashes(contract) {
             target_profile: contract.task.target_profile,
             execution_targets: contract.task.execution_targets,
             stages: contract.stages,
-            global: contract.global.product,
+            global: {
+                applicability: contract.global.applicability,
+                product: contract.global.product,
+            },
             outcomes: contract.outcomes.map((outcome) => ({
                 key: outcome.key,
                 stage: outcome.stage,
+                applicability: outcome.applicability,
                 product: outcome.product,
             })),
         }),
@@ -56,6 +60,7 @@ export function computeAuthorityHashes(contract) {
 export function outcomeAuthorityHash(outcome) {
     return hash({
         stage: outcome.stage,
+        applicability: outcome.applicability,
         product: outcome.product,
         acceptance: {
             checks: outcome.acceptance.checks.map(acceptanceCheck),
@@ -146,6 +151,7 @@ function assertionsStrengthened(previous, next) {
         if (!nextAssertion ||
             previousAssertion.criterion !== nextAssertion.criterion ||
             !same(previousAssertion.claims, nextAssertion.claims) ||
+            previousAssertion.applicability_ref !== nextAssertion.applicability_ref ||
             previousAssertion.observation !== nextAssertion.observation ||
             previousAssertion.operator !== nextAssertion.operator ||
             !same(previousAssertion.expected, nextAssertion.expected) ||
@@ -160,7 +166,8 @@ function counterfactualsStrengthened(previous, next) {
         candidate.check_key === control.check_key &&
         same(candidate.mutation, control.mutation) &&
         subset(control.claims, candidate.claims) &&
-        subset(control.expected_assertion_failures, candidate.expected_assertion_failures)));
+        subset(control.expected_assertion_failures, candidate.expected_assertion_failures) &&
+        subset(control.preserved_assertions, candidate.preserved_assertions)));
 }
 function subset(previous, next) {
     const available = new Set(next.map((item) => canonicalValueJson(item)));

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

@@ -89,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", "evidence_capabilities"], ["criterion", "expected"]);
+        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "applicability_ref", "expected"]);
         const operator = literal(row.operator, [
             "equals",
             "not_equals",
@@ -121,6 +121,11 @@ function parseAssertions(value, label) {
                 ? { criterion: string(row.criterion, `${itemLabel}.criterion`) }
                 : {}),
             claims: strings(row.claims, `${itemLabel}.claims`),
+            ...(Object.hasOwn(row, "applicability_ref")
+                ? {
+                    applicability_ref: key(row.applicability_ref, `${itemLabel}.applicability_ref`),
+                }
+                : {}),
             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,

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

@@ -1,61 +1,43 @@
+import { controlFieldFacts } from "./long-task-control-fields.js";
 import { fail } from "./long-task-delivery-shape.js";
 export function generateClaims(outcome) {
-    const claims = [claim(outcome.key, "result", "result")];
+    const claims = [
+        claim(outcome.key, "result", "result", [], outcome.product.result_applicability_refs),
+    ];
     for (const requirement of outcome.product.requirements)
-        claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces));
+        claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces, requirement.applicability_refs));
     for (const control of outcome.product.controls) {
-        const fields = [
-            ["surface", control.surface],
-            ["region", control.region],
-            ["location", control.location],
-            ["control_type", control.control_type],
-            ["label_content", control.label_content],
-            ["user_task", control.user_task],
-            ["visibility", control.visibility],
-            ["availability", control.availability],
-            ["trigger", control.trigger],
-            ["input", control.input],
-            ["validation", control.validation],
-            ["default_value", control.default_value],
-            ["interaction", control.interaction],
-            ["navigation_result", control.navigation_result],
-            ["loading", control.loading_state],
-            ["empty", control.empty_state],
-            ["success", control.success_state],
-            ["failure", control.failure_state],
-            ["recovery", control.recovery],
-            ["permission", control.permission],
-            ["feedback", control.feedback],
-            ["accessibility", control.accessibility],
-        ];
-        for (const [field, value] of fields)
-            if (value.trim())
-                claims.push(claim(outcome.key, `control.${control.key}.${field}`, "control"));
+        for (const field of controlFieldFacts(control))
+            claims.push(claim(outcome.key, `control.${control.key}.${field.claim_field}`, "control", [], field.applicability_refs, field.state === "not_applicable" ? "negative" : "positive"));
     }
+    if (outcome.product.control_relation_closure.state !== "unresolved")
+        claims.push(claim(outcome.key, "control_relation_closure", "control_relation", [], outcome.product.control_relation_closure.applicability_refs, outcome.product.control_relation_closure.state === "not_applicable"
+            ? "negative"
+            : "positive"));
+    for (const relation of outcome.product.control_relations)
+        claims.push(claim(outcome.key, `control_relation.${relation.key}`, "control_relation", relation.required_proof_surfaces, relation.applicability_refs));
     for (const item of outcome.product.non_completing_outcomes)
-        claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing"));
+        claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing", [], item.applicability_refs, "negative"));
     for (const item of outcome.technical.obligations)
-        claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces));
+        claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces, item.applicability_refs));
     for (const item of outcome.technical.forbidden_shortcuts)
-        claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut"));
+        claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut", [], item.applicability_refs, "negative"));
     return claims;
 }
 export function generateGlobalClaims(global) {
     return [
-        ...global.product.non_goals.map((item) => globalClaim(`non_goal.${item.key}`, "global_non_goal", "negative")),
-        ...global.technical.constraints.map((item) => globalClaim(`constraint.${item.key}`, "global_constraint", "any")),
-        ...global.technical.forbidden_shortcuts.map((item) => globalClaim(`forbidden_shortcut.${item.key}`, "global_forbidden_shortcut", "negative")),
+        ...global.product.non_goals.map((item) => globalClaim(`non_goal.${item.key}`, "global_non_goal", "negative", item.applicability_refs)),
+        ...global.technical.constraints.map((item) => globalClaim(`constraint.${item.key}`, "global_constraint", "positive", item.applicability_refs)),
+        ...global.technical.forbidden_shortcuts.map((item) => globalClaim(`forbidden_shortcut.${item.key}`, "global_forbidden_shortcut", "negative", item.applicability_refs)),
     ].sort((left, right) => left.id.localeCompare(right.id));
 }
 export function validateGlobalProofPolarity(claim, proof) {
-    if (claim.required_polarity === "negative" && proof.polarity !== "negative")
+    if (proof.polarity !== claim.required_polarity)
         fail("global_negative_claim_proof_required", `${claim.local_key}:${proof.check_key}`);
 }
 export function validateProofSurface(claim, proof, outcomeKey) {
-    if ((claim.kind === "non_completing" || claim.kind === "forbidden_shortcut") &&
-        proof.polarity !== "negative" &&
-        proof.polarity !== "counterfactual")
-        fail("negative_or_counterfactual_claim_proof_required", `${outcomeKey}:${claim.local_key}`);
+    if (proof.polarity !== claim.required_polarity)
+        fail("claim_proof_polarity_mismatch", `${outcomeKey}:${claim.local_key}:${proof.polarity}:${claim.required_polarity}`);
     if ((claim.kind === "requirement" || claim.kind === "obligation") &&
         claim.required_proof_surfaces.length > 0 &&
         !claim.required_proof_surfaces.includes(proof.proof_surface))
@@ -69,20 +51,23 @@ export function assertAllGlobalClaimsCovered(uncovered) {
     if (uncovered.length)
         fail("global_claim_uncovered", uncovered.sort().join(","));
 }
-function claim(outcomeKey, localKey, kind, requiredProofSurfaces = []) {
+function claim(outcomeKey, localKey, kind, requiredProofSurfaces = [], applicabilityRefs = [], requiredPolarity = "positive") {
     return {
         id: `${outcomeKey}.${localKey}`,
         outcome_key: outcomeKey,
         local_key: localKey,
         kind,
         required_proof_surfaces: requiredProofSurfaces,
+        required_polarity: requiredPolarity,
+        applicability_refs: applicabilityRefs,
     };
 }
-function globalClaim(localKey, kind, requiredPolarity) {
+function globalClaim(localKey, kind, requiredPolarity, applicabilityRefs) {
     return {
         id: `GLOBAL.${localKey}`,
         local_key: localKey,
         kind,
         required_polarity: requiredPolarity,
+        applicability_refs: applicabilityRefs,
     };
 }