project-tiny-context-harness 0.7.9 → 0.8.0

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

@@ -0,0 +1,93 @@
+import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceScope(handoff) {
+    const surfaceStableKeys = new Set(handoff.subjects
+        .filter((subject) => subject.kind === "surface")
+        .flatMap((subject) => subject.stable_keys));
+    for (const surfaceKey of handoff.scope.surface_keys)
+        if (!surfaceStableKeys.has(surfaceKey))
+            invalidDesignResourceHandoff("scope_surface_subject_missing", surfaceKey);
+}
+export function validateDesignResourceConditions(handoff) {
+    for (const condition of handoff.conditions) {
+        for (const [name, values] of [
+            ["modes", condition.modes],
+            ["states", condition.states],
+            ["content_cases", condition.content_cases],
+            ["input_methods", condition.input_methods],
+        ]) {
+            requireNonemptyDesignResourceValues(values, `condition_${name}_required:${condition.key}`);
+            requireUniqueDesignResourceValues(values, `condition_${name}_duplicate:${condition.key}`);
+        }
+    }
+}
+export function validateDesignResourceSubjects(handoff, targets) {
+    const stableKeys = new Set();
+    for (const subject of handoff.subjects) {
+        requireNonemptyDesignResourceValues(subject.stable_keys, `subject_stable_keys_required:${subject.key}`);
+        requireUniqueDesignResourceValues(subject.stable_keys, `subject_stable_key_duplicate:${subject.key}`);
+        requireNonemptyDesignResourceValues(subject.target_refs, `subject_target_refs_required:${subject.key}`);
+        requireUniqueDesignResourceValues(subject.target_refs, `subject_target_ref_duplicate:${subject.key}`);
+        for (const ref of subject.target_refs)
+            requireKnownDesignResourceRef(targets, ref, "target");
+        for (const stableKey of subject.stable_keys) {
+            if (stableKeys.has(stableKey))
+                invalidDesignResourceHandoff("subject_stable_key_ambiguous", stableKey);
+            stableKeys.add(stableKey);
+        }
+    }
+}
+export function validateDesignResourceTargets(handoff, resources, conditions) {
+    for (const target of handoff.targets) {
+        requireNonemptyDesignResourceValues(target.resource_refs, `target_resource_refs_required:${target.key}`);
+        requireNonemptyDesignResourceValues(target.condition_refs, `target_condition_refs_required:${target.key}`);
+        requireUniqueDesignResourceValues(target.resource_refs, `target_resource_ref_duplicate:${target.key}`);
+        requireUniqueDesignResourceValues(target.condition_refs, `target_condition_ref_duplicate:${target.key}`);
+        for (const ref of target.resource_refs)
+            requireKnownDesignResourceRef(resources, ref, "resource");
+        for (const ref of target.condition_refs)
+            requireKnownDesignResourceRef(conditions, ref, "condition");
+        validateTargetSourceProfile(target, resources);
+        const expectedRole = target.interpretation === "exact_target" ? "exact_target" : "constraint";
+        if (!target.resource_refs.some((ref) => resources.get(ref)?.role === expectedRole))
+            invalidDesignResourceHandoff("target_interpretation_resource_role_missing", `${target.key}:${expectedRole}`);
+    }
+}
+function validateTargetSourceProfile(target, resources) {
+    const profile = target.source_profile;
+    requireKnownDesignResourceRef(resources, profile.entry_resource_ref, "source_profile_entry_resource");
+    requireUniqueDesignResourceValues(profile.dependency_resource_refs, `source_profile_dependency_resource_ref_duplicate:${target.key}`);
+    for (const ref of profile.dependency_resource_refs)
+        requireKnownDesignResourceRef(resources, ref, "source_profile_dependency_resource");
+    if (profile.dependency_resource_refs.includes(profile.entry_resource_ref))
+        invalidDesignResourceHandoff("source_profile_entry_repeated_as_dependency", target.key);
+    const declared = [
+        profile.entry_resource_ref,
+        ...profile.dependency_resource_refs,
+    ].sort();
+    const targetResources = [...target.resource_refs].sort();
+    if (declared.length !== targetResources.length ||
+        declared.some((ref, index) => ref !== targetResources[index]))
+        invalidDesignResourceHandoff("source_profile_resource_closure_mismatch", target.key);
+    const entry = resources.get(profile.entry_resource_ref);
+    if (profile.kind === "implementation_web" &&
+        !["text/html", "application/xhtml+xml"].includes(entry.media_type))
+        invalidDesignResourceHandoff("implementation_web_entry_media_type_invalid", `${target.key}:${entry.media_type}`);
+    if (profile.kind === "implementation_app" &&
+        !(entry.media_type.startsWith("text/") ||
+            [
+                "application/json",
+                "application/javascript",
+                "application/yaml",
+                "application/x-yaml",
+            ].includes(entry.media_type)))
+        invalidDesignResourceHandoff("implementation_app_entry_media_type_invalid", `${target.key}:${entry.media_type}`);
+}
+export function validateDesignResourceEvidence(handoff, resources, conditions) {
+    for (const item of handoff.evidence) {
+        requireKnownDesignResourceRef(resources, item.resource_ref, "resource");
+        requireNonemptyDesignResourceValues(item.condition_refs, `evidence_condition_refs_required:${item.key}`);
+        requireUniqueDesignResourceValues(item.condition_refs, `evidence_condition_ref_duplicate:${item.key}`);
+        for (const ref of item.condition_refs)
+            requireKnownDesignResourceRef(conditions, ref, "condition");
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function preflightDesignResourceHandoff(repository: string, handoffPath: string): Promise<DesignResourceHandoffPreflightV1>;
+export declare function validateDesignResourceHandoffSemantics(parsed: ParsedDesignResourceHandoffV1): void;

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

@@ -0,0 +1,78 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
+import { validateDesignResourceFiles } from "./design-resource-handoff-file-validation.js";
+import { validateDesignResourceBlockers, validateDesignResourceCoverage, validateDesignResourceReachability, } from "./design-resource-handoff-validation-coverage.js";
+import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonemptyDesignResourceValues, requireUniqueDesignResourceObjects, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+export async function preflightDesignResourceHandoff(repository, handoffPath) {
+    const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
+    const parsed = parseDesignResourceHandoffMarkdown(handoffPath, await readFile(handoffFile, "utf8"));
+    validateDesignResourceHandoffSemantics(parsed);
+    const resourceHashes = await validateResourceIntegrity(repository, parsed);
+    await validateDesignResourceFiles(repository, parsed);
+    const handoff = parsed.handoff;
+    return {
+        schema_version: "design-resource-handoff-preflight-v1",
+        status: "ready",
+        ...parsed,
+        resource_hashes: resourceHashes,
+        counts: {
+            resources: handoff.resources.length,
+            conditions: handoff.conditions.length,
+            subjects: handoff.subjects.length,
+            targets: handoff.targets.length,
+            evidence: handoff.evidence.length,
+            coverage: handoff.coverage.length,
+            acceptance_blockers: handoff.acceptance_blockers.length,
+        },
+    };
+}
+export function validateDesignResourceHandoffSemantics(parsed) {
+    const { handoff } = parsed;
+    requireNonemptyDesignResourceValues(handoff.scope.surface_keys, "scope_surface_keys_required");
+    requireNonemptyDesignResourceValues(handoff.resources, "resources_required");
+    requireNonemptyDesignResourceValues(handoff.conditions, "conditions_required");
+    requireNonemptyDesignResourceValues(handoff.subjects, "subjects_required");
+    requireNonemptyDesignResourceValues(handoff.targets, "targets_required");
+    requireNonemptyDesignResourceValues(handoff.evidence, "evidence_required");
+    requireNonemptyDesignResourceValues(handoff.coverage, "coverage_required");
+    requireUniqueDesignResourceValues(handoff.scope.surface_keys, "scope_surface_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.resources, "resource_key_duplicate");
+    requireUniqueDesignResourceValues(handoff.resources.map((item) => item.path), "resource_path_duplicate");
+    requireUniqueDesignResourceObjects(handoff.conditions, "condition_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.subjects, "subject_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.targets, "target_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.evidence, "evidence_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.coverage, "coverage_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.acceptance_blockers, "acceptance_blocker_key_duplicate");
+    const resources = indexDesignResourceItems(handoff.resources);
+    const conditions = indexDesignResourceItems(handoff.conditions);
+    const subjects = indexDesignResourceItems(handoff.subjects);
+    const targets = indexDesignResourceItems(handoff.targets);
+    const evidence = indexDesignResourceItems(handoff.evidence);
+    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
+    validateDesignResourceScope(handoff);
+    validateDesignResourceConditions(handoff);
+    validateDesignResourceSubjects(handoff, targets);
+    validateDesignResourceTargets(handoff, resources, conditions);
+    validateDesignResourceEvidence(handoff, resources, conditions);
+    validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, sourceItems);
+    validateDesignResourceBlockers(handoff, subjects, targets, sourceItems);
+    validateDesignResourceReachability(handoff);
+}
+async function validateResourceIntegrity(repository, parsed) {
+    const hashes = {};
+    for (const resource of parsed.handoff.resources) {
+        if (resource.path === parsed.handoff_path)
+            invalidDesignResourceHandoff("resource_must_not_be_handoff", resource.key);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource:${resource.key}`);
+        const digest = sha256Hex(await readFile(file));
+        if (digest !== resource.sha256)
+            invalidDesignResourceHandoff("resource_digest_mismatch", `${resource.key}:${resource.sha256}:${digest}`);
+        hashes[resource.key] = digest;
+    }
+    return hashes;
+}

package/dist/lib/design-resource-handoff-web-dependency-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import { type DesignResource } from "./design-resource-handoff-file-primitives.js";
+export declare function validateDesignResourceWebDependencyClosure(target: ParsedDesignResourceHandoffV1["handoff"]["targets"][number], resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;

package/dist/lib/design-resource-handoff-web-dependency-validation.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+import { htmlAttributes, isTextResource, } from "./design-resource-handoff-file-primitives.js";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceWebDependencyClosure(target, resources, contents) {
+    const declaredPaths = new Set(target.resource_refs.map((ref) => resources.get(ref).path));
+    for (const resourceRef of target.resource_refs) {
+        const resource = resources.get(resourceRef);
+        if (!isTextResource(resource))
+            continue;
+        const content = contents.get(resourceRef).toString("utf8");
+        for (const reference of localDependencyReferences(content, resource.media_type)) {
+            const resolved = resolveResourceReference(resource.path, reference);
+            if (!declaredPaths.has(resolved))
+                invalidDesignResourceHandoff("implementation_dependency_undeclared", `${target.key}:${resource.path}:${reference}:${resolved}`);
+        }
+    }
+}
+function localDependencyReferences(content, mediaType) {
+    const values = new Set();
+    if (["text/html", "application/xhtml+xml"].includes(mediaType)) {
+        for (const tag of content.matchAll(/<(script|img|source|video|audio|track|iframe|embed|input|link|object|use|image)\b([^<>]*)>/giu)) {
+            const attributes = htmlAttributes(tag[2]);
+            for (const name of ["src", "href", "poster"])
+                addLocalReference(values, attributes.get(name));
+            if (tag[1].toLowerCase() === "object")
+                addLocalReference(values, attributes.get("data"));
+            for (const candidate of (attributes.get("srcset") ?? "").split(","))
+                addLocalReference(values, candidate.trim().split(/\s+/u)[0]);
+        }
+    }
+    if (mediaType === "text/css" ||
+        ["text/html", "application/xhtml+xml"].includes(mediaType))
+        for (const match of content.matchAll(/(?:url\(\s*["']?([^"')\s]+)|@import\s+(?:url\(\s*)?["']([^"']+))/giu))
+            addLocalReference(values, match[1] ?? match[2]);
+    if ([
+        "text/javascript",
+        "application/javascript",
+        "text/typescript",
+        "application/typescript",
+        "text/ecmascript",
+        "application/ecmascript",
+        "text/html",
+    ].includes(mediaType)) {
+        for (const match of content.matchAll(/(?:\b(?:from|import)\s*|\bimport\s*\(|\brequire\s*\()\s*["']([^"']+)["']/gu))
+            addLocalReference(values, match[1]);
+        for (const match of content.matchAll(/(?:\bfetch\s*\(|\bnew\s+(?:Shared)?Worker\s*\(|\bnew\s+URL\s*\()\s*["']([^"']+)["']/gu))
+            addLocalReference(values, match[1]);
+    }
+    return values;
+}
+function addLocalReference(values, raw) {
+    if (!raw)
+        return;
+    const value = raw.trim();
+    if (!value ||
+        value.startsWith("#") ||
+        /^(?:[a-z][a-z0-9+.-]*:|\/\/)/iu.test(value))
+        return;
+    values.add(value.replace(/[?#].*$/u, ""));
+}
+function resolveResourceReference(from, reference) {
+    if (reference.startsWith("/"))
+        invalidDesignResourceHandoff("implementation_dependency_path_unsafe", `${from}:${reference}`);
+    const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(from), reference));
+    if (resolved === ".." ||
+        resolved.startsWith("../") ||
+        path.posix.isAbsolute(resolved))
+        invalidDesignResourceHandoff("implementation_dependency_path_unsafe", `${from}:${reference}`);
+    return resolved;
+}

package/dist/lib/long-task-activation-validation.js

@@ -6,6 +6,7 @@ import { validateClaimEvidenceSensitivity } from "./long-task-evidence-sensitivi
 import { validateSemanticConformance } from "./long-task-conformance-policy.js";
 import { deliveryContractStructureDiagnostics, validateDeliveryContractStructure, } from "./long-task-delivery-validation.js";
 import { validateRawExecutionObservationOwnership } from "./long-task-observation-ownership.js";
+import { validateLongTaskDesignResourceHandoffs } from "./long-task-design-resource-handoff.js";
 import { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
 import { classifyLongTaskRisk, validateRiskProof, } from "./long-task-risk.js";
 import { validateSourceContinuity } from "./long-task-source-continuity.js";
@@ -41,6 +42,7 @@ export async function validateContractForActivation(options) {
             : undefined);
         return items;
     });
+    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository));
     const risk = await attempt(mode, diagnostics, () => {
         const decision = classifyLongTaskRisk(contract);
         validateRiskProof(contract, decision);
@@ -60,7 +62,7 @@ export async function validateContractForActivation(options) {
         const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
         if (!executionTarget)
             continue;
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets), null, check.key);
+        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, []), null, check.key);
         if (frozen)
             globalChecks.push(frozen);
     }
@@ -71,7 +73,7 @@ export async function validateContractForActivation(options) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets), outcome.key, check.key);
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key)), outcome.key, check.key);
             if (frozen)
                 checks.push(frozen);
         }
@@ -114,6 +116,16 @@ export async function validateContractForActivation(options) {
         outcomes,
     };
 }
+function designTargetsForCheck(outcome, checkKey) {
+    return (outcome.product.surface_bindings ?? []).flatMap((binding) => binding.design_targets
+        .filter((target) => target.conformance_check_ref === checkKey)
+        .map((target) => ({
+        ...target,
+        surface_binding_ref: binding.key,
+        surface_ref: binding.surface_ref,
+        target_ref: binding.target_ref,
+    })));
+}
 async function attempt(mode, diagnostics, action, outcomeKey, checkKey) {
     try {
         return await action();

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

@@ -140,6 +140,9 @@ function diagnosticRefs(code, message) {
             return payload.slice(0, 2);
         case "owner_path_globs_empty":
             return payload.slice(0, 1);
+        case "workspace_path_forbidden":
+        case "workspace_path_unclassified":
+            return payload.slice(0, 1);
         case "product_claim_uncovered":
         case "global_claim_uncovered":
         case "source_claim_decision_required":
@@ -171,6 +174,10 @@ function diagnosticRepairHint(code) {
             return "Correct source_ref or add the matching non-rendering Source marker/anchor without rewriting the Source statement.";
         case "source_claim_decision_required":
             return "Resolve the stated product decision from the user or authoritative Source before Compile.";
+        case "workspace_path_forbidden":
+            return "Revert or relocate the forbidden workspace change, or revise the owning Source/Contract boundary through the appropriate authority path.";
+        case "workspace_path_unclassified":
+            return "Declare the file under the owning Outcome's expected_change_paths or allowed_support_paths, or remove the unrelated workspace change before Compile.";
         default:
             if (code.endsWith("_path_not_found"))
                 return "Create or correct the declared repository path, runner target or Binding carrier, then rerun Preflight.";

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

@@ -4,7 +4,8 @@ import { addAuthoringDiagnostics, addDiagnosticError, normalizeAuthoringDiagnost
 import { emptyClaimCoverage, emptyPreflightResult, } from "./long-task-authoring-preflight-types.js";
 import { validateContractForActivation } from "./long-task-activation-validation.js";
 import { parseDeliveryContractBundle } from "./long-task-delivery-parser.js";
-import { repositoryRoot } from "./long-task-workspace.js";
+import { changedWorkspacePaths, changedWorkspacePathsFromHead, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
+import { classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, workspaceScopeErrors, } from "./long-task-workspace-scope.js";
 export async function preflightDeliveryContract(workdirInput, projectRootInput = process.cwd()) {
     const diagnostics = [];
     const repository = await repositoryRoot(projectRootInput);
@@ -29,6 +30,43 @@ export async function preflightDeliveryContract(workdirInput, projectRootInput =
         diagnostics,
     });
     const active = await loadAuthoringActiveAuthority(repository, workdir, diagnostics);
+    if (validation.workspace)
+        try {
+            const changedPaths = active?.workdir === workdir
+                ? changedWorkspacePaths(active.initial_task_base.workspace_manifest, validation.workspace)
+                : await changedWorkspacePathsFromHead(repository, workdir);
+            const contractFiles = Object.fromEntries(Object.entries(parsed.contract_files).map(([relative, hash]) => [
+                repoRelative(repository, path.join(workdir, ...relative.split("/"))),
+                hash,
+            ]));
+            const checks = [
+                ...validation.global_checks,
+                ...validation.outcomes.flatMap((outcome) => outcome.acceptance.checks),
+            ];
+            const declaredVerificationInputs = [
+                ...contract.global.acceptance.checks,
+                ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks),
+            ].flatMap((check) => check.verification_inputs);
+            const firstLockManagedPaths = active?.workdir === workdir
+                ? []
+                : await firstLockManagedWorkspacePaths(repository, changedPaths);
+            const classification = classifyWorkspaceScope(contract, changedPaths, protectedWorkspacePaths({
+                contract_files: contractFiles,
+                source_hashes: validation.source_hashes,
+                context_hashes: validation.context_snapshot?.sha256,
+                checks,
+                additional_files: [
+                    ...contract.task.source_paths,
+                    ...declaredVerificationInputs,
+                    ...firstLockManagedPaths,
+                ],
+            }));
+            for (const error of workspaceScopeErrors(classification))
+                addDiagnosticError(diagnostics, new Error(error));
+        }
+        catch (error) {
+            addDiagnosticError(diagnostics, error);
+        }
     const normalizedDiagnostics = normalizeAuthoringDiagnostics(diagnostics);
     const ready = !normalizedDiagnostics.some((item) => item.level === "error" || item.level === "decision_required");
     return {

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

@@ -168,6 +168,20 @@ function flattenProductSemantics(projection) {
                 "accessibility",
             ])
                 fields.set(`${prefix}.controls.${control.key}.${field}`, control[field]);
+        for (const binding of outcome.surface_bindings ?? []) {
+            const bindingPrefix = `${prefix}.surface_bindings.${binding.key}`;
+            fields.set(`${bindingPrefix}.surface_ref`, binding.surface_ref);
+            fields.set(`${bindingPrefix}.target_ref`, binding.target_ref);
+            fields.set(`${bindingPrefix}.control_refs`, binding.control_refs);
+            fields.set(`${bindingPrefix}.route_binding_ref`, binding.route_binding_ref);
+            fields.set(`${bindingPrefix}.component_binding_refs`, binding.component_binding_refs);
+            fields.set(`${bindingPrefix}.root_journey_check_ref`, binding.root_journey_check_ref);
+            fields.set(`${bindingPrefix}.entry_action_ref`, binding.entry_action_ref);
+            for (const target of binding.design_targets)
+                fields.set(`${bindingPrefix}.design_targets.${target.key}`, target);
+            for (const blocker of binding.acceptance_blockers)
+                fields.set(`${bindingPrefix}.acceptance_blockers.${blocker.key}`, blocker);
+        }
         for (const item of outcome.non_completing_outcomes)
             fields.set(`${prefix}.non_completing.${item.key}`, item.statement);
     }

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

@@ -77,6 +77,27 @@ export function projectProductSemantics(contract) {
                 feedback: control.feedback,
                 accessibility: control.accessibility,
             })),
+            surface_bindings: [...(outcome.product.surface_bindings ?? [])]
+                .sort(keyOrder)
+                .map((binding) => ({
+                ...binding,
+                control_refs: [...binding.control_refs].sort(),
+                component_binding_refs: [...binding.component_binding_refs].sort(),
+                design_targets: [...binding.design_targets]
+                    .sort(keyOrder)
+                    .map((target) => ({
+                    ...target,
+                    source_paths: [...target.source_paths].sort(),
+                    condition_keys: [...target.condition_keys].sort(),
+                    claim_refs: [...target.claim_refs].sort(),
+                })),
+                acceptance_blockers: [...binding.acceptance_blockers]
+                    .sort(keyOrder)
+                    .map((blocker) => ({
+                    ...blocker,
+                    refs: [...blocker.refs].sort(),
+                })),
+            })),
             non_completing_outcomes: keyedStatements(outcome.product.non_completing_outcomes),
         })),
     };

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

@@ -65,6 +65,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         requirements: "semantic_user_review";
         owner_surfaces: "semantic_user_review";
         controls: "semantic_user_review";
+        surface_bindings: "semantic_user_review";
         non_completing_outcomes: "semantic_user_review";
     };
     readonly requirement: {
@@ -102,6 +103,38 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         feedback: "semantic_user_review";
         accessibility: "semantic_user_review";
     };
+    readonly surface_binding: {
+        key: "identity";
+        surface_ref: "semantic_user_review";
+        target_ref: "semantic_user_review";
+        control_refs: "semantic_user_review";
+        route_binding_ref: "semantic_user_review";
+        component_binding_refs: "semantic_user_review";
+        root_journey_check_ref: "proof_additive";
+        entry_action_ref: "proof_additive";
+        design_targets: "semantic_user_review";
+        acceptance_blockers: "semantic_user_review";
+    };
+    readonly design_target: {
+        key: "identity";
+        interpretation: "semantic_user_review";
+        source_paths: "scope";
+        condition_keys: "semantic_user_review";
+        claim_refs: "proof_additive";
+        conformance_check_ref: "proof_additive";
+        conformance_assertion_ref: "proof_additive";
+        verification_method_bindings: "proof_additive";
+        actual_artifact_path: "output_requirement";
+        comparison_artifact_path: "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";
+        rationale: "semantic_user_review";
+    };
     readonly outcome_technical: {
         obligations: "semantic_user_review";
         expected_change_paths: "scope";

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

@@ -48,6 +48,7 @@ const OUTCOME_PRODUCT_AUTHORITY_POLICY = {
     requirements: "semantic_user_review",
     owner_surfaces: "semantic_user_review",
     controls: "semantic_user_review",
+    surface_bindings: "semantic_user_review",
     non_completing_outcomes: "semantic_user_review",
 };
 const REQUIREMENT_AUTHORITY_POLICY = {
@@ -85,6 +86,38 @@ const CONTROL_AUTHORITY_POLICY = {
     feedback: "semantic_user_review",
     accessibility: "semantic_user_review",
 };
+const SURFACE_BINDING_AUTHORITY_POLICY = {
+    key: "identity",
+    surface_ref: "semantic_user_review",
+    target_ref: "semantic_user_review",
+    control_refs: "semantic_user_review",
+    route_binding_ref: "semantic_user_review",
+    component_binding_refs: "semantic_user_review",
+    root_journey_check_ref: "proof_additive",
+    entry_action_ref: "proof_additive",
+    design_targets: "semantic_user_review",
+    acceptance_blockers: "semantic_user_review",
+};
+const DESIGN_TARGET_AUTHORITY_POLICY = {
+    key: "identity",
+    interpretation: "semantic_user_review",
+    source_paths: "scope",
+    condition_keys: "semantic_user_review",
+    claim_refs: "proof_additive",
+    conformance_check_ref: "proof_additive",
+    conformance_assertion_ref: "proof_additive",
+    verification_method_bindings: "proof_additive",
+    actual_artifact_path: "output_requirement",
+    comparison_artifact_path: "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",
+    rationale: "semantic_user_review",
+};
 const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
     obligations: "semantic_user_review",
     expected_change_paths: "scope",
@@ -185,6 +218,9 @@ export const AUTHORITY_FIELD_POLICY_REGISTRIES = {
     requirement: REQUIREMENT_AUTHORITY_POLICY,
     owner: OWNER_AUTHORITY_POLICY,
     control: CONTROL_AUTHORITY_POLICY,
+    surface_binding: SURFACE_BINDING_AUTHORITY_POLICY,
+    design_target: DESIGN_TARGET_AUTHORITY_POLICY,
+    design_blocker: DESIGN_BLOCKER_AUTHORITY_POLICY,
     outcome_technical: OUTCOME_TECHNICAL_AUTHORITY_POLICY,
     obligation: OBLIGATION_AUTHORITY_POLICY,
     binding: BINDING_AUTHORITY_POLICY,

package/dist/lib/long-task-authority-revision-analysis.d.ts

@@ -1,6 +1,7 @@
 import type { CompiledCheckV2, CompiledDeliveryContractV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
 export interface CheckRevisionAnalysis {
     negative_assertions_removed: string[];
+    acceptance_semantics_reduced: string[];
     proof_surfaces_changed: string[];
     runner_definitions_changed: string[];
     verification_inputs_added: string[];

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

@@ -2,6 +2,7 @@ import { addedInputPaths, addedVerificationInputs, bindingReductions, changedRun
 export function analyzeCheckRevisions(beforeChecks, afterChecks) {
     const result = {
         negative_assertions_removed: [],
+        acceptance_semantics_reduced: [],
         proof_surfaces_changed: [],
         runner_definitions_changed: [],
         verification_inputs_added: [],
@@ -19,6 +20,12 @@ export function analyzeCheckRevisions(beforeChecks, afterChecks) {
         for (const assertion of before.negative_assertions)
             if (!after.negative_assertions.some((item) => same(item, assertion)))
                 result.negative_assertions_removed.push(`${identity}:${assertion.key}`);
+        if (!same(before.execution_target, after.execution_target))
+            result.acceptance_semantics_reduced.push(`${identity}:execution_target`);
+        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:journey_role`, before.journey_roles, after.journey_roles);
+        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:scenario.given`, before.scenario.given, after.scenario.given);
+        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:scenario.when`, before.scenario.when, after.scenario.when);
+        collectAssertionReductions(result.acceptance_semantics_reduced, identity, before.positive_assertions, after.positive_assertions);
         if (before.proof_surface !== after.proof_surface)
             result.proof_surfaces_changed.push(`${identity}:${before.proof_surface}->${after.proof_surface}`);
         result.runner_definitions_changed.push(...changedRunnerFields(identity, before, after));
@@ -32,6 +39,29 @@ export function analyzeCheckRevisions(beforeChecks, afterChecks) {
     }
     return result;
 }
+function collectRemovedValues(result, prefix, before, after) {
+    for (const value of before)
+        if (!after.some((candidate) => same(candidate, value)))
+            result.push(`${prefix}:${String(value)}`);
+}
+function collectAssertionReductions(result, identity, before, after) {
+    const next = new Map(after.map((assertion) => [assertion.key, assertion]));
+    for (const assertion of before) {
+        const candidate = next.get(assertion.key);
+        if (!candidate) {
+            result.push(`${identity}:positive_assertion.${assertion.key}:removed`);
+            continue;
+        }
+        const semanticChanged = assertion.criterion !== candidate.criterion ||
+            !same(assertion.claims, candidate.claims) ||
+            assertion.observation !== candidate.observation ||
+            assertion.operator !== candidate.operator ||
+            !same(assertion.expected, candidate.expected);
+        const capabilityRemoved = assertion.evidence_capabilities.some((capability) => !candidate.evidence_capabilities.includes(capability));
+        if (semanticChanged || capabilityRemoved)
+            result.push(`${identity}:positive_assertion.${assertion.key}:changed`);
+    }
+}
 export function analyzeOutcomeRevisions(previous, next) {
     const result = {
         owner_paths_expanded: [],

package/dist/lib/long-task-authority-revision-brief.d.ts

@@ -0,0 +1,3 @@
+import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionBriefV2, AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
+export declare function authorityRevisionDecisionNextAction(decision: AuthorityRevisionDecisionV2): string;
+export declare function buildAuthorityRevisionDecisionBrief(summary: AuthorityRevisionApprovalSummaryV2, changeClass: AuthorityRevisionChangeClassV2, approvalRequired: boolean): AuthorityRevisionDecisionBriefV2;