project-tiny-context-harness 0.8.16 → 0.11.0

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,3 +1,11 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function validateDeliveryContractStructure(contract: DeliveryContractV2): void;
-export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2): string[];
+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

@@ -10,7 +10,7 @@ import { validateExecutionTargets, validateExternalConfirmationImpacts, } from "
 import { validateUiSurfaceBindings } from "./long-task-ui-surface-policy.js";
 import { controlFieldFacts } from "./long-task-control-fields.js";
 import { validateSemanticAssuranceShape } from "./long-task-semantic-assurance-policy.js";
-export function validateDeliveryContractStructure(contract) {
+export function validateDeliveryContractStructure(contract, options = {}) {
     validateUniqueKeys(contract);
     validateDependencies(contract);
     validateControlClosure(contract);
@@ -21,22 +21,28 @@ export function validateDeliveryContractStructure(contract) {
         allow_uncovered: true,
     });
     validateSourceClaimMappings(contract, claims);
-    validateUiSurfaceBindings(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);
 }
-export function deliveryContractStructureDiagnostics(contract) {
+export function deliveryContractStructureDiagnostics(contract, options = {}) {
     const diagnostics = [];
     const report = (message) => diagnostics.push(message);
     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);
@@ -48,12 +54,21 @@ export function deliveryContractStructureDiagnostics(contract) {
     });
     if (claims) {
         validateSourceClaimMappings(contract, claims, report);
-        validateUiSurfaceBindings(contract, claims, report);
+        validateUiSurfaceBindings(contract, claims, report, options);
         validateExternalConfirmationImpacts(contract, claims, report);
         capture(diagnostics, () => assertCompiledClaimsCovered(claims));
     }
     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));

package/dist/lib/long-task-design-feasibility-binding-owners.d.ts

@@ -0,0 +1,6 @@
+import type { DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DeliveryBindingV2 } from "./long-task-delivery-types.js";
+type FeasibleRealization = DesignResourceImplementationFeasibilityV1["component_family_cells"][number]["feasible_realizations"][number];
+export declare function matchingFeasibilityBindingKeys(realization: FeasibleRealization, bindings: DeliveryBindingV2[]): Set<string>;
+export declare function validateFeasibilityBindingOwnerRoots(document: DesignResourceImplementationFeasibilityV1, componentBindings: DeliveryBindingV2[], routeBinding: DeliveryBindingV2): void;
+export {};

package/dist/lib/long-task-design-feasibility-binding-owners.js

@@ -0,0 +1,52 @@
+import { invalid } from "./long-task-design-resource-method-binding.js";
+import { matchesRepoPattern, proveRepositoryPatternSubset, } from "./long-task-paths.js";
+export function matchingFeasibilityBindingKeys(realization, bindings) {
+    const result = new Set();
+    for (const owner of realization.owner_candidates)
+        for (const binding of bindings) {
+            if (binding.existence !== owner.existence)
+                continue;
+            const matches = owner.kind === "planned_logical_owner"
+                ? binding.key === owner.locator || binding.target === owner.locator
+                : (binding.kind === "file" && binding.target === owner.locator) ||
+                    binding.carrier_paths.some((pattern) => matchesRepoPattern(owner.locator, pattern));
+            if (matches)
+                result.add(binding.key);
+        }
+    return result;
+}
+export function validateFeasibilityBindingOwnerRoots(document, componentBindings, routeBinding) {
+    const componentRoots = observedOwnerRoots(document, "component_owner_roots");
+    const routeRoots = observedOwnerRoots(document, "route_owner_roots");
+    if (componentBindings.length && componentRoots.length === 0)
+        invalid("feasibility_component_owner_roots_required", document.target_ref);
+    for (const binding of componentBindings) {
+        if (binding.existence === "planned" && binding.carrier_paths.length === 0)
+            invalid("feasibility_planned_binding_carrier_required", binding.key);
+        proveBindingPathUniverseWithinObservedRoots(binding, componentRoots, "feasibility_component_binding_outside_owner_roots");
+    }
+    if (routeRoots.length === 0)
+        invalid("feasibility_route_owner_roots_required", document.target_ref);
+    proveBindingPathUniverseWithinObservedRoots(routeBinding, routeRoots, "feasibility_route_binding_outside_owner_roots");
+}
+function proveBindingPathUniverseWithinObservedRoots(binding, roots, errorCode) {
+    for (const candidate of bindingPathUniverse(binding)) {
+        const proofs = roots.map((root) => proveRepositoryPatternSubset(candidate, `${root.replace(/\/+$/u, "")}/**`));
+        if (proofs.some((proof) => proof.status === "proven_subset"))
+            continue;
+        const proof = proofs[0];
+        invalid(errorCode, `${binding.key}:${candidate}:${proof?.status ?? "unknown"}:${proof?.reason ?? "owner_roots_empty"}:${roots.join(",")}`);
+    }
+}
+function observedOwnerRoots(document, kind) {
+    const observation = document.substrate_observations.find((candidate) => candidate.kind === kind);
+    return observation?.disposition === "observed" &&
+        observation.value?.kind === "repository_paths"
+        ? observation.value.paths
+        : [];
+}
+function bindingPathUniverse(binding) {
+    return binding.kind === "verified"
+        ? [...binding.carrier_paths]
+        : [binding.target, ...binding.carrier_paths];
+}

package/dist/lib/long-task-design-feasibility-binding.d.ts

@@ -0,0 +1,14 @@
+import type { DesignResourceHandoffPreflightV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
+import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { ContractDesignTarget } from "./long-task-design-resource-handoff.js";
+type DesignResourcePreflight = DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2;
+export interface LongTaskDesignFeasibilityBindingValidationResult {
+    attribution_mode: "feasibility" | "legacy";
+    consumed_component_binding_refs: string[];
+}
+export interface LongTaskDesignFeasibilityBindingValidationOptions {
+    deferComponentBindingAttribution?: boolean;
+}
+export declare function validateLongTaskDesignFeasibilityBindings(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, preflight: DesignResourcePreflight, sourceItems: CompiledSourceItemV2[], options?: LongTaskDesignFeasibilityBindingValidationOptions): LongTaskDesignFeasibilityBindingValidationResult;
+export {};