project-tiny-context-harness 0.8.0 → 0.8.2

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

@@ -10,25 +10,32 @@ export function parseCounterfactuals(value, label) {
             "check_key",
             "mutation",
             "expected_assertion_failures",
+        ], ["preserved_assertions"]);
+        const mutation = object(row.mutation, `${itemLabel}.mutation`, ["type"], [
+            "paths",
+            "path",
+            "fixture_path",
+            "pointer",
+            "value",
+            "match",
+            "replacement",
         ]);
-        const mutation = object(row.mutation, `${itemLabel}.mutation`, ["type"], ["paths", "path", "fixture_path"]);
-        const type = literal(mutation.type, ["remove_paths", "replace_file"], `${itemLabel}.mutation.type`);
+        const type = literal(mutation.type, [
+            "remove_paths",
+            "replace_file",
+            "replace_json_value",
+            "replace_text",
+        ], `${itemLabel}.mutation.type`);
         return {
             key: key(row.key, `${itemLabel}.key`),
             binding_key: key(row.binding_key, `${itemLabel}.binding_key`),
             claims: strings(row.claims, `${itemLabel}.claims`),
             check_key: key(row.check_key, `${itemLabel}.check_key`),
-            mutation: type === "remove_paths"
-                ? {
-                    type,
-                    paths: repositoryFiles(mutation.paths, `${itemLabel}.mutation.paths`),
-                }
-                : {
-                    type,
-                    path: repositoryFile(mutation.path, `${itemLabel}.mutation.path`),
-                    fixture_path: repositoryFile(mutation.fixture_path, `${itemLabel}.mutation.fixture_path`),
-                },
+            mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
             expected_assertion_failures: strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((item, assertionIndex) => key(item, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`)),
+            preserved_assertions: Object.hasOwn(row, "preserved_assertions")
+                ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
+                : [],
         };
     });
 }
@@ -42,7 +49,7 @@ export function parseGlobalCounterfactuals(value, label) {
             "check_key",
             "mutation",
             "expected_assertion_failures",
-        ]);
+        ], ["preserved_assertions"]);
         const bindingRef = string(row.binding_ref, `${itemLabel}.binding_ref`);
         if (!/^[a-z0-9][a-z0-9-]*\.[a-z0-9][a-z0-9-]*$/u.test(bindingRef))
             fail(`${itemLabel}.binding_ref`, "must be <outcome-key>.<binding-key>");
@@ -59,39 +66,93 @@ export function parseGlobalCounterfactuals(value, label) {
             check_key: key(row.check_key, `${itemLabel}.check_key`),
             mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
             expected_assertion_failures: failures,
+            preserved_assertions: Object.hasOwn(row, "preserved_assertions")
+                ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
+                : [],
         };
     });
 }
 function parseCounterfactualMutation(value, label) {
-    const mutation = object(value, label, ["type"], ["paths", "path", "fixture_path"]);
-    const type = literal(mutation.type, ["remove_paths", "replace_file"], `${label}.type`);
-    return type === "remove_paths"
-        ? {
+    const mutation = object(value, label, ["type"], [
+        "paths",
+        "path",
+        "fixture_path",
+        "pointer",
+        "value",
+        "match",
+        "replacement",
+    ]);
+    const type = literal(mutation.type, [
+        "remove_paths",
+        "replace_file",
+        "replace_json_value",
+        "replace_text",
+    ], `${label}.type`);
+    if (type === "remove_paths")
+        return {
             type,
             paths: repositoryFiles(mutation.paths, `${label}.paths`),
-        }
-        : {
+        };
+    const target = repositoryFile(mutation.path, `${label}.path`);
+    if (type === "replace_file")
+        return {
             type,
-            path: repositoryFile(mutation.path, `${label}.path`),
+            path: target,
             fixture_path: repositoryFile(mutation.fixture_path, `${label}.fixture_path`),
         };
+    if (type === "replace_json_value") {
+        const pointer = string(mutation.pointer, `${label}.pointer`);
+        if (!/^\/(?:[^~/]|~[01])+(?:\/(?:[^~/]|~[01])+)*$/u.test(pointer))
+            fail(`${label}.pointer`, "must be a non-root RFC 6901 JSON pointer");
+        if (!Object.hasOwn(mutation, "value"))
+            fail(`${label}.value`, "must be present");
+        assertJsonValue(mutation.value, `${label}.value`);
+        return { type, path: target, pointer, value: mutation.value };
+    }
+    const match = string(mutation.match, `${label}.match`);
+    const replacement = typeof mutation.replacement === "string"
+        ? mutation.replacement
+        : fail(`${label}.replacement`, "must be a string");
+    if (match === replacement)
+        fail(`${label}.replacement`, "must differ from match");
+    return { type, path: target, match, replacement };
+}
+function assertJsonValue(value, label) {
+    if (value === undefined ||
+        typeof value === "function" ||
+        typeof value === "symbol" ||
+        typeof value === "bigint")
+        fail(label, "must be JSON-compatible");
+    try {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined)
+            fail(label, "must be JSON-compatible");
+        JSON.parse(encoded);
+    }
+    catch {
+        fail(label, "must be JSON-compatible");
+    }
 }
 export function parsePopulation(value, label) {
     const row = object(value, label, [
         "check_key",
+        "universe_binding_key",
         "claims",
         "observations",
         "exclusion_rules",
     ]);
     const observations = object(row.observations, `${label}.observations`, [
+        "universe_ids",
         "eligible_ids",
         "observed_ids",
         "excluded_items",
     ]);
     return {
         check_key: key(row.check_key, `${label}.check_key`),
+        universe_binding_key: key(row.universe_binding_key, `${label}.universe_binding_key`),
         claims: strings(row.claims, `${label}.claims`),
         observations: {
+            universe_ids: string(observations.universe_ids, `${label}.observations.universe_ids`),
             eligible_ids: string(observations.eligible_ids, `${label}.observations.eligible_ids`),
             observed_ids: string(observations.observed_ids, `${label}.observations.observed_ids`),
             excluded_items: string(observations.excluded_items, `${label}.observations.excluded_items`),

package/dist/lib/long-task-applicability-shape.d.ts

@@ -0,0 +1,4 @@
+import type { ApplicableKeyedStatementV2, ClaimApplicabilityV2 } from "./long-task-semantic-contract-types.js";
+export declare function parseClaimApplicability(value: unknown, label: string): ClaimApplicabilityV2[];
+export declare function parseApplicableKeyedStatements(value: unknown, label: string): ApplicableKeyedStatementV2[];
+export declare function parseKeyRefs(value: unknown, label: string): string[];

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

@@ -0,0 +1,54 @@
+import { array, key, literal, object, string, strings, } from "./long-task-shape-primitives.js";
+const JOURNEY_ROLES = [
+    "success",
+    "degradation",
+    "recovery",
+    "stage_gate",
+    "conformance",
+];
+export function parseClaimApplicability(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "target_ref",
+            "journey_role",
+            "dimensions",
+            "given_refs",
+            "when_refs",
+        ]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            target_ref: key(row.target_ref, `${itemLabel}.target_ref`),
+            journey_role: literal(row.journey_role, JOURNEY_ROLES, `${itemLabel}.journey_role`),
+            dimensions: array(row.dimensions, `${itemLabel}.dimensions`).map((dimension, dimensionIndex) => {
+                const dimensionLabel = `${itemLabel}.dimensions[${dimensionIndex}]`;
+                const entry = object(dimension, dimensionLabel, ["key", "value"]);
+                return {
+                    key: key(entry.key, `${dimensionLabel}.key`),
+                    value: key(entry.value, `${dimensionLabel}.value`),
+                };
+            }),
+            given_refs: parseKeyRefs(row.given_refs, `${itemLabel}.given_refs`),
+            when_refs: parseKeyRefs(row.when_refs, `${itemLabel}.when_refs`),
+        };
+    });
+}
+export function parseApplicableKeyedStatements(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "statement",
+            "applicability_refs",
+        ]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            statement: string(row.statement, `${itemLabel}.statement`),
+            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
+        };
+    });
+}
+export function parseKeyRefs(value, label) {
+    return strings(value, label).map((item, index) => key(item, `${label}[${index}]`));
+}

package/dist/lib/long-task-assertions-v2.js

@@ -77,14 +77,18 @@ export function evaluateDeliveryAssertionDetailed(assertion, observations) {
     return result(comparison.passed, expected, value);
 }
 export function evaluatePopulation(requirement, observations) {
+    const universe = observationValue(observations, requirement.observations.universe_ids).value;
     const eligible = observationValue(observations, requirement.observations.eligible_ids).value;
     const observed = observationValue(observations, requirement.observations.observed_ids).value;
     const excluded = observationValue(observations, requirement.observations.excluded_items).value;
     const actual = {
+        universe_ids: universe,
         eligible_ids: eligible,
         observed_ids: observed,
         excluded_items: excluded,
     };
+    if (!validIds(universe))
+        return failure(actual, "universe_ids_invalid");
     if (!validIds(eligible))
         return failure(actual, "eligible_ids_invalid");
     if (!validIds(observed))
@@ -92,6 +96,10 @@ export function evaluatePopulation(requirement, observations) {
     if (!Array.isArray(excluded))
         return failure(actual, "excluded_items_invalid");
     const eligibleSet = new Set(eligible);
+    const universeSet = new Set(universe);
+    if (universeSet.size !== eligibleSet.size ||
+        [...universeSet].some((id) => !eligibleSet.has(id)))
+        return failure(actual, "eligible_universe_mismatch");
     const observedSet = new Set(observed);
     const excludedIds = [];
     const rules = new Set(requirement.exclusion_rules.map((item) => item.key));

package/dist/lib/long-task-authoring-preflight-diagnostics.js

@@ -147,6 +147,10 @@ function diagnosticRefs(code, message) {
         case "global_claim_uncovered":
         case "source_claim_decision_required":
             return payload.flatMap((value) => value.split(",")).filter(Boolean);
+        case "product_claim_required_surfaces_missing":
+            return payload.length >= 2
+                ? [`${payload[0]}.${payload[1]}`, ...payload.slice(2)]
+                : payload;
         case "assertion_criterion_required":
             return payload.length ? [payload.join(":")] : [];
         default:
@@ -166,6 +170,7 @@ function diagnosticRepairHint(code) {
         case "forbidden_shortcut_key_duplicate":
             return "Remove an accidental duplicate or assign distinct stable keys while preserving each distinct semantic item.";
         case "product_claim_uncovered":
+        case "product_claim_required_surfaces_missing":
         case "global_claim_uncovered":
             return "Add claim-bearing Assertion coverage for every required proof surface or correct the Claim mapping; do not weaken or delete the uncovered Claim.";
         case "assertion_criterion_required":

package/dist/lib/long-task-authoring-preflight-repair-order.js

@@ -7,6 +7,7 @@ const STRUCTURAL_BLOCKERS = new Set([
 ]);
 const COVERAGE_FOLLOW_UPS = new Set([
     "product_claim_uncovered",
+    "product_claim_required_surfaces_missing",
     "global_claim_uncovered",
 ]);
 /**
@@ -83,6 +84,8 @@ function repairEntity(diagnostic) {
             return scopedClaim(refs, "forbidden_shortcut");
         case "product_claim_uncovered":
             return refs.length === 1 ? refs[0] : null;
+        case "product_claim_required_surfaces_missing":
+            return (refs.find((ref) => /^[a-z0-9][a-z0-9-]*\.(?:result|requirement\.|control\.|control_relation\.|non_completing\.|obligation\.|forbidden_shortcut\.)/u.test(ref)) ?? null);
         case "global_claim_uncovered":
             return refs.length === 1 ? refs[0] : null;
         default:

package/dist/lib/long-task-authoring-preflight.js

@@ -22,14 +22,18 @@ export async function preflightDeliveryContract(workdirInput, projectRootInput =
     }
     const contract = parsed.contract;
     addAuthoringDiagnostics(contract, parsed, diagnostics);
-    const validation = await validateContractForActivation({
-        repository,
-        workdir,
-        contract,
-        mode: "collect",
-        diagnostics,
-    });
-    const active = await loadAuthoringActiveAuthority(repository, workdir, diagnostics);
+    const activeDiagnostics = [];
+    const [validation, active] = await Promise.all([
+        validateContractForActivation({
+            repository,
+            workdir,
+            contract,
+            mode: "collect",
+            diagnostics,
+        }),
+        loadAuthoringActiveAuthority(repository, workdir, activeDiagnostics),
+    ]);
+    diagnostics.push(...activeDiagnostics);
     if (validation.workspace)
         try {
             const changedPaths = active?.workdir === workdir

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

@@ -31,12 +31,20 @@ export function projectProductSemantics(contract) {
         target_profile: contract.task.target_profile,
         execution_targets: [...contract.task.execution_targets].sort(keyOrder),
         stages: [...contract.stages].sort(keyOrder),
-        global_non_goals: keyedStatements(contract.global.product.non_goals),
+        global_non_goals: applicableStatements(contract.global.product.non_goals),
         outcomes: [...contract.outcomes].sort(keyOrder).map((outcome) => ({
             key: outcome.key,
             title: outcome.title,
             stage: outcome.stage,
+            applicability: [...outcome.applicability].sort(keyOrder).map((item) => ({
+                ...item,
+                given_refs: [...item.given_refs],
+                when_refs: [...item.when_refs],
+            })),
             observable_result: outcome.product.observable_result,
+            result_applicability_refs: [
+                ...outcome.product.result_applicability_refs,
+            ].sort(),
             success_path_required: outcome.product.success_path_required,
             degradation_path_required: outcome.product.degradation_path_required,
             owner: {
@@ -51,6 +59,7 @@ export function projectProductSemantics(contract) {
                 required_proof_surfaces: [
                     ...requirement.required_proof_surfaces,
                 ].sort(),
+                applicability_refs: [...requirement.applicability_refs].sort(),
             })),
             controls: [...outcome.product.controls].sort(keyOrder).map((control) => ({
                 key: control.key,
@@ -76,6 +85,20 @@ export function projectProductSemantics(contract) {
                 permission: control.permission,
                 feedback: control.feedback,
                 accessibility: control.accessibility,
+                field_coverage: [...control.field_coverage].map((entry) => ({
+                    ...entry,
+                    fields: [...entry.fields].sort(),
+                    applicability_refs: [...entry.applicability_refs].sort(),
+                })),
+            })),
+            control_relation_closure: outcome.product.control_relation_closure,
+            control_relations: [...outcome.product.control_relations]
+                .sort(keyOrder)
+                .map((relation) => ({
+                ...relation,
+                control_refs: [...relation.control_refs].sort(),
+                required_proof_surfaces: [...relation.required_proof_surfaces].sort(),
+                applicability_refs: [...relation.applicability_refs].sort(),
             })),
             surface_bindings: [...(outcome.product.surface_bindings ?? [])]
                 .sort(keyOrder)
@@ -96,16 +119,26 @@ export function projectProductSemantics(contract) {
                     .map((blocker) => ({
                     ...blocker,
                     refs: [...blocker.refs].sort(),
+                    source_item_refs: [...blocker.source_item_refs].sort(),
+                    verification_methods: [...blocker.verification_methods].sort(),
+                    required_capabilities: [...blocker.required_capabilities].sort(),
                 })),
             })),
-            non_completing_outcomes: keyedStatements(outcome.product.non_completing_outcomes),
+            non_completing_outcomes: applicableStatements(outcome.product.non_completing_outcomes),
         })),
     };
 }
 export function projectGlobalSemantics(contract) {
     return {
-        constraints: keyedStatements(contract.global.technical.constraints),
-        forbidden_shortcuts: keyedStatements(contract.global.technical.forbidden_shortcuts),
+        applicability: [...contract.global.applicability]
+            .sort(keyOrder)
+            .map((item) => ({
+            ...item,
+            given_refs: [...item.given_refs],
+            when_refs: [...item.when_refs],
+        })),
+        constraints: applicableStatements(contract.global.technical.constraints),
+        forbidden_shortcuts: applicableStatements(contract.global.technical.forbidden_shortcuts),
     };
 }
 function keyedStatements(values) {
@@ -113,6 +146,15 @@ function keyedStatements(values) {
         .sort(keyOrder)
         .map(({ key, statement }) => ({ key, statement }));
 }
+function applicableStatements(values) {
+    return [...values]
+        .sort(keyOrder)
+        .map(({ key, statement, applicability_refs }) => ({
+        key,
+        statement,
+        applicability_refs: [...applicability_refs].sort(),
+    }));
+}
 function keyOrder(left, right) {
     return left.key.localeCompare(right.key);
 }

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

@@ -35,6 +35,12 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         requested_level: "semantic_user_review";
         facts: "semantic_user_review";
     };
+    readonly global: {
+        applicability: "semantic_user_review";
+        product: "semantic_user_review";
+        technical: "semantic_user_review";
+        acceptance: "proof_additive";
+    };
     readonly global_product: {
         non_goals: "semantic_user_review";
     };
@@ -53,18 +59,35 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         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";
     };
+    readonly claim_applicability: {
+        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";
+    };
+    readonly applicable_statement: {
+        key: "identity";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+    };
     readonly outcome_product: {
         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";
     };
@@ -72,6 +95,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         key: "identity";
         statement: "semantic_user_review";
         required_proof_surfaces: "proof_additive";
+        applicability_refs: "semantic_user_review";
     };
     readonly owner: {
         label: "identity";
@@ -102,6 +126,25 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         permission: "semantic_user_review";
         feedback: "semantic_user_review";
         accessibility: "semantic_user_review";
+        field_coverage: "semantic_user_review";
+    };
+    readonly control_field_coverage: {
+        fields: "semantic_user_review";
+        state: "semantic_user_review";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+    };
+    readonly control_relation_closure: {
+        state: "semantic_user_review";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+    };
+    readonly control_relation: {
+        key: "identity";
+        statement: "semantic_user_review";
+        applicability_refs: "semantic_user_review";
+        control_refs: "semantic_user_review";
+        required_proof_surfaces: "proof_additive";
     };
     readonly surface_binding: {
         key: "identity";
@@ -127,12 +170,18 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         actual_artifact_path: "output_requirement";
         comparison_artifact_path: "output_requirement";
     };
+    readonly design_verification_binding: {
+        method: "proof_additive";
+        assertion_ref: "proof_additive";
+        evidence_artifacts: "output_requirement";
+    };
     readonly design_blocker: {
         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";
     };
     readonly outcome_technical: {
@@ -148,6 +197,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         key: "identity";
         statement: "semantic_user_review";
         required_proof_surfaces: "proof_additive";
+        applicability_refs: "semantic_user_review";
     };
     readonly binding: {
         key: "identity";
@@ -186,6 +236,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         key: "identity";
         criterion: "semantic_user_review";
         claims: "proof_additive";
+        applicability_ref: "proof_additive";
         observation: "proof_additive";
         evidence_capabilities: "proof_additive";
         operator: "proof_additive";
@@ -203,6 +254,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly population: {
         check_key: "proof_additive";
+        universe_binding_key: "proof_additive";
         claims: "proof_additive";
         observations: "proof_additive";
         exclusion_rules: "proof_additive";
@@ -214,6 +266,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         check_key: "proof_additive";
         mutation: "proof_additive";
         expected_assertion_failures: "proof_additive";
+        preserved_assertions: "proof_additive";
     };
     readonly global_counterfactual: {
         key: "identity";
@@ -222,6 +275,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         check_key: "proof_additive";
         mutation: "proof_additive";
         expected_assertion_failures: "proof_additive";
+        preserved_assertions: "proof_additive";
     };
 };
 export declare function projectFieldsByPolicy<T extends object>(value: T, policy: Record<keyof T, AuthorityFieldPolicy>, included: ReadonlySet<AuthorityFieldPolicy>): Partial<T>;