project-tiny-context-harness 0.7.3 → 0.7.5

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

@@ -24,24 +24,52 @@ export function parseControls(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
         const row = object(item, itemLabel, ["key", "location"], [
+            "surface",
+            "region",
+            "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",
         ]);
         return {
             key: key(row.key, `${itemLabel}.key`),
+            surface: optionalText(row, "surface", itemLabel),
+            region: optionalText(row, "region", itemLabel),
             location: string(row.location, `${itemLabel}.location`),
+            control_type: optionalText(row, "control_type", itemLabel),
+            label_content: optionalText(row, "label_content", itemLabel),
+            user_task: optionalText(row, "user_task", itemLabel),
+            visibility: optionalText(row, "visibility", itemLabel),
+            availability: optionalText(row, "availability", itemLabel),
             trigger: optionalText(row, "trigger", itemLabel),
             input: optionalText(row, "input", itemLabel),
+            validation: optionalText(row, "validation", itemLabel),
+            default_value: optionalText(row, "default_value", itemLabel),
+            interaction: optionalText(row, "interaction", itemLabel),
+            navigation_result: optionalText(row, "navigation_result", itemLabel),
             loading_state: optionalText(row, "loading_state", itemLabel),
             empty_state: optionalText(row, "empty_state", itemLabel),
             success_state: optionalText(row, "success_state", itemLabel),
             failure_state: optionalText(row, "failure_state", itemLabel),
+            recovery: optionalText(row, "recovery", itemLabel),
+            permission: optionalText(row, "permission", itemLabel),
             feedback: optionalText(row, "feedback", itemLabel),
+            accessibility: optionalText(row, "accessibility", itemLabel),
         };
     });
 }

package/dist/lib/long-task-progress.js

@@ -76,6 +76,10 @@ export function checkIdentity(check) {
         artifact_globs: check.artifact_globs,
         positive_assertions: check.positive_assertions,
         negative_assertions: check.negative_assertions,
+        journey_roles: check.journey_roles,
+        execution_target: check.execution_target,
+        execution_target_definition: check.execution_target_definition,
+        scenario: check.scenario,
         environment_requirements: check.environment_requirements,
     }));
 }

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

@@ -1,4 +1,5 @@
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 export declare function parseTask(value: unknown): DeliveryContractV2["task"];
+export declare function parseStages(value: unknown): DeliveryContractV2["stages"];
 export declare function parseRisk(value: unknown): DeliveryContractV2["risk"];
 export declare function parseGlobal(value: unknown): DeliveryContractV2["global"];

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

@@ -1,6 +1,6 @@
 import { parseGlobalCounterfactuals } from "./long-task-acceptance-shape.js";
 import { parseCheck } from "./long-task-check-shape.js";
-import { array, key, literal, object, parseKeyedPaths, parseKeyedStatements, repositoryFiles, string, strings, } from "./long-task-delivery-shape.js";
+import { array, boolean, key, literal, object, parseKeyedPaths, parseKeyedStatements, repositoryFiles, string, strings, } from "./long-task-delivery-shape.js";
 const RISK_FACTS = [
     "public_api_or_schema_change",
     "persistent_data_change",
@@ -14,11 +14,59 @@ const RISK_FACTS = [
     "weak_observability",
 ];
 export function parseTask(value) {
-    const row = object(value, "task", ["id", "title", "goal", "source_paths", "context_refs"], ["context_snapshot_mode"]);
+    const row = object(value, "task", [
+        "id",
+        "title",
+        "goal",
+        "target_profile",
+        "execution_targets",
+        "source_paths",
+        "context_refs",
+    ], ["context_snapshot_mode"]);
+    const targetProfile = object(row.target_profile, "task.target_profile", [
+        "key",
+        "description",
+        "required_state",
+        "required_target_refs",
+    ]);
     return {
         id: key(row.id, "task.id"),
         title: string(row.title, "task.title"),
         goal: string(row.goal, "task.goal"),
+        target_profile: {
+            key: key(targetProfile.key, "task.target_profile.key"),
+            description: string(targetProfile.description, "task.target_profile.description"),
+            required_state: literal(targetProfile.required_state, [
+                "implementation_complete",
+                "target_profile_usable",
+                "production_release_ready",
+            ], "task.target_profile.required_state"),
+            required_target_refs: strings(targetProfile.required_target_refs, "task.target_profile.required_target_refs").map((item, index) => key(item, `task.target_profile.required_target_refs[${index}]`)),
+        },
+        execution_targets: array(row.execution_targets, "task.execution_targets").map((item, index) => {
+            const label = `task.execution_targets[${index}]`;
+            const target = object(item, label, [
+                "key",
+                "description",
+                "role",
+                "runtime_family",
+                "root_entrypoint",
+            ]);
+            return {
+                key: key(target.key, `${label}.key`),
+                description: string(target.description, `${label}.description`),
+                role: literal(target.role, ["product", "support", "observer"], `${label}.role`),
+                runtime_family: literal(target.runtime_family, [
+                    "browser",
+                    "native",
+                    "desktop",
+                    "service",
+                    "process",
+                    "external",
+                ], `${label}.runtime_family`),
+                root_entrypoint: string(target.root_entrypoint, `${label}.root_entrypoint`),
+            };
+        }),
         source_paths: repositoryFiles(row.source_paths, "task.source_paths"),
         context_refs: repositoryFiles(row.context_refs, "task.context_refs"),
         context_snapshot_mode: Object.hasOwn(row, "context_snapshot_mode")
@@ -26,6 +74,23 @@ export function parseTask(value) {
             : "referenced",
     };
 }
+export function parseStages(value) {
+    return array(value, "stages").map((item, index) => {
+        const label = `stages[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "title",
+            "depends_on",
+            "gate_outcome",
+        ]);
+        return {
+            key: key(row.key, `${label}.key`),
+            title: string(row.title, `${label}.title`),
+            depends_on: strings(row.depends_on, `${label}.depends_on`).map((entry, dependencyIndex) => key(entry, `${label}.depends_on[${dependencyIndex}]`)),
+            gate_outcome: key(row.gate_outcome, `${label}.gate_outcome`),
+        };
+    });
+}
 export function parseRisk(value) {
     const row = object(value, "risk", ["facts"], ["requested_level"]);
     const facts = object(row.facts, "risk.facts", [], [...RISK_FACTS]);
@@ -73,11 +138,27 @@ export function parseGlobal(value) {
             external_confirmations: Object.hasOwn(acceptance, "external_confirmations")
                 ? array(acceptance.external_confirmations, "global.acceptance.external_confirmations").map((item, index) => {
                     const label = `global.acceptance.external_confirmations[${index}]`;
-                    const entry = object(item, label, ["key", "description", "owner"]);
+                    const entry = object(item, label, [
+                        "key",
+                        "description",
+                        "owner",
+                        "kind",
+                        "impact_claims",
+                        "blocks_target",
+                    ]);
                     return {
                         key: key(entry.key, `${label}.key`),
                         description: string(entry.description, `${label}.description`),
                         owner: string(entry.owner, `${label}.owner`),
+                        kind: literal(entry.kind, [
+                            "functional_prerequisite",
+                            "field_validation",
+                            "production_release_gate",
+                            "commercial_activation",
+                            "expert_authority",
+                        ], `${label}.kind`),
+                        impact_claims: strings(entry.impact_claims, `${label}.impact_claims`),
+                        blocks_target: boolean(entry.blocks_target, `${label}.blocks_target`),
                     };
                 })
                 : [],

package/dist/lib/long-task-runner-environment.js

@@ -23,7 +23,7 @@ const BASE_ENVIRONMENT_KEYS = [
 ];
 export function runnerEnvironment(requirements) {
     const environment = {
-        TY_CONTEXT_CHECK_PROTOCOL: "long-task-check-result-v2",
+        TY_CONTEXT_CHECK_PROTOCOL: "long-task-check-result-v3",
     };
     for (const key of BASE_ENVIRONMENT_KEYS)
         copyEnvironmentValue(environment, key);

package/dist/lib/long-task-runner-freeze.d.ts

@@ -1,2 +1,2 @@
-import type { CompiledCheckV2, DeliveryCheckV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2): Promise<CompiledCheckV2>;
+import type { CompiledCheckV2, DeliveryCheckV2, ExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[]): Promise<CompiledCheckV2>;

package/dist/lib/long-task-runner-freeze.js

@@ -7,7 +7,7 @@ import { nearestRunnerFile, npmCliPath, npxCliPath, } from "./long-task-runner-f
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
 import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
-export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline) {
+export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets) {
     const prefix = outcomeKey ? `CHECK.${outcomeKey}` : "CHECK.GLOBAL";
     const expectedOutputs = check.expected_output_paths.map((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.expected_output_paths[${index}]`));
     for (const [index, pattern] of check.input_paths.entries()) {
@@ -30,6 +30,8 @@ export async function freezeDeliveryCheck(check, outcomeKey, repository, baselin
         evidence_adapter: evidenceAdapterForRunner(check.runner.type),
         runner: await freezeRunner(check, repository, cwd, target, verificationInputHashes),
         verification_input_hashes: verificationInputHashes,
+        execution_target_definition: executionTarget,
+        known_execution_targets: knownExecutionTargets,
     };
     return {
         ...compiled,

package/dist/lib/long-task-runtime-types.d.ts

@@ -1,6 +1,8 @@
 import type { DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, DeliveryRunnerV2, ProofSurface } from "./long-task-contract-types.js";
+import type { EvidenceCapabilityV2, ExecutionTargetV2 } from "./long-task-semantic-contract-types.js";
 import type { AuthorityHashesV2, ContextAuthoritySnapshotV2, InitialTaskBaseV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-authority-types.js";
 import type { EvidenceAdapter } from "./long-task-evidence-adapter-types.js";
+import type { EvidenceCapabilityRecordV2 } from "./long-task-evidence-capability-types.js";
 import type { EffectiveRiskLevel, RiskFactName } from "./long-task-risk-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
@@ -21,6 +23,8 @@ export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
     evidence_adapter: EvidenceAdapter;
     verification_input_hashes: Record<string, string>;
     raw_execution_identity: string;
+    execution_target_definition: ExecutionTargetV2;
+    known_execution_targets: ExecutionTargetV2[];
 }
 export interface ProductClaimV2 {
     id: string;
@@ -88,6 +92,7 @@ export interface CompiledDeliveryContractV2 {
     task: DeliveryContractV2["task"];
     risk: DeliveryContractV2["risk"];
     source_claims: DeliveryContractV2["source_claims"];
+    stages: DeliveryContractV2["stages"];
     global: Omit<DeliveryContractV2["global"], "acceptance"> & {
         acceptance: {
             checks: CompiledCheckV2[];
@@ -123,6 +128,8 @@ export interface AssertionResultV2 {
     passed: boolean;
     claims: string[];
     observation: string;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    evidence_complete: boolean;
     status: "passed" | "observation_missing" | "observation_type_mismatch" | "assertion_value_mismatch";
     expected?: unknown;
     actual?: unknown;
@@ -133,6 +140,7 @@ export interface RawCommandExecutionV2 {
     execution_status: "completed" | "blocked_external" | "infrastructure_error" | "invalid_evidence";
     exit_code: number;
     observations: Record<string, unknown>;
+    evidence_records: EvidenceCapabilityRecordV2[];
     stdout_sha256: string;
     stderr_sha256: string;
     attempts: number;
@@ -148,6 +156,7 @@ export interface CheckExecutionResultV2 {
     execution_identity: string;
     assertion_results: AssertionResultV2[];
     observations: Record<string, unknown>;
+    evidence_records: EvidenceCapabilityRecordV2[];
     artifact_hashes: Record<string, string>;
     claim_proofs: ClaimProofV2[];
     findings: LongTaskFindingV2[];
@@ -185,12 +194,16 @@ export interface TargetedVerificationResultV2 {
     completed_at: string;
 }
 export type OutcomeStatusV2 = "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
+export type StageStatusV2 = "locked" | "ready" | "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
 export interface FinalReceiptV2 {
     schema_version: "long-task-final-receipt-v2";
     receipt_sha256: string;
     authority_scope: "audit_only";
     reusable_for_acceptance: false;
     workflow_status: "machine_accepted" | "machine_accepted_external_pending" | "needs_work" | "blocked_external";
+    target_profile: DeliveryContractV2["task"]["target_profile"];
+    target_state: DeliveryContractV2["task"]["target_profile"]["required_state"] | "not_accepted" | "blocked_external";
+    stage_results: Record<string, "passed" | "failed" | "blocked_external" | "blocked_dependency">;
     compiled_identity: string;
     contract_sha256: string;
     snapshot_sha256: string;

package/dist/lib/long-task-semantic-contract-types.d.ts

@@ -0,0 +1,36 @@
+export interface KeyedStatementV2 {
+    key: string;
+    statement: string;
+}
+export type ExternalConfirmationKindV2 = "functional_prerequisite" | "field_validation" | "production_release_gate" | "commercial_activation" | "expert_authority";
+export type TargetCompletionStateV2 = "implementation_complete" | "target_profile_usable" | "production_release_ready";
+export type ExecutionTargetRuntimeFamilyV2 = "browser" | "native" | "desktop" | "service" | "process" | "external";
+export interface TargetProfileV2 {
+    key: string;
+    description: string;
+    required_state: TargetCompletionStateV2;
+    required_target_refs: string[];
+}
+export interface ExecutionTargetV2 {
+    key: string;
+    description: string;
+    role: "product" | "support" | "observer";
+    runtime_family: ExecutionTargetRuntimeFamilyV2;
+    root_entrypoint: string;
+}
+export interface DeliveryStageV2 {
+    key: string;
+    title: string;
+    depends_on: string[];
+    gate_outcome: string;
+}
+export type DeliveryJourneyRoleV2 = "success" | "degradation" | "recovery" | "stage_gate" | "conformance";
+export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "target_runtime" | "input_variation";
+export interface CheckExecutionTargetV2 {
+    target_ref: string;
+    entrypoint: "root" | "internal";
+}
+export interface DeliveryScenarioV2 {
+    given: KeyedStatementV2[];
+    when: KeyedStatementV2[];
+}

package/dist/lib/long-task-semantic-contract-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/long-task-semantic-drift-migration.d.ts

@@ -0,0 +1,3 @@
+export declare function semanticDriftMigrationFields(value: unknown): string[];
+export declare function semanticDriftOutcomeMigrationFields(value: unknown, label: string): string[];
+export declare function assertNoSemanticDriftMigration(fields: string[]): void;

package/dist/lib/long-task-semantic-drift-migration.js

@@ -0,0 +1,68 @@
+export function semanticDriftMigrationFields(value) {
+    const root = row(value);
+    if (!root || root.schema_version !== "long-task-delivery-v2")
+        return [];
+    const missing = [];
+    required(root, "$", ["stages"], missing);
+    const task = row(root.task);
+    if (task) {
+        required(task, "task", ["target_profile", "execution_targets"], missing);
+        const profile = row(task.target_profile);
+        if (profile)
+            required(profile, "task.target_profile", ["required_target_refs"], missing);
+    }
+    for (const [index, outcome] of rows(root.outcomes).entries())
+        collectOutcome(outcome, `outcomes[${index}]`, missing);
+    const global = row(root.global);
+    const globalAcceptance = row(global?.acceptance);
+    collectChecks(globalAcceptance?.checks, "global.acceptance.checks", missing);
+    for (const [index, confirmation] of rows(globalAcceptance?.external_confirmations).entries())
+        required(confirmation, `global.acceptance.external_confirmations[${index}]`, ["kind", "impact_claims", "blocks_target"], missing);
+    return [...new Set(missing)].sort();
+}
+export function semanticDriftOutcomeMigrationFields(value, label) {
+    const missing = [];
+    const outcome = row(value);
+    if (outcome)
+        collectOutcome(outcome, label, missing);
+    return [...new Set(missing)].sort();
+}
+export function assertNoSemanticDriftMigration(fields) {
+    if (!fields.length)
+        return;
+    const detail = fields.slice(0, 24).join(",");
+    const suffix = fields.length > 24 ? `,+${fields.length - 24}-more` : "";
+    throw new Error(`long_task_delivery_v2_semantic_drift_migration_required:${detail}${suffix}`);
+}
+function collectOutcome(outcome, label, missing) {
+    required(outcome, label, ["stage"], missing);
+    const product = row(outcome.product);
+    if (product)
+        required(product, `${label}.product`, ["success_path_required", "degradation_path_required"], missing);
+    const acceptance = row(outcome.acceptance);
+    collectChecks(acceptance?.checks, `${label}.acceptance.checks`, missing);
+}
+function collectChecks(value, label, missing) {
+    for (const [index, check] of rows(value).entries()) {
+        const checkLabel = `${label}[${index}]`;
+        required(check, checkLabel, ["journey_roles", "execution_target", "scenario"], missing);
+        for (const polarity of ["positive_assertions", "negative_assertions"])
+            for (const [assertionIndex, assertion] of rows(check[polarity]).entries())
+                required(assertion, `${checkLabel}.${polarity}[${assertionIndex}]`, ["evidence_capabilities"], missing);
+    }
+}
+function required(value, label, keys, missing) {
+    for (const key of keys)
+        if (!Object.hasOwn(value, key))
+            missing.push(`${label}.${key}`);
+}
+function rows(value) {
+    return Array.isArray(value)
+        ? value.map(row).filter((item) => item !== null)
+        : [];
+}
+function row(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}

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

@@ -3,6 +3,7 @@ export declare function object(value: unknown, label: string, required: string[]
 export declare function array(value: unknown, label: string): unknown[];
 export declare function string(value: unknown, label: string): string;
 export declare function text(value: unknown, label: string): string;
+export declare function boolean(value: unknown, label: string): boolean;
 export declare function strings(value: unknown, label: string): string[];
 export declare function repositoryFile(value: unknown, label: string): string;
 export declare function repositoryFiles(value: unknown, label: string): string[];
@@ -14,4 +15,6 @@ export declare function literal<T extends string>(value: unknown, allowed: reado
 export declare function key(value: unknown, label: string): string;
 export declare function nullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
 export declare const PROOF_SURFACES: readonly ["ui_browser", "runtime_behavior", "api_contract", "data_state", "security_boundary", "population_coverage", "implementation_structure"];
+export declare const JOURNEY_ROLES: readonly ["success", "degradation", "recovery", "stage_gate", "conformance"];
+export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "external_side_effect", "failure_injection", "visual_render", "target_runtime", "input_variation"];
 export declare function fail(label: string, message: string): never;

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

@@ -27,6 +27,11 @@ export function text(value, label) {
         fail(label, "must be a string");
     return value;
 }
+export function boolean(value, label) {
+    if (typeof value !== "boolean")
+        fail(label, "must be a boolean");
+    return value;
+}
 export function strings(value, label) {
     return array(value, label).map((item, index) => string(item, `${label}[${index}]`));
 }
@@ -76,6 +81,26 @@ export const PROOF_SURFACES = [
     "population_coverage",
     "implementation_structure",
 ];
+export const JOURNEY_ROLES = [
+    "success",
+    "degradation",
+    "recovery",
+    "stage_gate",
+    "conformance",
+];
+export const EVIDENCE_CAPABILITIES = [
+    "presence",
+    "interaction_trace",
+    "state_delta",
+    "cross_surface_consistency",
+    "durable_readback",
+    "boundary_invocation",
+    "external_side_effect",
+    "failure_injection",
+    "visual_render",
+    "target_runtime",
+    "input_variation",
+];
 export function fail(label, message) {
     throw new Error(`delivery_contract_invalid:${label}:${message}`);
 }

package/dist/lib/long-task-source-target-index.js

@@ -59,14 +59,28 @@ function target(ref, kind, text, outcomeKey, scope) {
 }
 function controlFields(control) {
     return [
+        ["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],
     ];
 }
 export function sourceKindForTarget(target) {

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

@@ -0,0 +1,4 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+type Reporter = (message: string) => void;
+export declare function validateDeliveryStages(contract: DeliveryContractV2, report?: Reporter): void;
+export {};

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

@@ -0,0 +1,120 @@
+export function validateDeliveryStages(contract, report) {
+    unique(contract.stages.map((stage) => stage.key), "stage_key_duplicate", report);
+    const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
+    const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
+    for (const stage of contract.stages) {
+        for (const dependency of stage.depends_on) {
+            if (dependency === stage.key)
+                issue(report, "stage_dependency_self", stage.key);
+            else if (!stages.has(dependency))
+                issue(report, "stage_dependency_unknown", `${stage.key}:${dependency}`);
+        }
+        const gate = outcomes.get(stage.gate_outcome);
+        if (!gate)
+            issue(report, "stage_gate_outcome_unknown", `${stage.key}:${stage.gate_outcome}`);
+        else if (gate.stage !== stage.key)
+            issue(report, "stage_gate_outcome_mismatch", `${stage.key}:${gate.key}`);
+    }
+    for (const outcome of contract.outcomes)
+        if (!stages.has(outcome.stage))
+            issue(report, "outcome_stage_unknown", `${outcome.key}:${outcome.stage}`);
+    validateStageCycles(contract, report);
+    validateStageGateClosure(contract, report);
+}
+function validateStageCycles(contract, report) {
+    const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (key) => {
+        if (visiting.has(key)) {
+            issue(report, "stage_dependency_cycle", key);
+            return;
+        }
+        if (visited.has(key))
+            return;
+        visiting.add(key);
+        for (const dependency of stages.get(key)?.depends_on ?? [])
+            if (stages.has(dependency))
+                visit(dependency);
+        visiting.delete(key);
+        visited.add(key);
+    };
+    for (const stage of stages.keys())
+        visit(stage);
+}
+function validateStageGateClosure(contract, report) {
+    const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
+    for (const stage of contract.stages) {
+        const gate = outcomes.get(stage.gate_outcome);
+        if (!gate || gate.stage !== stage.key)
+            continue;
+        for (const outcome of contract.outcomes.filter((candidate) => candidate.stage === stage.key && candidate.key !== gate.key))
+            if (!outcomeDependsOn(gate.key, outcome.key, outcomes))
+                issue(report, "stage_gate_missing_outcome_dependency", `${stage.key}:${gate.key}:${outcome.key}`);
+        for (const dependency of stage.depends_on) {
+            const dependencyGate = contract.stages.find((candidate) => candidate.key === dependency)?.gate_outcome;
+            if (!dependencyGate)
+                continue;
+            for (const outcome of contract.outcomes.filter((candidate) => candidate.stage === stage.key))
+                if (!outcomeDependsOn(outcome.key, dependencyGate, outcomes))
+                    issue(report, "stage_outcome_missing_gate_dependency", `${stage.key}:${outcome.key}:${dependencyGate}`);
+        }
+        const stageGateChecks = gate.acceptance.checks.filter((check) => check.journey_roles.includes("stage_gate"));
+        if (!stageGateChecks.length)
+            issue(report, "stage_gate_check_required", `${stage.key}:${gate.key}`);
+        else if (!stageGateChecks.some((check) => provesGate(check, gate)))
+            issue(report, "stage_gate_target_runtime_result_required", `${stage.key}:${gate.key}`);
+        for (const targetRef of contract.task.target_profile.required_target_refs)
+            if (!stageGateChecks.some((check) => check.execution_target.target_ref === targetRef &&
+                check.execution_target.entrypoint === "root" &&
+                provesGate(check, gate)))
+                issue(report, "stage_gate_required_target_proof_missing", `${stage.key}:${targetRef}`);
+        const stageOutcomes = contract.outcomes.filter((candidate) => candidate.stage === stage.key);
+        if (stageOutcomes.length > 1 &&
+            !stageGateChecks.some((check) => [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("cross_surface_consistency"))))
+            issue(report, "stage_gate_cross_surface_consistency_required", `${stage.key}:${stageOutcomes.map((outcome) => outcome.key).join(",")}`);
+    }
+    for (const outcome of contract.outcomes)
+        for (const check of outcome.acceptance.checks)
+            if (check.journey_roles.includes("stage_gate") &&
+                !contract.stages.some((stage) => stage.gate_outcome === outcome.key))
+                issue(report, "stage_gate_role_on_non_gate", `${outcome.key}:${check.key}`);
+}
+function provesGate(check, gate) {
+    const assertions = [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ];
+    const provesResult = assertions.some((assertion) => assertion.claims.includes("result")) ||
+        (gate.acceptance.population?.check_key === check.key &&
+            gate.acceptance.population.claims.includes("result"));
+    return (provesResult &&
+        assertions.some((assertion) => assertion.evidence_capabilities.includes("target_runtime")));
+}
+function outcomeDependsOn(start, target, outcomes) {
+    const seen = new Set();
+    const visit = (key) => {
+        if (key === target)
+            return true;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return (outcomes.get(key)?.depends_on ?? []).some(visit);
+    };
+    return visit(start);
+}
+function unique(values, code, report) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            issue(report, code, value);
+        seen.add(value);
+    }
+}
+function issue(report, code, detail) {
+    const message = `delivery_contract_invalid:${code}:${detail}`;
+    if (report)
+        report(message);
+    else
+        throw new Error(message);
+}

package/dist/lib/long-task-status-projection.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledDeliveryContractV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, ProgressRecordV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import type { CompiledDeliveryContractV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, ProgressRecordV2, StageStatusV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 interface StatusProjectionInputV2 {
     compiled: CompiledDeliveryContractV2;
     manifest: WorkspaceManifestV2;
@@ -11,7 +11,10 @@ export type AuditGateStatusV2 = "no_final_gate" | "last_gate_passed" | "last_gat
 export declare function projectDeliveryStatus(input: StatusProjectionInputV2): {
     finalResult: AuditGateStatusV2;
     finalWorkflowStatus: FinalReceiptV2["workflow_status"] | null;
+    targetState: FinalReceiptV2["target_state"];
     outcomes: Record<string, OutcomeStatusV2>;
+    stages: Record<string, StageStatusV2>;
+    readyStages: string[];
     readyOutcomes: string[];
     needsReverify: string[];
     progressPassing: string[];