project-tiny-context-harness 0.8.1 → 0.8.2

package/dist/commands/design-resource.js

@@ -26,7 +26,7 @@ export async function designResource(args) {
     console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
 }
 function help() {
-    console.log(`ty-context design-resource commands:
-  preflight <handoff.md> [--json]
+    console.log(`ty-context design-resource commands:
+  preflight <handoff.md> [--json]
                        Validate one selected implementation handoff`);
 }

package/dist/commands/index.js

@@ -36,32 +36,32 @@ export const commands = {
     package: packageSource,
 };
 export function help() {
-    console.log(`ty-context commands:
-  init [--adopt] [--harness-folder <path>]
-                       Initialize/adopt a project; without --harness-folder, choose target agent first
-  enable long-task     Install Long-Task Skill, Source Plan pointer, Stop Hook and templates
-  disable long-task    Remove only package-owned long-task profile assets
-  sync                 Refresh managed assets; does not run migrations
-  upgrade [--check] [--json]
-                       Run safe migrations, sync managed assets and doctor
-  doctor               Diagnose project configuration and drift
-  check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
-                       Warn when selected handwritten source files exceed a line-count limit
-  export-context --full|--code|--all|--source-pack|--code-index|--task-context
-                       Export temporary Context, code snapshot or bounded Source Pack artifacts
-  validate <gate>      Run a Harness validation gate
-  validate-context     Validate Minimal Context fact-source recoverability
-  validate-code-modularity
-                       Enforce touched handwritten source file modularity
-  validate-harness     Run validate-context and validate-code-modularity
-  design-resource <subcommand>
-                       Validate a selected design-resource implementation handoff
-  long-task <subcommand>
-                       Manage one Canonical Delivery Contract in the current workspace
-  delivery-set <subcommand>
-                       Retired; use one complete Contract with semantic Outcomes
-  composite-long-task Retired command; use ty-context long-task
-  composite-campaign  Retired command; use ty-context long-task
+    console.log(`ty-context commands:
+  init [--adopt] [--harness-folder <path>]
+                       Initialize/adopt a project; without --harness-folder, choose target agent first
+  enable long-task     Install Long-Task Skill, Source Plan pointer, Stop Hook and templates
+  disable long-task    Remove only package-owned long-task profile assets
+  sync                 Refresh managed assets; does not run migrations
+  upgrade [--check] [--json]
+                       Run safe migrations, sync managed assets and doctor
+  doctor               Diagnose project configuration and drift
+  check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
+                       Warn when selected handwritten source files exceed a line-count limit
+  export-context --full|--code|--all|--source-pack|--code-index|--task-context
+                       Export temporary Context, code snapshot or bounded Source Pack artifacts
+  validate <gate>      Run a Harness validation gate
+  validate-context     Validate Minimal Context fact-source recoverability
+  validate-code-modularity
+                       Enforce touched handwritten source file modularity
+  validate-harness     Run validate-context and validate-code-modularity
+  design-resource <subcommand>
+                       Validate a selected design-resource implementation handoff
+  long-task <subcommand>
+                       Manage one Canonical Delivery Contract in the current workspace
+  delivery-set <subcommand>
+                       Retired; use one complete Contract with semantic Outcomes
+  composite-long-task Retired command; use ty-context long-task
+  composite-campaign  Retired command; use ty-context long-task
   package <subcommand> Maintain package canonical source`);
 }
 async function withLongTaskProfile(args, handler) {

package/dist/commands/long-task-authoring.js

@@ -39,8 +39,10 @@ task:
       role: product
       runtime_family: process
       root_entrypoint: tests/replace-oracle.mjs
+      capabilities: [process-runtime, cold-start, production-root]
   source_paths: [plans/replace-me.md]
   context_refs: [project_context/areas/replace-me.md]
+  context_snapshot_mode: full
 source_claims:
   - key: replace-requirement
     source_ref: plans/replace-me.md#replace-requirement
@@ -48,6 +50,12 @@ source_claims:
     disposition:
       type: claim
       refs: [replace-outcome.requirement.replace-requirement]
+  - key: replace-architecture
+    source_ref: plans/replace-me.md#replace-architecture
+    statement: Preserve the declared owner, dependency direction, verifier boundary and architecture conformance.
+    disposition:
+      type: claim
+      refs: [replace-outcome.obligation.architecture]
 stages:
   - key: delivery
     title: Delivery
@@ -55,13 +63,22 @@ stages:
     gate_outcome: replace-outcome
 risk:
   facts: {}
-global: {}
+global:
+  applicability: []
 outcomes:
   - key: replace-outcome
     title: Replace outcome
     stage: delivery
+    applicability:
+      - key: root-success
+        target_ref: replace-runtime
+        journey_role: success
+        dimensions: [{key: delivery-state, value: ready}]
+        given_refs: [source-ready]
+        when_refs: [inspect-result]
     product:
       observable_result: Describe what a user or system can observe.
+      result_applicability_refs: [root-success]
       success_path_required: true
       degradation_path_required: false
       owner:
@@ -72,7 +89,17 @@ outcomes:
         - key: replace-requirement
           statement: Preserve one atomic source requirement.
           required_proof_surfaces: [runtime_behavior]
+          applicability_refs: [root-success]
+      control_relation_closure:
+        state: not_applicable
+        statement: This Outcome declares no user-visible Controls.
+        applicability_refs: [root-success]
     technical:
+      obligations:
+        - key: architecture
+          statement: Preserve the declared owner, dependency direction, verifier boundary and architecture conformance.
+          required_proof_surfaces: [runtime_behavior]
+          applicability_refs: [root-success]
       expected_change_paths: ["src/**"]
       bindings:
         - key: replace-carrier
@@ -97,21 +124,68 @@ outcomes:
           input_paths: [src/replace-me.ts]
           expected_output_paths: [src/replace-me.ts]
           positive_assertions:
-            - key: replace-success
-              criterion: The declared outcome and requirement are observable.
-              claims: [result, requirement.replace-requirement]
+            - key: replace-result
+              criterion: The declared outcome is observable.
+              claims: [result]
+              applicability_ref: root-success
               observation: result
               evidence_capabilities: [state_delta, target_runtime]
               operator: equals
               expected: true
+            - key: replace-requirement
+              criterion: The atomic Source requirement is observable.
+              claims: [requirement.replace-requirement]
+              applicability_ref: root-success
+              observation: requirement_result
+              evidence_capabilities: [state_delta, target_runtime]
+              operator: equals
+              expected: true
+            - key: replace-architecture
+              criterion: The declared architecture obligation remains conformant.
+              claims: [obligation.architecture]
+              applicability_ref: root-success
+              observation: architecture_result
+              evidence_capabilities: [state_delta, target_runtime]
+              operator: equals
+              expected: true
+            - key: replace-liveness
+              criterion: The declared target remains live under semantic mutation.
+              claims: []
+              observation: target_live
+              evidence_capabilities: [target_runtime]
+              operator: equals
+              expected: true
+          negative_assertions:
+            - key: replace-relations-na
+              criterion: Cross-Control relations remain inapplicable when no Controls are declared.
+              claims: [control_relation_closure]
+              applicability_ref: root-success
+              observation: relations_applicable
+              evidence_capabilities: [state_delta, target_runtime]
+              operator: equals
+              expected: false
       counterfactual_controls:
-        - key: remove-replace-carrier
+        - key: replace-semantic-carrier
+          binding_key: replace-carrier
+          claims: [result, requirement.replace-requirement, obligation.architecture]
+          check_key: replace-check
+          mutation:
+            type: replace_text
+            path: src/replace-me.ts
+            match: IMPLEMENTED_STATE
+            replacement: SEMANTIC_FAILURE_STATE
+          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture]
+          preserved_assertions: [replace-liveness]
+        - key: replace-relation-applicability
           binding_key: replace-carrier
-          claims: [result, requirement.replace-requirement]
+          claims: [control_relation_closure]
           check_key: replace-check
           mutation:
-            type: remove_paths
-            paths: [src/replace-me.ts]
-          expected_assertion_failures: [replace-success]
+            type: replace_text
+            path: src/replace-me.ts
+            match: NO_CROSS_CONTROL_RELATIONS
+            replacement: CROSS_CONTROL_RELATIONS_APPLY
+          expected_assertion_failures: [replace-relations-na]
+          preserved_assertions: [replace-liveness]
 `;
 }

package/dist/commands/long-task.js

@@ -124,20 +124,20 @@ async function finalGate(workdir, args) {
         process.exitCode = 1;
 }
 function help() {
-    console.log(`ty-context long-task commands:
-  init <workdir>
-  preflight <workdir>
-  compile <workdir>
-  compile <workdir> --revise
-  diagnose-revision <workdir> [--outcome <key>] [--check <key>]
-  approve-authority-revision <workdir> --revision <sha>
-  explain <workdir>
-  verify <workdir> [--outcome <key>] [--check <key>] [--explain]
-  status <workdir>
-  resume <workdir>
-  doctor <workdir>
-  final-gate <workdir>
-  stop-check <workdir> [--message <text>]
-  close <workdir>
+    console.log(`ty-context long-task commands:
+  init <workdir>
+  preflight <workdir>
+  compile <workdir>
+  compile <workdir> --revise
+  diagnose-revision <workdir> [--outcome <key>] [--check <key>]
+  approve-authority-revision <workdir> --revision <sha>
+  explain <workdir>
+  verify <workdir> [--outcome <key>] [--check <key>] [--explain]
+  status <workdir>
+  resume <workdir>
+  doctor <workdir>
+  final-gate <workdir>
+  stop-check <workdir> [--message <text>]
+  close <workdir>
   abandon <workdir> [--force-corrupt-state]`);
 }

package/dist/lib/context-graph-snapshot.js

@@ -15,6 +15,13 @@ export async function captureContextGraphSnapshot(repositoryRoot, contextRefs, m
     const explicitlySelected = new Set();
     if (mode === "full") {
         allFiles.forEach((file) => selected.add(file));
+        for (const contextRef of contextRefs) {
+            const normalized = normalizeRepoPath(contextRef);
+            if (!available.has(normalized)) {
+                throw new Error(`context_ref_invalid:${contextRef}`);
+            }
+            explicitlySelected.add(normalized);
+        }
     }
     else {
         for (const required of [

package/dist/lib/design-resource-handoff-shape-evidence.js

@@ -1,6 +1,7 @@
 import { DESIGN_RESOURCE_DIMENSIONS, DESIGN_RESOURCE_EVIDENCE_KINDS, DESIGN_RESOURCE_LOCATOR_KINDS, } from "./design-resource-handoff-types.js";
 import { contractKey, contractKeys, sourceItemKeys, stableKey, stableKeys, verificationMethods, } from "./design-resource-handoff-shape-primitives.js";
 import { array, literal, object, string, } from "./long-task-shape-primitives.js";
+import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
 export function parseDesignResourceHandoffEvidence(value) {
     return array(value, "design_resource_handoff.evidence").map((item, index) => {
         const label = `design_resource_handoff.evidence[${index}]`;
@@ -69,6 +70,7 @@ export function parseDesignResourceHandoffBlockers(value) {
             "dimensions",
             "source_item_refs",
             "verification_methods",
+            "required_capabilities",
             "description",
         ]);
         return {
@@ -78,6 +80,7 @@ export function parseDesignResourceHandoffBlockers(value) {
             dimensions: array(row.dimensions, `${label}.dimensions`).map((dimension, itemIndex) => literal(dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimensions[${itemIndex}]`)),
             source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
             verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
+            required_capabilities: array(row.required_capabilities, `${label}.required_capabilities`).map((capability, capabilityIndex) => literal(capability, EXECUTION_TARGET_CAPABILITIES, `${label}.required_capabilities[${capabilityIndex}]`)),
             description: string(row.description, `${label}.description`),
         };
     });

package/dist/lib/design-resource-handoff-types.d.ts

@@ -1,3 +1,4 @@
+import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
 export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
 export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation"];
@@ -115,6 +116,7 @@ export interface DesignResourceHandoffBlockerV1 {
     dimensions: DesignResourceDimension[];
     source_item_refs: string[];
     verification_methods: DesignResourceVerificationMethod[];
+    required_capabilities: ExecutionTargetCapabilityV2[];
     description: string;
 }
 export interface ParsedDesignResourceHandoffV1 {

package/dist/lib/design-resource-handoff-validation-coverage.js

@@ -80,6 +80,7 @@ export function validateDesignResourceBlockers(handoff, subjects, targets, sourc
             ["dimensions", blocker.dimensions],
             ["source_item_refs", blocker.source_item_refs],
             ["verification_methods", blocker.verification_methods],
+            ["required_capabilities", blocker.required_capabilities],
         ]) {
             requireNonemptyDesignResourceValues(values, `acceptance_blocker_${name}_required:${blocker.key}`);
             requireUniqueDesignResourceValues(values, `acceptance_blocker_${name}_duplicate:${blocker.key}`);

package/dist/lib/design-resource-handoff-validation-structure.js

@@ -17,6 +17,8 @@ export function validateDesignResourceConditions(handoff) {
         ]) {
             requireNonemptyDesignResourceValues(values, `condition_${name}_required:${condition.key}`);
             requireUniqueDesignResourceValues(values, `condition_${name}_duplicate:${condition.key}`);
+            if (values.length !== 1)
+                invalidDesignResourceHandoff(`condition_${name}_must_be_atomic`, condition.key);
         }
     }
 }

package/dist/lib/execution-target-capabilities.d.ts

@@ -0,0 +1,2 @@
+export declare const EXECUTION_TARGET_CAPABILITIES: readonly ["browser-runtime", "native-runtime", "desktop-runtime", "service-runtime", "process-runtime", "external-runtime", "cold-start", "production-root", "pointer-input", "keyboard-input", "touch-input", "viewport-control", "pixel-density-observation", "safe-area-observation", "motion-observation", "reduced-motion", "color-scheme-control", "text-scale-control", "assistive-technology", "screen-reader", "physical-device", "device-orientation", "sensor-input", "camera-input", "haptic-output", "thermal-observation", "power-mode-control", "persistent-storage", "network-boundary"];
+export type ExecutionTargetCapabilityV2 = (typeof EXECUTION_TARGET_CAPABILITIES)[number];

package/dist/lib/execution-target-capabilities.js

@@ -0,0 +1,31 @@
+export const EXECUTION_TARGET_CAPABILITIES = [
+    "browser-runtime",
+    "native-runtime",
+    "desktop-runtime",
+    "service-runtime",
+    "process-runtime",
+    "external-runtime",
+    "cold-start",
+    "production-root",
+    "pointer-input",
+    "keyboard-input",
+    "touch-input",
+    "viewport-control",
+    "pixel-density-observation",
+    "safe-area-observation",
+    "motion-observation",
+    "reduced-motion",
+    "color-scheme-control",
+    "text-scale-control",
+    "assistive-technology",
+    "screen-reader",
+    "physical-device",
+    "device-orientation",
+    "sensor-input",
+    "camera-input",
+    "haptic-output",
+    "thermal-observation",
+    "power-mode-control",
+    "persistent-storage",
+    "network-boundary",
+];

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: