project-tiny-context-harness 0.7.3 → 0.7.5

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

@@ -28,6 +28,17 @@ task:
   id: replace-me
   title: Replace me
   goal: Describe the complete observable delivery goal.
+  target_profile:
+    key: replace-target
+    description: The declared product target is usable from its root entrypoint.
+    required_state: target_profile_usable
+    required_target_refs: [replace-runtime]
+  execution_targets:
+    - key: replace-runtime
+      description: The product runtime used by the acceptance oracle.
+      role: product
+      runtime_family: process
+      root_entrypoint: tests/replace-oracle.mjs
   source_paths: [plans/replace-me.md]
   context_refs: [project_context/areas/replace-me.md]
 source_claims:
@@ -37,14 +48,22 @@ source_claims:
     disposition:
       type: claim
       refs: [replace-outcome.requirement.replace-requirement]
+stages:
+  - key: delivery
+    title: Delivery
+    depends_on: []
+    gate_outcome: replace-outcome
 risk:
   facts: {}
 global: {}
 outcomes:
   - key: replace-outcome
     title: Replace outcome
+    stage: delivery
     product:
       observable_result: Describe what a user or system can observe.
+      success_path_required: true
+      degradation_path_required: false
       owner:
         label: replace-owner
         context_refs: [project_context/areas/replace-me.md]
@@ -64,6 +83,11 @@ outcomes:
     acceptance:
       checks:
         - key: replace-check
+          journey_roles: [success, stage_gate]
+          execution_target: {target_ref: replace-runtime, entrypoint: root}
+          scenario:
+            given: [{key: source-ready, statement: The planned source carrier is available.}]
+            when: [{key: inspect-result, statement: Inspect the product result through the declared runtime.}]
           proof_surface: runtime_behavior
           runner:
             type: node_oracle
@@ -77,6 +101,7 @@ outcomes:
               criterion: The declared outcome and requirement are observable.
               claims: [result, requirement.replace-requirement]
               observation: result
+              evidence_capabilities: [state_delta, target_runtime]
               operator: equals
               expected: true
       counterfactual_controls:

package/dist/commands/long-task.js

@@ -68,6 +68,9 @@ export async function longTask(args) {
             workdir,
             workflow_status: result.workflow_status,
             external_confirmations: result.external_confirmations,
+            target_profile: result.target_profile,
+            target_state: result.target_state,
+            stage_results: result.stage_results,
             acceptance_scope: result.acceptance_scope,
             closed_scope: result.closed_scope,
             native_goal_effect: result.native_goal_effect,

package/dist/lib/design-md.d.ts

@@ -1,5 +1,12 @@
 export declare const DESIGN_MD_PATH = "DESIGN.md";
 export declare const UNCONFIGURED_DESIGN_AUTHORITY_MARKER = "Design authority status: `unconfigured`";
 export type DesignAuthorityStatus = "missing" | "unconfigured" | "configured";
+export interface DesignAuthorityInspection {
+    status: DesignAuthorityStatus;
+    has_authority_index: boolean;
+    token_source_selected: boolean;
+    classified_reference_count: number;
+}
 export declare function createDesignMdIfMissing(projectRoot: string): Promise<boolean>;
 export declare function inspectDesignAuthorityStatus(projectRoot: string): Promise<DesignAuthorityStatus>;
+export declare function inspectDesignAuthority(projectRoot: string): Promise<DesignAuthorityInspection>;

package/dist/lib/design-md.js

@@ -10,16 +10,57 @@ export async function createDesignMdIfMissing(projectRoot) {
     return writeTextIfChanged(target, designMdTemplate());
 }
 export async function inspectDesignAuthorityStatus(projectRoot) {
+    return (await inspectDesignAuthority(projectRoot)).status;
+}
+export async function inspectDesignAuthority(projectRoot) {
     const target = path.join(projectRoot, DESIGN_MD_PATH);
-    if (!(await pathExists(target)))
-        return "missing";
-    const content = await readText(target);
-    if (content.includes(UNCONFIGURED_DESIGN_AUTHORITY_MARKER)) {
-        return "unconfigured";
+    if (!(await pathExists(target))) {
+        return {
+            status: "missing",
+            has_authority_index: false,
+            token_source_selected: false,
+            classified_reference_count: 0,
+        };
     }
+    const content = await readText(target);
     const legacyStarter = content.includes('name: "Starter Design System"') &&
         content.includes('description: "Neutral baseline design guidance for projects that have not defined their own visual system."');
-    return legacyStarter ? "unconfigured" : "configured";
+    const status = content.includes(UNCONFIGURED_DESIGN_AUTHORITY_MARKER) || legacyStarter
+        ? "unconfigured"
+        : "configured";
+    const index = designAuthorityIndex(content);
+    return {
+        status,
+        has_authority_index: index !== null,
+        token_source_selected: index ? tokenSourceSelected(index) : false,
+        classified_reference_count: index ? classifiedReferenceCount(index) : 0,
+    };
+}
+function designAuthorityIndex(content) {
+    const match = /^###\s+Design Authority Index\s*$/imu.exec(content);
+    if (!match)
+        return null;
+    const remainder = content.slice(match.index + match[0].length);
+    const nextSection = /^#{1,3}\s+/mu.exec(remainder);
+    return nextSection ? remainder.slice(0, nextSection.index) : remainder;
+}
+function tokenSourceSelected(index) {
+    const line = index
+        .split(/\r?\n/u)
+        .find((candidate) => /authored(?: exact-value)? token source\s*:/iu.test(candidate));
+    if (!line)
+        return false;
+    const value = line.slice(line.indexOf(":") + 1).trim();
+    return (value.length > 0 &&
+        !/(?:not selected|unselected|none|n\/a|tbd|todo|unknown)/iu.test(value));
+}
+function classifiedReferenceCount(index) {
+    return index.split(/\r?\n/u).filter((line) => {
+        if (/(?:none|not) selected/iu.test(line))
+            return false;
+        const matches = line.match(/\b(?:exact-target|constraint|inspiration)\b/giu);
+        return matches?.length === 1;
+    }).length;
 }
 function designMdTemplate() {
     return [

package/dist/lib/doctor.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import { readdir } from "node:fs/promises";
 import { DEFAULT_CONTEXT_FILE_SOFT_BUDGET_BYTES, DEFAULT_CONTEXT_TOTAL_SOFT_BUDGET_BYTES, inspectDefaultContextFootprint, } from "./context-default-footprint.js";
 import { readConfig } from "./config.js";
-import { inspectDesignAuthorityStatus } from "./design-md.js";
+import { inspectDesignAuthority } from "./design-md.js";
 import { harnessConfigPath, harnessRoot } from "./harness-root.js";
 import { pathExists } from "./fs.js";
 import { unsupportedSchemaMessage } from "./schema-guard.js";
@@ -63,13 +63,28 @@ export async function runDoctor(projectRoot) {
     catch (error) {
         report.warnings.push(`default Context footprint unavailable: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const designAuthority = await inspectDesignAuthorityStatus(projectRoot);
-    if (designAuthority === "unconfigured") {
+    const designAuthority = await inspectDesignAuthority(projectRoot);
+    if (designAuthority.status === "unconfigured") {
         report.info.push("design authority: unconfigured; DESIGN.md is a starter scaffold and does not authorize material production UI until project-specific tokens and exact-target/constraint/inspiration references are selected");
     }
     else {
-        report.info.push(`design authority: ${designAuthority}`);
+        report.info.push(`design authority: ${designAuthority.status}${designAuthority.status === "configured" ? "; project-level visual-system configuration only" : ""}`);
     }
+    if (designAuthority.status === "configured") {
+        report.info.push(`design authority signals: index=${designAuthority.has_authority_index ? "present" : "missing"}, token_source=${designAuthority.token_source_selected ? "selected" : "missing-or-unselected"}, classified_references=${designAuthority.classified_reference_count}`);
+        if (!designAuthority.has_authority_index) {
+            report.warnings.push("configured DESIGN.md has no Design Authority Index; add the authored token source/generation direction and classified exact-target/constraint/inspiration references when material UI depends on them");
+        }
+        else {
+            if (!designAuthority.token_source_selected) {
+                report.warnings.push("Design Authority Index has no selected authored token source; generated tokens or current CSS must not become competing visual authority");
+            }
+            if (designAuthority.classified_reference_count === 0) {
+                report.warnings.push("Design Authority Index has no classified durable design references; inspiration, constraints and exact targets remain undeclared for material surfaces");
+            }
+        }
+    }
+    report.info.push("surface implementation readiness: not inferred; inspect owning Product Surface/Screen/Control Context, selected target or constraints, authored token source and project-owned verification for each material surface");
     for (const location of await findUserSuperpowersSkills()) {
         report.warnings.push(`user-level using-superpowers Skill detected at ${location}. Tiny Context workflows do not depend on it and doctor will not modify global configuration. To disable it explicitly for Codex, remove/disable that plugin or add a matching [[skills.config]] entry with enabled = false in ${path.join(os.homedir(), ".codex", "config.toml")}.`);
     }

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

@@ -3,6 +3,7 @@ import { addDiagnosticError } from "./long-task-authoring-preflight-diagnostics.
 import { compileProductClaimCoverage, } from "./long-task-claims.js";
 import { hashDeclaredFiles, validateCounterfactualPaths, validateTechnicalPaths, validateVerificationInputSeparation, } from "./long-task-delivery-preflight.js";
 import { validateClaimEvidenceSensitivity } from "./long-task-evidence-sensitivity-policy.js";
+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 { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
@@ -56,7 +57,10 @@ export async function validateContractForActivation(options) {
         return emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context);
     const globalChecks = [];
     for (const check of contract.global.acceptance.checks) {
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace), null, check.key);
+        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);
         if (frozen)
             globalChecks.push(frozen);
     }
@@ -64,7 +68,10 @@ export async function validateContractForActivation(options) {
     for (const outcome of contract.outcomes) {
         const checks = [];
         for (const check of outcome.acceptance.checks) {
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace), outcome.key, check.key);
+            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);
             if (frozen)
                 checks.push(frozen);
         }
@@ -91,6 +98,10 @@ export async function validateContractForActivation(options) {
         await attempt(mode, diagnostics, () => validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, mode === "collect"
             ? (error) => addDiagnosticError(diagnostics, new Error(error))
             : undefined));
+        if (risk)
+            await attempt(mode, diagnostics, () => validateSemanticConformance(contract, risk.effective_level, allChecks, mode === "collect"
+                ? (error) => addDiagnosticError(diagnostics, new Error(error))
+                : undefined));
     }
     return {
         claims,

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

@@ -33,6 +33,7 @@ export function authoringRevisionPreview(contract, sourceHashes, sourceItems, co
         schema_version: "long-task-delivery-v2",
         task: active.authority_snapshot.task,
         source_claims: active.authority_snapshot.source_claims,
+        stages: active.authority_snapshot.stages,
         risk: active.authority_snapshot.risk,
         global: active.authority_snapshot.global,
         outcomes: active.authority_snapshot.outcomes,

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

@@ -66,14 +66,28 @@ function productClaimSemantics(contract) {
             });
         for (const control of outcome.product.controls)
             for (const [field, value] of [
+                ["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],
             ])
                 if (value.trim())
                     result.set(`${outcome.key}.control.${control.key}.${field}`, value);
@@ -89,13 +103,39 @@ function productClaimSemantics(contract) {
 function flattenProductSemantics(projection) {
     const fields = new Map([
         ["task.goal", projection.task_goal],
+        ["task.target_profile.key", projection.target_profile.key],
+        ["task.target_profile.description", projection.target_profile.description],
+        [
+            "task.target_profile.required_state",
+            projection.target_profile.required_state,
+        ],
+        [
+            "task.target_profile.required_target_refs",
+            [...projection.target_profile.required_target_refs].sort(),
+        ],
     ]);
+    for (const target of projection.execution_targets) {
+        const prefix = `task.execution_targets.${target.key}`;
+        fields.set(`${prefix}.description`, target.description);
+        fields.set(`${prefix}.role`, target.role);
+        fields.set(`${prefix}.runtime_family`, target.runtime_family);
+        fields.set(`${prefix}.root_entrypoint`, target.root_entrypoint);
+    }
+    for (const stage of projection.stages) {
+        const prefix = `stages.${stage.key}`;
+        fields.set(`${prefix}.title`, stage.title);
+        fields.set(`${prefix}.depends_on`, [...stage.depends_on].sort());
+        fields.set(`${prefix}.gate_outcome`, stage.gate_outcome);
+    }
     for (const item of projection.global_non_goals)
         fields.set(`global.product.non_goals.${item.key}`, item.statement);
     for (const outcome of projection.outcomes) {
         const prefix = `outcomes.${outcome.key}`;
         fields.set(`${prefix}.title`, outcome.title);
+        fields.set(`${prefix}.stage`, outcome.stage);
         fields.set(`${prefix}.observable_result`, outcome.observable_result);
+        fields.set(`${prefix}.success_path_required`, outcome.success_path_required);
+        fields.set(`${prefix}.degradation_path_required`, outcome.degradation_path_required);
         fields.set(`${prefix}.owner.label`, outcome.owner.label);
         fields.set(`${prefix}.owner.owner_surfaces`, outcome.owner.owner_surfaces);
         for (const requirement of outcome.requirements) {
@@ -104,14 +144,28 @@ function flattenProductSemantics(projection) {
         }
         for (const control of outcome.controls)
             for (const field of [
+                "surface",
+                "region",
                 "location",
+                "control_type",
+                "label_content",
+                "user_task",
+                "visibility",
+                "availability",
                 "trigger",
                 "input",
+                "validation",
+                "default_value",
+                "interaction",
+                "navigation_result",
                 "loading_state",
                 "empty_state",
                 "success_state",
                 "failure_state",
+                "recovery",
+                "permission",
                 "feedback",
+                "accessibility",
             ])
                 fields.set(`${prefix}.controls.${control.key}.${field}`, control[field]);
         for (const item of outcome.non_completing_outcomes)

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

@@ -1,7 +1,7 @@
 import type { AuthorityMaterialHashesV2, CompiledDeliveryContractV2, CompiledSourceItemV2, ContextAuthoritySnapshotV2, DeliveryContractV2, GlobalSemanticProjectionV2, NextAuthorityMaterialsV2, ProductSemanticProjectionV2 } from "./long-task-delivery-types.js";
-export declare function computeAuthorityMaterials(contract: Pick<DeliveryContractV2, "task" | "global" | "outcomes">, sourceHashes: Record<string, string>, sourceItems: CompiledSourceItemV2[], contextSnapshot: ContextAuthoritySnapshotV2): NextAuthorityMaterialsV2;
+export declare function computeAuthorityMaterials(contract: Pick<DeliveryContractV2, "task" | "global" | "outcomes" | "stages">, sourceHashes: Record<string, string>, sourceItems: CompiledSourceItemV2[], contextSnapshot: ContextAuthoritySnapshotV2): NextAuthorityMaterialsV2;
 export declare function compiledAuthorityMaterials(compiled: CompiledDeliveryContractV2): NextAuthorityMaterialsV2;
 export declare function authorityMaterialHashes(materials: NextAuthorityMaterialsV2): AuthorityMaterialHashesV2;
 export declare function authorityMaterialsChanged(previous: NextAuthorityMaterialsV2, next: NextAuthorityMaterialsV2): boolean;
-export declare function projectProductSemantics(contract: Pick<DeliveryContractV2, "task" | "global" | "outcomes">): ProductSemanticProjectionV2;
+export declare function projectProductSemantics(contract: Pick<DeliveryContractV2, "task" | "global" | "outcomes" | "stages">): ProductSemanticProjectionV2;
 export declare function projectGlobalSemantics(contract: Pick<DeliveryContractV2, "global">): GlobalSemanticProjectionV2;

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

@@ -28,11 +28,17 @@ export function authorityMaterialsChanged(previous, next) {
 export function projectProductSemantics(contract) {
     return {
         task_goal: contract.task.goal,
+        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),
         outcomes: [...contract.outcomes].sort(keyOrder).map((outcome) => ({
             key: outcome.key,
             title: outcome.title,
+            stage: outcome.stage,
             observable_result: outcome.product.observable_result,
+            success_path_required: outcome.product.success_path_required,
+            degradation_path_required: outcome.product.degradation_path_required,
             owner: {
                 label: outcome.product.owner.label,
                 owner_surfaces: [...outcome.product.owner_surfaces].sort(),
@@ -48,14 +54,28 @@ export function projectProductSemantics(contract) {
             })),
             controls: [...outcome.product.controls].sort(keyOrder).map((control) => ({
                 key: control.key,
+                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_state: control.loading_state,
                 empty_state: control.empty_state,
                 success_state: control.success_state,
                 failure_state: control.failure_state,
+                recovery: control.recovery,
+                permission: control.permission,
                 feedback: control.feedback,
+                accessibility: control.accessibility,
             })),
             non_completing_outcomes: keyedStatements(outcome.product.non_completing_outcomes),
         })),

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

@@ -1,6 +1,9 @@
 export type AuthorityFieldPolicy = "identity" | "semantic_user_review" | "proof_additive" | "runner_authority" | "input_coverage" | "output_requirement" | "scope" | "readiness_only" | "descriptive_non_authoritative";
 export declare const CHECK_AUTHORITY_POLICY: {
     key: "identity";
+    journey_roles: "proof_additive";
+    execution_target: "semantic_user_review";
+    scenario: "proof_additive";
     proof_surface: "semantic_user_review";
     runner: "runner_authority";
     verification_inputs: "proof_additive";
@@ -19,6 +22,8 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         source_paths: "scope";
         context_refs: "scope";
         context_snapshot_mode: "scope";
+        target_profile: "semantic_user_review";
+        execution_targets: "semantic_user_review";
     };
     readonly source_claim: {
         key: "identity";
@@ -46,6 +51,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     readonly outcome: {
         key: "identity";
         title: "descriptive_non_authoritative";
+        stage: "semantic_user_review";
         depends_on: "readiness_only";
         product: "semantic_user_review";
         technical: "semantic_user_review";
@@ -53,6 +59,8 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly outcome_product: {
         observable_result: "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";
@@ -71,14 +79,28 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly control: {
         key: "identity";
+        surface: "semantic_user_review";
+        region: "semantic_user_review";
         location: "semantic_user_review";
+        control_type: "semantic_user_review";
+        label_content: "semantic_user_review";
+        user_task: "semantic_user_review";
+        visibility: "semantic_user_review";
+        availability: "semantic_user_review";
         trigger: "semantic_user_review";
         input: "semantic_user_review";
+        validation: "semantic_user_review";
+        default_value: "semantic_user_review";
+        interaction: "semantic_user_review";
+        navigation_result: "semantic_user_review";
         loading_state: "semantic_user_review";
         empty_state: "semantic_user_review";
         success_state: "semantic_user_review";
         failure_state: "semantic_user_review";
+        recovery: "semantic_user_review";
+        permission: "semantic_user_review";
         feedback: "semantic_user_review";
+        accessibility: "semantic_user_review";
     };
     readonly outcome_technical: {
         obligations: "semantic_user_review";
@@ -114,6 +136,9 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly check: {
         key: "identity";
+        journey_roles: "proof_additive";
+        execution_target: "semantic_user_review";
+        scenario: "proof_additive";
         proof_surface: "semantic_user_review";
         runner: "runner_authority";
         verification_inputs: "proof_additive";
@@ -129,6 +154,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         criterion: "semantic_user_review";
         claims: "proof_additive";
         observation: "proof_additive";
+        evidence_capabilities: "proof_additive";
         operator: "proof_additive";
         expected: "proof_additive";
     };

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

@@ -5,6 +5,8 @@ const TASK_AUTHORITY_POLICY = {
     source_paths: "scope",
     context_refs: "scope",
     context_snapshot_mode: "scope",
+    target_profile: "semantic_user_review",
+    execution_targets: "semantic_user_review",
 };
 const SOURCE_CLAIM_AUTHORITY_POLICY = {
     key: "identity",
@@ -32,6 +34,7 @@ const GLOBAL_ACCEPTANCE_AUTHORITY_POLICY = {
 const OUTCOME_AUTHORITY_POLICY = {
     key: "identity",
     title: "descriptive_non_authoritative",
+    stage: "semantic_user_review",
     depends_on: "readiness_only",
     product: "semantic_user_review",
     technical: "semantic_user_review",
@@ -39,6 +42,8 @@ const OUTCOME_AUTHORITY_POLICY = {
 };
 const OUTCOME_PRODUCT_AUTHORITY_POLICY = {
     observable_result: "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",
@@ -57,14 +62,28 @@ const OWNER_AUTHORITY_POLICY = {
 };
 const CONTROL_AUTHORITY_POLICY = {
     key: "identity",
+    surface: "semantic_user_review",
+    region: "semantic_user_review",
     location: "semantic_user_review",
+    control_type: "semantic_user_review",
+    label_content: "semantic_user_review",
+    user_task: "semantic_user_review",
+    visibility: "semantic_user_review",
+    availability: "semantic_user_review",
     trigger: "semantic_user_review",
     input: "semantic_user_review",
+    validation: "semantic_user_review",
+    default_value: "semantic_user_review",
+    interaction: "semantic_user_review",
+    navigation_result: "semantic_user_review",
     loading_state: "semantic_user_review",
     empty_state: "semantic_user_review",
     success_state: "semantic_user_review",
     failure_state: "semantic_user_review",
+    recovery: "semantic_user_review",
+    permission: "semantic_user_review",
     feedback: "semantic_user_review",
+    accessibility: "semantic_user_review",
 };
 const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
     obligations: "semantic_user_review",
@@ -100,6 +119,9 @@ const OUTCOME_ACCEPTANCE_AUTHORITY_POLICY = {
 };
 export const CHECK_AUTHORITY_POLICY = {
     key: "identity",
+    journey_roles: "proof_additive",
+    execution_target: "semantic_user_review",
+    scenario: "proof_additive",
     proof_surface: "semantic_user_review",
     runner: "runner_authority",
     verification_inputs: "proof_additive",
@@ -115,6 +137,7 @@ const ASSERTION_AUTHORITY_POLICY = {
     criterion: "semantic_user_review",
     claims: "proof_additive",
     observation: "proof_additive",
+    evidence_capabilities: "proof_additive",
     operator: "proof_additive",
     expected: "proof_additive",
 };

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

@@ -0,0 +1,33 @@
+import type { CompiledCheckV2, CompiledDeliveryContractV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+export interface CheckRevisionAnalysis {
+    negative_assertions_removed: string[];
+    proof_surfaces_changed: string[];
+    runner_definitions_changed: string[];
+    verification_inputs_added: string[];
+    verification_inputs_removed_or_replaced: string[];
+    input_paths_added: string[];
+    input_paths_removed_or_narrowed: string[];
+    expected_output_paths_removed_or_weakened: string[];
+    artifacts_removed: string[];
+    environment_requirements_removed: string[];
+}
+export declare function analyzeCheckRevisions(beforeChecks: Map<string, CompiledCheckV2>, afterChecks: Map<string, CompiledCheckV2>): CheckRevisionAnalysis;
+export interface OutcomeRevisionAnalysis {
+    owner_paths_expanded: string[];
+    owner_context_refs_removed: string[];
+    expected_change_paths_expanded: string[];
+    allowed_paths_expanded: string[];
+    forbidden_paths_removed: string[];
+    bindings_removed_or_expanded: string[];
+    obligations_removed_or_weakened: string[];
+    rollback_or_recovery_weakened: string[];
+    counterfactuals_removed: string[];
+    population_weakened: string[];
+}
+export declare function analyzeOutcomeRevisions(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): OutcomeRevisionAnalysis;
+export declare function keyedAuthorityChanges(before: Array<{
+    key: string;
+}>, after: Array<{
+    key: string;
+}>): string[];
+export declare function selectedRevisionReasons(entries: Array<[reason: string, changed: boolean | unknown[]]>): string[];