project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/long-task-context-authority-topology.js

@@ -1,3 +1,4 @@
+import { compareUtf8Paths, normalizeContextPath, } from "./context-catalog/catalog-paths.js";
 import { canonicalJson, sha256Hex } from "./strict-codec.js";
 /**
  * Hashes only manifest structure that can change the currently selected
@@ -11,13 +12,14 @@ export function contextAuthorityTopologyHash(manifest, selectedFiles) {
             .filter((area) => selected.has(normalizeRepoPath(area.context)))
             .map(({ line: _line, default: _default, forbidden_runtime_dependencies, kind, ...area }) => ({
             ...area,
+            id: area.id.normalize("NFC"),
             ...(kind === undefined ? {} : { kind }),
             context: normalizeRepoPath(area.context),
             forbidden_runtime_dependencies: [
                 ...forbidden_runtime_dependencies,
             ].sort(),
         }))
-            .sort((left, right) => left.id.localeCompare(right.id)),
+            .sort((left, right) => compareUtf8Paths(left.id, right.id)),
         contexts: manifest.contexts
             .filter((context) => selected.has(normalizeRepoPath(context.path)))
             .map(({ line: _line, read_when: _readWhen, read_policy: _readPolicy, triggers: _triggers, default_children, ...context }) => ({
@@ -26,12 +28,12 @@ export function contextAuthorityTopologyHash(manifest, selectedFiles) {
             default_children: [...default_children]
                 .map(normalizeRepoPath)
                 .filter((child) => selected.has(child))
-                .sort(),
+                .sort(compareUtf8Paths),
         }))
-            .sort((left, right) => left.path.localeCompare(right.path)),
+            .sort((left, right) => compareUtf8Paths(left.path, right.path)),
     };
     return sha256Hex(canonicalJson(topology));
 }
 function normalizeRepoPath(value) {
-    return value.replace(/\\/gu, "/").replace(/^\.\//u, "");
+    return normalizeContextPath(value);
 }

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

@@ -3,7 +3,7 @@ import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./l
 import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
 import type { ApplicableKeyedStatementV2, CheckExecutionTargetV2, ClaimApplicabilityV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
-import type { SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
+import type { SemanticFactGlobalBindingsV2, SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
     refs: string[];
@@ -26,16 +26,42 @@ export type SourceClaimDispositionV2 = {
     type: "decision_required";
     reason: string;
 };
+export type ExternalJudgmentBasisKindV2 = "subjective_preference" | "expert_assessment" | "authorization";
+export interface SourceClaimJudgmentBasisV2 {
+    kind: ExternalJudgmentBasisKindV2;
+    claim_ref: string;
+    applicability_refs: string[];
+}
 export interface SourceClaimV2 {
     key: string;
     source_ref: string;
     statement: string;
     disposition: SourceClaimDispositionV2;
+    judgment_basis?: SourceClaimJudgmentBasisV2;
 }
 export interface KeyedPathV2 {
     key: string;
     path: string;
 }
+export type ExternalConfirmationIdentityAssuranceV2 = {
+    scheme: "ed25519";
+    key_id: string;
+    public_key_ref: string;
+} | {
+    scheme: "declared_only";
+};
+export type CompiledExternalConfirmationIdentityAssuranceV2 = {
+    scheme: "ed25519";
+    key_id: string;
+    public_key_ref: string;
+    public_key_sha256: string;
+} | {
+    scheme: "declared_only";
+};
+export interface ExternalConfirmationJudgmentBasisV2 {
+    kind: ExternalJudgmentBasisKindV2;
+    source_ref: string;
+}
 export interface ExternalConfirmationV2 {
     key: string;
     description: string;
@@ -43,6 +69,29 @@ export interface ExternalConfirmationV2 {
     kind: ExternalConfirmationKindV2;
     impact_claims: string[];
     blocks_target: boolean;
+    actor?: {
+        id: string;
+        role: string;
+        authority_kind: "human" | "expert" | "external_system";
+        identity_assurance?: ExternalConfirmationIdentityAssuranceV2;
+    };
+    target_ref?: string;
+    environment_identity?: string;
+    scenario?: DeliveryScenarioV2;
+    evidence_requirements?: KeyedStatementV2[];
+    obligations?: Array<{
+        key: string;
+        claim_ref: string;
+        applicability_ref: string;
+        fact_ref: string | null;
+        proof_ref: string | null;
+        method: string;
+        proof_surface: ProofSurface;
+        evidence_capabilities: EvidenceCapabilityV2[];
+        expected_authority_ref: string;
+        result_kind: "actual" | "judgment";
+        judgment_basis?: ExternalConfirmationJudgmentBasisV2;
+    }>;
 }
 export type ProofSurface = "ui_browser" | "runtime_behavior" | "api_contract" | "data_state" | "security_boundary" | "population_coverage" | "implementation_structure";
 export type RunnerType = "package_script" | "project_binary" | "node_oracle" | "playwright_test";
@@ -56,6 +105,7 @@ interface DeliveryAssertionBaseV2 {
     applicability_ref?: string;
     observation: string;
     evidence_capabilities: EvidenceCapabilityV2[];
+    expected_authority_ref?: string;
 }
 export type DeliveryAssertionV2 = (DeliveryAssertionBaseV2 & {
     operator: PresenceOrUnaryAssertionOperator;
@@ -247,6 +297,7 @@ export interface DeliveryContractV2 {
     };
     global: {
         applicability: ClaimApplicabilityV2[];
+        semantic_fact_bindings?: SemanticFactGlobalBindingsV2;
         product: {
             non_goals: ApplicableKeyedStatementV2[];
         };

package/dist/lib/long-task-counterfactual-sandbox.d.ts

@@ -1,13 +1,19 @@
 import type { CompiledCheckV2, CounterfactualControlV2, GlobalCounterfactualControlV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 export interface CounterfactualSandboxV2 {
     root: string;
+    mutation_source_root: string;
     dispose(): Promise<void>;
 }
+export interface CounterfactualProcessExecutionRootV2 {
+    root: string;
+    mutation_source_root: string;
+}
 type RemoveTree = (target: string, options: {
     recursive: true;
     force: true;
 }) => Promise<void>;
 type Wait = (milliseconds: number) => Promise<void>;
-export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[]): Promise<CounterfactualSandboxV2>;
+export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[], executionUniverse?: readonly CompiledCheckV2[]): Promise<CounterfactualSandboxV2>;
+export declare function counterfactualSandboxProcessExecution(sandbox: CounterfactualSandboxV2): CounterfactualProcessExecutionRootV2 | null;
 export declare function removeCounterfactualSandboxRoot(root: string, removeTree?: RemoveTree, wait?: Wait): Promise<void>;
 export {};

package/dist/lib/long-task-counterfactual-sandbox.js

@@ -2,6 +2,7 @@ import { copyFile, cp, lstat, mkdir, mkdtemp, readlink, realpath, rm, symlink, }
 import os from "node:os";
 import path from "node:path";
 import { matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
+const directProcessExecutionSandboxes = new WeakMap();
 const TRANSIENT_REMOVE_CODES = new Set([
     "EBUSY",
     "EMFILE",
@@ -11,7 +12,7 @@ const TRANSIENT_REMOVE_CODES = new Set([
 ]);
 const REMOVE_RETRY_LIMIT = process.platform === "win32" ? 6 : 2;
 const REMOVE_RETRY_DELAY_MS = 100;
-export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest, protectedAuthorityPaths = []) {
+export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest, protectedAuthorityPaths = [], executionUniverse = [check]) {
     const root = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-"));
     if (!manifest) {
         await cp(snapshotRoot, root, {
@@ -19,7 +20,26 @@ export async function createCounterfactualSandbox(snapshotRoot, check, control,
             force: true,
             dereference: false,
         });
-        return disposable(root);
+        return disposable(root, root, null);
+    }
+    const directProcessPaths = directProcessExecutionPaths({
+        check,
+        control,
+        manifest,
+        protected_authority_paths: protectedAuthorityPaths,
+        execution_universe: executionUniverse,
+    });
+    let processExecution = null;
+    if (directProcessPaths) {
+        const processRoot = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-process-"));
+        await copyInBatches(snapshotRoot, processRoot, directProcessPaths);
+        await mkdir(path.join(processRoot, check.runner.resolved_cwd), {
+            recursive: true,
+        });
+        processExecution = {
+            root: processRoot,
+            mutation_source_root: snapshotRoot,
+        };
     }
     const exactPaths = new Set([
         ...Object.keys(check.runner.frozen_files),
@@ -54,7 +74,60 @@ export async function createCounterfactualSandbox(snapshotRoot, check, control,
     await copyInBatches(snapshotRoot, root, selected);
     await mkdir(path.join(root, check.runner.resolved_cwd), { recursive: true });
     await linkDependencyRoots(snapshotRoot, root, check.runner.resolved_cwd);
-    return disposable(root);
+    return disposable(root, root, processExecution);
+}
+export function counterfactualSandboxProcessExecution(sandbox) {
+    return directProcessExecutionSandboxes.get(sandbox) ?? null;
+}
+function directProcessExecutionPaths(input) {
+    const checks = [
+        ...new Map([
+            input.check,
+            ...input.execution_universe.filter((candidate) => candidate.raw_execution_identity ===
+                input.check.raw_execution_identity),
+        ].map((candidate) => [candidate.internal_id, candidate])).values(),
+    ];
+    const processChecks = checks.filter((candidate) => (candidate.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact"));
+    if (!processChecks.some((candidate) => candidate === input.check))
+        return null;
+    const closures = processChecks.map((candidate) => candidate.process_runtime_closure ?? null);
+    if (closures.some((closure) => closure === null))
+        return null;
+    const closureIdentities = new Set(closures.map((closure) => closure.closure_identity));
+    if (closureIdentities.size !== 1)
+        return null;
+    const primaryClosure = input.check.process_runtime_closure;
+    const mutationTargets = input.control.mutation.type === "remove_paths"
+        ? input.control.mutation.paths
+        : [input.control.mutation.path];
+    if (mutationTargets.some((target) => !primaryClosure.production_carrier_files.includes(target) ||
+        input.protected_authority_paths.some((pattern) => matchesRepoPattern(target, pattern))))
+        return null;
+    const replacementFixture = input.control.mutation.type === "replace_file"
+        ? input.control.mutation.fixture_path
+        : null;
+    if (replacementFixture !== null &&
+        !input.manifest.files.some((file) => file.path === replacementFixture))
+        return null;
+    const selected = new Set();
+    for (const candidate of checks)
+        for (const authority of candidate.observation_authorities ?? []) {
+            if (authority.authority !== "package_static_json_exact" &&
+                authority.authority !== "package_process_json_exact")
+                continue;
+            for (const pattern of authority.carrier_refs.flatMap((carrier) => carrier.carrier_paths))
+                for (const file of input.manifest.files)
+                    if (matchesRepoPattern(file.path, pattern))
+                        selected.add(file.path);
+            if (authority.authority === "package_process_json_exact")
+                for (const file of candidate.process_runtime_closure
+                    .allowed_runtime_files)
+                    if (input.manifest.files.some((entry) => entry.path === file))
+                        selected.add(file);
+        }
+    return [...selected]
+        .filter((file) => !input.protected_authority_paths.some((pattern) => matchesRepoPattern(file, pattern)))
+        .sort();
 }
 async function copyInBatches(sourceRoot, targetRoot, paths) {
     const concurrency = 32;
@@ -89,13 +162,20 @@ async function linkDependencyRoots(sourceRoot, targetRoot, resolvedCwd) {
         await symlink(await realpath(source), target, process.platform === "win32" ? "junction" : "dir");
     }
 }
-function disposable(root) {
-    return {
+function disposable(root, mutationSourceRoot, processExecution) {
+    const sandbox = {
         root,
+        mutation_source_root: mutationSourceRoot,
         async dispose() {
-            await removeCounterfactualSandboxRoot(root);
+            directProcessExecutionSandboxes.delete(sandbox);
+            await Promise.all([processExecution?.root, root]
+                .filter((candidate) => Boolean(candidate))
+                .map((candidate) => removeCounterfactualSandboxRoot(candidate)));
         },
     };
+    if (processExecution)
+        directProcessExecutionSandboxes.set(sandbox, processExecution);
+    return sandbox;
 }
 export async function removeCounterfactualSandboxRoot(root, removeTree = rm, wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))) {
     for (let attempt = 0;; attempt += 1) {

package/dist/lib/long-task-delivery-compiler-preflight.d.ts

@@ -0,0 +1,24 @@
+import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, ContextAuthoritySnapshotV2, DeliveryContractV2, InitialTaskBaseV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+interface CompileWorkspaceGuardOptions {
+    live_gate?: boolean;
+    initial_task_base?: InitialTaskBaseV2;
+    previous_authority?: CompiledDeliveryContractV2 | null;
+}
+interface CompileWorkspaceGuardInput {
+    repository: string;
+    workdir: string;
+    options: CompileWorkspaceGuardOptions;
+    contract: DeliveryContractV2;
+    contract_files: Record<string, string>;
+    source_hashes: Record<string, string>;
+    context_snapshot: ContextAuthoritySnapshotV2;
+    workspace: WorkspaceManifestV2;
+    global_checks: CompiledCheckV2[];
+    outcomes: CompiledOutcomeV2[];
+}
+interface CompileWorkspaceGuardResult {
+    previous: CompiledDeliveryContractV2 | null;
+    initial_task_base: InitialTaskBaseV2;
+}
+export declare function prepareCompileWorkspaceGuard(input: CompileWorkspaceGuardInput): Promise<CompileWorkspaceGuardResult>;
+export {};

package/dist/lib/long-task-delivery-compiler-preflight.js

@@ -0,0 +1,32 @@
+import { validateActualRiskSurfaces } from "./long-task-risk-surfaces.js";
+import { changedWorkspacePaths, changedWorkspacePathsFromHead, currentGitTree, } from "./long-task-workspace.js";
+import { assertWorkspaceScope, classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
+export async function prepareCompileWorkspaceGuard(input) {
+    const previous = input.options.live_gate
+        ? null
+        : (input.options.previous_authority ?? null);
+    const existingInitialTaskBase = input.options.initial_task_base ?? previous?.initial_task_base ?? null;
+    const changedPaths = existingInitialTaskBase
+        ? changedWorkspacePaths(existingInitialTaskBase.workspace_manifest, input.workspace)
+        : await changedWorkspacePathsFromHead(input.repository, input.workdir);
+    const firstLockManagedPaths = existingInitialTaskBase
+        ? []
+        : await firstLockManagedWorkspacePaths(input.repository, changedPaths);
+    assertWorkspaceScope(classifyWorkspaceScope(input.contract, changedPaths, protectedWorkspacePaths({
+        contract_files: input.contract_files,
+        source_hashes: input.source_hashes,
+        context_hashes: input.context_snapshot.sha256,
+        checks: [
+            ...input.global_checks,
+            ...input.outcomes.flatMap((outcome) => outcome.acceptance.checks),
+        ],
+        additional_files: firstLockManagedPaths,
+    })));
+    const initialTaskBase = existingInitialTaskBase ?? {
+        git_commit: input.workspace.git_head,
+        git_tree: await currentGitTree(input.repository),
+        workspace_manifest: input.workspace,
+    };
+    await validateActualRiskSurfaces(input.repository, changedPaths, input.contract);
+    return { previous, initial_task_base: initialTaskBase };
+}

package/dist/lib/long-task-delivery-compiler.d.ts

@@ -11,3 +11,4 @@ export interface CompileDeliveryOptionsV2 {
     on_authority_revision?: (proposal: AuthorityRevisionProposalV2) => void;
 }
 export declare function compileDeliveryContract(workdirInput: string, projectRootInput?: string, options?: CompileDeliveryOptionsV2): Promise<CompiledDeliveryContractV2>;
+export declare function compiledAcceptanceAuthorityHash(declaredHash: string, claimCoverage: unknown, acceptanceReachability: unknown, frozenChecks: unknown): string;

package/dist/lib/long-task-delivery-compiler.js

@@ -6,14 +6,27 @@ import { changedAuthoritySections, computeAuthorityHashes, } from "./long-task-a
 import { authorityMaterialsChanged, compiledAuthorityMaterials, computeAuthorityMaterials, } from "./long-task-authority-materials.js";
 import { normalizeContextAuthoritySnapshot } from "./long-task-context-authority.js";
 import { assertRiskNotDowngraded, buildAuthorityRevisionProposal, enforceAuthorityRevision, } from "./long-task-authority-revision-enforcement.js";
-import { validateActualRiskSurfaces } from "./long-task-risk-surfaces.js";
 import { captureVerifierIdentity } from "./long-task-verifier-identity.js";
 import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
-import { changedWorkspacePaths, changedWorkspacePathsFromHead, currentGitTree, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
-import { assertWorkspaceScope, classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
+import { canonicalExistingLongTaskWorkdir, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
+import { compileExternalConfirmationIdentityAssurances } from "./long-task-external-confirmation-attestation.js";
+import { assertNoUnfinishedContextMutationForAuthority } from "./context-mutation/mutation-journal.js";
+import { currentActiveAuthorityLockToken } from "./long-task-active-authority-lock-context.js";
+import { withActiveAuthorityLock } from "./long-task-state.js";
+import { prepareCompileWorkspaceGuard } from "./long-task-delivery-compiler-preflight.js";
 export async function compileDeliveryContract(workdirInput, projectRootInput = process.cwd(), options = {}) {
     const repository = await repositoryRoot(projectRootInput);
-    const workdir = path.resolve(workdirInput);
+    const compile = () => compileDeliveryContractLocked(workdirInput, repository, options);
+    if (currentActiveAuthorityLockToken(repository))
+        return compile();
+    return withActiveAuthorityLock(repository, "compile", compile);
+}
+async function compileDeliveryContractLocked(workdirInput, repository, options) {
+    // The shared lock stays held while every Context, Source and Design input is
+    // captured. commitActiveAuthority repeats freshness under a later lock when
+    // compilation and binding are separate calls.
+    await assertNoUnfinishedContextMutationForAuthority(repository);
+    const workdir = await canonicalExistingLongTaskWorkdir(repository, workdirInput);
     const workdirRelative = repoRelative(repository, workdir);
     if (!workdirRelative)
         throw new Error("long_task_workdir_must_not_be_repository_root");
@@ -42,54 +55,45 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
     ]));
     const contractHash = sha256Hex(canonicalValueJson(contract));
     const authorityMaterials = computeAuthorityMaterials(contract, sourceHashes, sourceItems, context);
-    const previous = options.live_gate
-        ? null
-        : (options.previous_authority ?? null);
-    const existingInitialTaskBase = options.initial_task_base ?? previous?.initial_task_base ?? null;
-    const changedPaths = existingInitialTaskBase
-        ? changedWorkspacePaths(existingInitialTaskBase.workspace_manifest, current)
-        : await changedWorkspacePathsFromHead(repository, workdir);
-    const firstLockManagedPaths = existingInitialTaskBase
-        ? []
-        : await firstLockManagedWorkspacePaths(repository, changedPaths);
-    assertWorkspaceScope(classifyWorkspaceScope(contract, changedPaths, protectedWorkspacePaths({
+    const { previous, initial_task_base: initialTaskBase } = await prepareCompileWorkspaceGuard({
+        repository,
+        workdir,
+        options,
+        contract,
         contract_files: contractFiles,
         source_hashes: sourceHashes,
-        context_hashes: context.sha256,
-        checks: [
-            ...globalChecks,
-            ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
-        ],
-        additional_files: firstLockManagedPaths,
-    })));
-    const initialTaskBase = existingInitialTaskBase ?? {
-        git_commit: current.git_head,
-        git_tree: await currentGitTree(repository),
-        workspace_manifest: current,
-    };
-    await validateActualRiskSurfaces(repository, changedPaths, contract);
+        context_snapshot: context,
+        workspace: current,
+        global_checks: globalChecks,
+        outcomes,
+    });
     const verifier = await captureVerifierIdentity(repository, options.require_completion_gate !== false);
     const allChecks = [
         ...globalChecks,
         ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
     ];
     const authorityHashes = computeAuthorityHashes(contract);
-    authorityHashes.acceptance_authority_hash = sha256Hex(canonicalValueJson({
-        declared: authorityHashes.acceptance_authority_hash,
-        claim_coverage: claims.summary,
-        frozen_checks: allChecks.map((check) => ({
-            internal_id: check.internal_id,
-            runner_definition: check.runner.definition_sha256,
-            resolved_cwd: check.runner.resolved_cwd,
-            resolved_target: check.runner.resolved_target,
-            package_script: check.runner.package_script,
-            verification_inputs: check.verification_input_hashes,
-            raw_execution_identity: check.raw_execution_identity,
-            evidence_adapter: check.evidence_adapter,
-            observation_authorities: check.observation_authorities,
-            process_runtime_closure: check.process_runtime_closure,
-        })),
-    }));
+    const externalConfirmationIdentityAssurances = await compileExternalConfirmationIdentityAssurances({
+        contract,
+        repository,
+        source_hashes: sourceHashes,
+        context_snapshot: context,
+    });
+    authorityHashes.acceptance_authority_hash = compiledAcceptanceAuthorityHash(authorityHashes.acceptance_authority_hash, claims.summary, validation.acceptance_reachability, allChecks.map((check) => ({
+        internal_id: check.internal_id,
+        runner_definition: check.runner.definition_sha256,
+        resolved_cwd: check.runner.resolved_cwd,
+        resolved_target: check.runner.resolved_target,
+        package_script: check.runner.package_script,
+        verification_inputs: check.verification_input_hashes,
+        raw_execution_identity: check.raw_execution_identity,
+        evidence_adapter: check.evidence_adapter,
+        observation_authorities: check.observation_authorities,
+        process_runtime_closure: check.process_runtime_closure,
+        completion_role: check.completion_role,
+        expected_authority_refs: check.expected_authority_refs,
+        required_evidence_capabilities: check.required_evidence_capabilities,
+    })));
     let authorityRevision = options.authority_revision ?? previous?.authority_revision ?? 1;
     if (previous) {
         const changes = changedAuthoritySections(previous.authority_hashes, authorityHashes);
@@ -122,6 +126,7 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         source_hashes: sourceHashes,
         source_items: sourceItems,
         context_snapshot: normalizeContextAuthoritySnapshot(context),
+        project_design_authority: validation.project_design_authority,
         verifier_identity: verifier,
         effective_risk: risk.effective_level,
         risk_reasons: risk.reasons,
@@ -131,6 +136,8 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         authority_materials: authorityMaterials,
         authority_revision: authorityRevision,
         claim_coverage: claims.summary,
+        acceptance_reachability: validation.acceptance_reachability,
+        external_confirmation_identity_assurances: externalConfirmationIdentityAssurances,
         semantic_fact_manifest: contract.semantic_fact_manifest,
         task: contract.task,
         risk: contract.risk,
@@ -153,3 +160,11 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         compiled_identity: sha256Hex(canonicalValueJson(unsigned)),
     };
 }
+export function compiledAcceptanceAuthorityHash(declaredHash, claimCoverage, acceptanceReachability, frozenChecks) {
+    return sha256Hex(canonicalValueJson({
+        declared: declaredHash,
+        claim_coverage: claimCoverage,
+        acceptance_reachability: acceptanceReachability,
+        frozen_checks: frozenChecks,
+    }));
+}

package/dist/lib/long-task-delivery-parser.d.ts

@@ -4,6 +4,9 @@ export interface ParsedDeliveryContractV2 {
     contract: DeliveryContractV2;
     contract_files: Record<string, string>;
     outcome_files: string[];
+    compatibility: {
+        completion_authority_defaulted_to_machine_only: boolean;
+    };
 }
 export interface ParseDeliveryContractOptions {
     validate_structure?: boolean;

package/dist/lib/long-task-delivery-parser.js

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises";
+import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import { materializeLongTaskCompactCarrier, materializeLongTaskCompactCarrierForMigration, } from "./long-task-compact-carrier.js";
 import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
@@ -8,18 +8,18 @@ import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { array, literal, object, parseSourceClaims, strings, } from "./long-task-delivery-shape.js";
 import { parseGlobal, parseRisk, parseStages, parseTask, } from "./long-task-root-shape.js";
 import { parseSemanticFactManifestRef } from "./long-task-semantic-fact-shape.js";
-import { repositoryRoot } from "./long-task-workspace.js";
+import { canonicalExistingLongTaskWorkdir, repositoryRoot, } from "./long-task-workspace.js";
 import { assertNoSemanticDriftMigration, semanticDriftMigrationFields, } from "./long-task-semantic-drift-migration.js";
 export const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
 export async function parseDeliveryContract(workdir) {
     return (await parseDeliveryContractBundle(workdir)).contract;
 }
 export async function parseDeliveryContractBundle(workdirInput, repositoryInput, options = {}) {
-    const workdir = path.resolve(workdirInput);
-    const file = path.join(workdir, DELIVERY_CONTRACT_FILE);
     const repository = repositoryInput
-        ? path.resolve(repositoryInput)
-        : await repositoryRoot(workdir);
+        ? await realpath(path.resolve(repositoryInput))
+        : await repositoryRoot(workdirInput);
+    const workdir = await canonicalExistingLongTaskWorkdir(repository, workdirInput);
+    const file = path.join(workdir, DELIVERY_CONTRACT_FILE);
     const raw = await readFile(await assertProtectedRepositoryFile(repository, file, "delivery_contract"), "utf8");
     let root = parseRoot(raw, true);
     if (Object.hasOwn(root, "compact_semantic_carrier")) {
@@ -60,14 +60,30 @@ export async function parseDeliveryContractBundle(workdirInput, repositoryInput,
         outcomes.sort((left, right) => left.key.localeCompare(right.key));
     }
     const contract = parseContractRoot(root, outcomes);
+    const completionAuthorityDefaulted = targetProfileCompletionAuthorityMissing(root);
     if (options.validate_structure !== false)
-        validateDeliveryContractStructure(contract);
+        validateDeliveryContractStructure(contract, {
+            deferCompletionAuthorityClosure: true,
+        });
     return {
         contract,
         contract_files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))),
         outcome_files: outcomeFiles,
+        compatibility: {
+            completion_authority_defaulted_to_machine_only: completionAuthorityDefaulted,
+        },
     };
 }
+function targetProfileCompletionAuthorityMissing(root) {
+    const task = root.task;
+    if (!task || typeof task !== "object" || Array.isArray(task))
+        return false;
+    const targetProfile = task.target_profile;
+    return Boolean(targetProfile &&
+        typeof targetProfile === "object" &&
+        !Array.isArray(targetProfile) &&
+        !Object.hasOwn(targetProfile, "completion_authority"));
+}
 export function parseDeliveryContractText(raw) {
     return parseDeliveryContractTextInternal(raw, false);
 }
@@ -83,7 +99,9 @@ function parseDeliveryContractTextInternal(raw, allowLegacyCarrier) {
         assertNoSemanticDriftMigration(semanticDriftMigrationFields(root));
     }
     const contract = parseContractRoot(root, array(root.outcomes, "outcomes").map((item, index) => parseOutcome(item, `outcomes[${index}]`)));
-    validateDeliveryContractStructure(contract);
+    validateDeliveryContractStructure(contract, {
+        deferCompletionAuthorityClosure: true,
+    });
     return contract;
 }
 function parseRoot(raw, bundle) {

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

@@ -10,4 +10,6 @@ export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-ui-surface-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";
+export * from "./long-task-external-confirmation-types.js";
+export * from "./long-task-completion-types.js";
 export * from "./semantic-fact-types.js";

package/dist/lib/long-task-delivery-types.js

@@ -10,4 +10,6 @@ export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-ui-surface-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";
+export * from "./long-task-external-confirmation-types.js";
+export * from "./long-task-completion-types.js";
 export * from "./semantic-fact-types.js";

package/dist/lib/long-task-delivery-validation.d.ts

@@ -1,6 +1,11 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { CompiledCheckV2, CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
 export interface DeliveryContractStructureValidationOptions {
     allowDeferredDesignComponentBindingClosure?: boolean;
+    deferCompletionAuthorityClosure?: boolean;
 }
 export declare function validateDeliveryContractStructure(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): void;
 export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): string[];
+export declare function validateResolvedCompletionAuthorityClosure(contract: DeliveryContractV2, compiledGlobalChecks: readonly CompiledCheckV2[], compiledOutcomes: readonly CompiledOutcomeV2[], reachability: AcceptanceReachabilityV1 | null, report?: ValidationReporter): void;
+type ValidationReporter = (message: string) => void;
+export {};

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

@@ -23,8 +23,11 @@ export function validateDeliveryContractStructure(contract, options = {}) {
     validateSourceClaimMappings(contract, claims);
     validateUiSurfaceBindings(contract, claims, undefined, options);
     assertCompiledClaimsCovered(claims);
-    validateDeliveryStages(contract);
-    validateExecutionTargets(contract);
+    const completionOptions = {
+        defer_completion_authority_closure: options.deferCompletionAuthorityClosure,
+    };
+    validateDeliveryStages(contract, undefined, completionOptions);
+    validateExecutionTargets(contract, undefined, completionOptions);
     validateSemanticAssuranceShape(contract);
     validateEvidenceCapabilityDeclarations(contract);
     validateExternalConfirmationImpacts(contract, claims);
@@ -35,8 +38,11 @@ export function deliveryContractStructureDiagnostics(contract, options = {}) {
     validateUniqueKeys(contract, report);
     validateDependencies(contract, report);
     validateControlClosure(contract, report);
-    validateDeliveryStages(contract, report);
-    validateExecutionTargets(contract, report);
+    const completionOptions = {
+        defer_completion_authority_closure: options.deferCompletionAuthorityClosure,
+    };
+    validateDeliveryStages(contract, report, completionOptions);
+    validateExecutionTargets(contract, report, completionOptions);
     validateSemanticAssuranceShape(contract, report);
     validateEvidenceCapabilityDeclarations(contract, report);
     validateOwnerAndBindings(contract, report);
@@ -54,6 +60,15 @@ export function deliveryContractStructureDiagnostics(contract, options = {}) {
     }
     return [...new Set(diagnostics)];
 }
+export function validateResolvedCompletionAuthorityClosure(contract, compiledGlobalChecks, compiledOutcomes, reachability, report) {
+    const options = {
+        acceptance_reachability: reachability,
+        compiled_global_checks: compiledGlobalChecks,
+        compiled_outcomes: compiledOutcomes,
+    };
+    validateDeliveryStages(contract, report, options);
+    validateExecutionTargets(contract, report, options);
+}
 function validateEvidenceAdapters(contract, report) {
     for (const check of contract.global.acceptance.checks)
         captureOrReport(report, () => validateEvidenceAdapterCompatibility(check, null));