project-tiny-context-harness 0.7.3 → 0.7.4

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

@@ -89,13 +89,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) {

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(),

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";
@@ -114,6 +122,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 +140,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",
@@ -100,6 +105,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 +123,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[];

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

@@ -0,0 +1,91 @@
+import { addedInputPaths, addedVerificationInputs, bindingReductions, changedRunnerFields, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, rollbackReductions, same, } from "./long-task-authority-revision-details.js";
+export function analyzeCheckRevisions(beforeChecks, afterChecks) {
+    const result = {
+        negative_assertions_removed: [],
+        proof_surfaces_changed: [],
+        runner_definitions_changed: [],
+        verification_inputs_added: [],
+        verification_inputs_removed_or_replaced: [],
+        input_paths_added: [],
+        input_paths_removed_or_narrowed: [],
+        expected_output_paths_removed_or_weakened: [],
+        artifacts_removed: [],
+        environment_requirements_removed: [],
+    };
+    for (const [identity, before] of beforeChecks) {
+        const after = afterChecks.get(identity);
+        if (!after)
+            continue;
+        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 (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));
+        result.verification_inputs_added.push(...addedVerificationInputs(identity, before, after));
+        result.verification_inputs_removed_or_replaced.push(...removedOrReplacedVerificationInputs(identity, before, after));
+        result.input_paths_added.push(...addedInputPaths(identity, before, after));
+        result.input_paths_removed_or_narrowed.push(...removedOrNarrowedInputPaths(identity, before, after));
+        result.expected_output_paths_removed_or_weakened.push(...removedOrWeakenedExpectedOutputPaths(identity, before, after));
+        result.artifacts_removed.push(...removedExactValues(identity, before.artifact_globs, after.artifact_globs));
+        result.environment_requirements_removed.push(...removedStructuredValues(identity, before.environment_requirements, after.environment_requirements));
+    }
+    return result;
+}
+export function analyzeOutcomeRevisions(previous, next) {
+    const result = {
+        owner_paths_expanded: [],
+        owner_context_refs_removed: [],
+        expected_change_paths_expanded: [],
+        allowed_paths_expanded: [],
+        forbidden_paths_removed: removedGlobalForbiddenPaths(previous, next),
+        bindings_removed_or_expanded: [],
+        obligations_removed_or_weakened: [],
+        rollback_or_recovery_weakened: [],
+        counterfactuals_removed: globalCounterfactualReductions(previous, next),
+        population_weakened: [],
+    };
+    const previousOutcomes = new Map(previous.outcomes.map((outcome) => [outcome.key, outcome]));
+    for (const after of next.outcomes) {
+        const before = previousOutcomes.get(after.key);
+        if (!before)
+            continue;
+        result.owner_paths_expanded.push(...expandedPatterns(after.key, before.product.owner.path_globs, after.product.owner.path_globs));
+        result.owner_context_refs_removed.push(...removedExactValues(after.key, before.product.owner.context_refs, after.product.owner.context_refs));
+        result.expected_change_paths_expanded.push(...expandedPatterns(after.key, before.technical.expected_change_paths, after.technical.expected_change_paths));
+        result.allowed_paths_expanded.push(...expandedPatterns(after.key, before.technical.allowed_support_paths, after.technical.allowed_support_paths));
+        result.forbidden_paths_removed.push(...removedExactValues(after.key, before.technical.forbidden_paths, after.technical.forbidden_paths));
+        result.bindings_removed_or_expanded.push(...bindingReductions(before, after));
+        result.obligations_removed_or_weakened.push(...obligationReductions(before, after));
+        result.rollback_or_recovery_weakened.push(...rollbackReductions(before, after));
+        result.counterfactuals_removed.push(...counterfactualReductions(before, after));
+        if (before.acceptance.population &&
+            (!after.acceptance.population ||
+                !same(before.acceptance.population, after.acceptance.population)))
+            result.population_weakened.push(after.key);
+    }
+    return result;
+}
+export function keyedAuthorityChanges(before, after) {
+    const beforeByKey = new Map(before.map((item) => [item.key, item]));
+    const afterByKey = new Map(after.map((item) => [item.key, item]));
+    return [
+        ...before
+            .filter((item) => !afterByKey.has(item.key))
+            .map((item) => `${item.key}:removed`),
+        ...after
+            .filter((item) => !beforeByKey.has(item.key))
+            .map((item) => `${item.key}:added`),
+        ...before
+            .filter((item) => {
+            const candidate = afterByKey.get(item.key);
+            return candidate !== undefined && !same(item, candidate);
+        })
+            .map((item) => `${item.key}:changed`),
+    ].sort();
+}
+export function selectedRevisionReasons(entries) {
+    return entries
+        .filter(([, changed]) => Array.isArray(changed) ? changed.length > 0 : changed)
+        .map(([reason]) => reason);
+}