project-tiny-context-harness 0.7.3 → 0.7.4

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-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[];

package/dist/lib/long-task-status-projection.js

@@ -1,13 +1,21 @@
 import { progressRecordFresh } from "./long-task-progress.js";
 export function projectDeliveryStatus(input) {
     const outcomes = projectOutcomes(input);
+    const stages = projectStages(input.compiled, outcomes);
     return {
         finalResult: projectFinalResult(input),
         finalWorkflowStatus: receiptFresh(input)
             ? input.receipt.workflow_status
             : null,
+        targetState: receiptFresh(input)
+            ? (input.receipt.target_state ?? legacyTargetState(input.receipt))
+            : "not_accepted",
         outcomes,
-        readyOutcomes: readyOutcomes(input.compiled, outcomes),
+        stages,
+        readyStages: Object.entries(stages)
+            .filter(([, status]) => status === "ready")
+            .map(([key]) => key),
+        readyOutcomes: readyOutcomes(input.compiled, outcomes, stages),
         needsReverify: Object.entries(outcomes)
             .filter(([, status]) => ["unverified", "progress_stale", "progress_failing"].includes(status))
             .map(([key]) => key),
@@ -88,12 +96,64 @@ function projectFindings(input) {
     }
     return findings;
 }
-function readyOutcomes(compiled, outcomes) {
+function readyOutcomes(compiled, outcomes, stages) {
     return compiled.outcomes
-        .filter((outcome) => outcomes[outcome.key] !== "progress_passing" &&
+        .filter((outcome) => stages[outcome.stage] !== "locked" &&
+        stages[outcome.stage] !== "progress_passing" &&
+        outcomes[outcome.key] !== "progress_passing" &&
         outcome.depends_on.every((dependency) => outcomes[dependency] === "progress_passing"))
         .map((outcome) => outcome.key);
 }
+function legacyTargetState(receipt) {
+    if (receipt.workflow_status === "machine_accepted" ||
+        receipt.workflow_status === "machine_accepted_external_pending")
+        return receipt.target_profile.required_state;
+    return receipt.workflow_status === "blocked_external"
+        ? "blocked_external"
+        : "not_accepted";
+}
+function projectStages(compiled, outcomes) {
+    const result = {};
+    const remaining = new Set(compiled.stages.map((stage) => stage.key));
+    while (remaining.size) {
+        let advanced = false;
+        for (const stage of compiled.stages) {
+            if (!remaining.has(stage.key))
+                continue;
+            if (stage.depends_on.some((dependency) => remaining.has(dependency)))
+                continue;
+            const prerequisitesPassing = stage.depends_on.every((dependency) => result[dependency] === "progress_passing");
+            if (!prerequisitesPassing)
+                result[stage.key] = "locked";
+            else {
+                const owned = compiled.outcomes
+                    .filter((outcome) => outcome.stage === stage.key)
+                    .map((outcome) => outcomes[outcome.key]);
+                const gate = outcomes[stage.gate_outcome];
+                result[stage.key] = owned.includes("progress_failing")
+                    ? "progress_failing"
+                    : owned.includes("blocked_external")
+                        ? "blocked_external"
+                        : owned.includes("progress_stale")
+                            ? "progress_stale"
+                            : gate === "progress_passing" &&
+                                owned.every((status) => status === "progress_passing")
+                                ? "progress_passing"
+                                : owned.every((status) => status === "unverified")
+                                    ? "ready"
+                                    : "unverified";
+            }
+            remaining.delete(stage.key);
+            advanced = true;
+        }
+        if (!advanced) {
+            for (const stage of remaining)
+                result[stage] = "locked";
+            break;
+        }
+    }
+    return result;
+}
 function projectFinalResult(input) {
     if (!input.receipt)
         return "no_final_gate";

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

@@ -1,5 +1,5 @@
 import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2 } from "./long-task-delivery-types.js";
+import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, StageStatusV2, TargetProfileV2 } from "./long-task-delivery-types.js";
 import { type AuditGateStatusV2 } from "./long-task-status-projection.js";
 export interface DeliveryStatusV2 {
     schema_version: "long-task-status-v2";
@@ -13,7 +13,11 @@ export interface DeliveryStatusV2 {
     final_result: AuditGateStatusV2;
     final_workflow_status: FinalReceiptV2["workflow_status"] | null;
     external_confirmations: ExternalConfirmationV2[];
+    target_profile: TargetProfileV2;
+    target_state: FinalReceiptV2["target_state"];
     outcomes: Record<string, OutcomeStatusV2>;
+    stages: Record<string, StageStatusV2>;
+    ready_stages: string[];
     ready_outcomes: string[];
     ready_for_implementation: string[];
     needs_reverify: string[];
@@ -31,6 +35,9 @@ export interface StopCheckDeliveryResultV2 {
     reason: string;
     workflow_status?: FinalReceiptV2["workflow_status"];
     external_confirmations?: ExternalConfirmationV2[];
+    target_profile?: TargetProfileV2;
+    target_state?: FinalReceiptV2["target_state"];
+    stage_results?: FinalReceiptV2["stage_results"];
     acceptance_scope?: "declared_machine_authority";
     native_goal_effect?: "none";
     message?: string;
@@ -39,6 +46,9 @@ export interface CloseDeliveryResultV2 {
     status: "closed";
     workflow_status: Extract<FinalReceiptV2["workflow_status"], "machine_accepted" | "machine_accepted_external_pending">;
     external_confirmations: ExternalConfirmationV2[];
+    target_profile: TargetProfileV2;
+    target_state: FinalReceiptV2["target_state"];
+    stage_results: FinalReceiptV2["stage_results"];
     acceptance_scope: "declared_machine_authority";
     closed_scope: "machine_authority";
     native_goal_effect: "none";

package/dist/lib/long-task-status-v2.js

@@ -53,7 +53,11 @@ async function readDeliveryStatusForAuthority(active) {
         final_result: projection.finalResult,
         final_workflow_status: projection.finalWorkflowStatus,
         external_confirmations: compiled.global.acceptance.external_confirmations,
+        target_profile: compiled.task.target_profile,
+        target_state: projection.targetState,
         outcomes: projection.outcomes,
+        stages: projection.stages,
+        ready_stages: projection.readyStages,
         ready_outcomes: projection.readyOutcomes,
         ready_for_implementation: projection.readyOutcomes,
         needs_reverify: projection.needsReverify,
@@ -89,6 +93,8 @@ export async function resumeDeliveryTask(workdir) {
             id: compiled.task.id,
             title: compiled.task.title,
             goal: compiled.task.goal,
+            target_profile: compiled.task.target_profile,
+            execution_targets: compiled.task.execution_targets,
         },
         contract_identity: compiled.compiled_identity,
         authority_revision: compiled.authority_revision,
@@ -101,7 +107,11 @@ export async function resumeDeliveryTask(workdir) {
         last_gate: status.final_result,
         final_workflow_status: status.final_workflow_status,
         external_confirmations: status.external_confirmations,
+        target_profile: status.target_profile,
+        target_state: status.target_state,
         outcomes: status.outcomes,
+        stages: status.stages,
+        ready_stages: status.ready_stages,
         ready_outcomes: status.ready_outcomes,
         ready_for_implementation: status.ready_for_implementation,
         needs_reverify: status.needs_reverify,
@@ -216,6 +226,9 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
                         reason: "active_authority_changed_after_final_gate",
                         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,
                         message: "Active Authority changed after the Live Final Gate; the accepted identity was not cleared.",
                     };
                 throw error;
@@ -225,9 +238,12 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
                 reason: result.workflow_status,
                 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: "declared_machine_authority",
                 native_goal_effect: "none",
-                message: acceptedScopeMessage(result.workflow_status, result.external_confirmations),
+                message: acceptedScopeMessage(result.workflow_status, result.external_confirmations, result.target_profile),
             };
         }
         return {
@@ -235,6 +251,9 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
             reason: `live_final_gate_${result.workflow_status}`,
             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,
             message: messageText ||
                 result.findings.at(-1)?.next_action ||
                 "Repair the failing Check and rerun Stop.",
@@ -274,13 +293,16 @@ export async function closeDeliveryTask(workdir) {
         status: "closed",
         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: "declared_machine_authority",
         closed_scope: "machine_authority",
         native_goal_effect: "none",
     };
 }
-function acceptedScopeMessage(workflowStatus, confirmations) {
-    const scope = "Declared machine Authority accepted and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.";
+function acceptedScopeMessage(workflowStatus, confirmations, targetProfile) {
+    const scope = `Declared machine Authority accepted for target ${targetProfile.key}:${targetProfile.required_state} and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.`;
     if (workflowStatus === "machine_accepted")
         return scope;
     const pending = confirmations

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

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