project-tiny-context-harness 0.2.84 → 0.6.0

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

@@ -0,0 +1,203 @@
+import type { LongTaskRiskFacts, RequestedRiskLevel } from "./long-task-risk-types.js";
+import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./long-task-counterfactual-types.js";
+export type SourceClaimDispositionV2 = {
+    type: "claim";
+    refs: string[];
+} | {
+    type: "acceptance";
+    refs: [string];
+} | {
+    type: "outcome_result";
+    ref: string;
+} | {
+    type: "global_constraint";
+    refs: string[];
+} | {
+    type: "risk_fact";
+    refs: string[];
+} | {
+    type: "external_confirmation";
+    refs: string[];
+} | {
+    type: "decision_required";
+    reason: string;
+};
+export interface SourceClaimV2 {
+    key: string;
+    source_ref: string;
+    statement: string;
+    disposition: SourceClaimDispositionV2;
+}
+export interface KeyedStatementV2 {
+    key: string;
+    statement: string;
+}
+export interface KeyedPathV2 {
+    key: string;
+    path: string;
+}
+export interface ExternalConfirmationV2 {
+    key: string;
+    description: string;
+    owner: string;
+}
+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";
+export type PresenceOrUnaryAssertionOperator = "exists" | "truthy" | "falsy";
+export type BinaryAssertionOperator = "equals" | "not_equals" | "contains" | "not_contains" | "matches" | "not_matches" | "greater_than" | "greater_or_equal" | "less_than" | "less_or_equal" | "set_equals" | "subset_of" | "superset_of";
+export type AssertionOperator = PresenceOrUnaryAssertionOperator | BinaryAssertionOperator;
+interface DeliveryAssertionBaseV2 {
+    key: string;
+    criterion?: string;
+    claims: string[];
+    observation: string;
+}
+export type DeliveryAssertionV2 = (DeliveryAssertionBaseV2 & {
+    operator: PresenceOrUnaryAssertionOperator;
+    expected?: never;
+}) | (DeliveryAssertionBaseV2 & {
+    operator: BinaryAssertionOperator;
+    expected: unknown;
+});
+export interface DeliveryRunnerV2 {
+    type: RunnerType;
+    target: string;
+    argv: string[];
+    cwd: string;
+    timeout_ms: number;
+    effect: "read_only" | "test_sandbox";
+    retry_policy: "none" | "transient_once";
+    idempotent: boolean;
+}
+export type EnvironmentRequirementV2 = {
+    key: string;
+    kind: "executable" | "env_var";
+    target: string;
+} | {
+    key: string;
+    kind: "file" | "directory";
+    target: string;
+} | {
+    key: string;
+    kind: "loopback_tcp";
+    host: "127.0.0.1" | "::1" | "localhost";
+    port: number;
+    timeout_ms: number;
+};
+export interface DeliveryCheckV2 {
+    key: string;
+    proof_surface: ProofSurface;
+    runner: DeliveryRunnerV2;
+    verification_inputs: string[];
+    input_paths: string[];
+    expected_output_paths: string[];
+    artifact_globs: string[];
+    positive_assertions: DeliveryAssertionV2[];
+    negative_assertions: DeliveryAssertionV2[];
+    environment_requirements: EnvironmentRequirementV2[];
+}
+export interface DeliveryControlV2 {
+    key: string;
+    location: string;
+    trigger: string;
+    input: string;
+    loading_state: string;
+    empty_state: string;
+    success_state: string;
+    failure_state: string;
+    feedback: string;
+}
+interface DeliveryRequirementV2 extends KeyedStatementV2 {
+    required_proof_surfaces: ProofSurface[];
+}
+export interface DeliveryOwnerV2 {
+    label: string;
+    context_refs: string[];
+    path_globs: string[];
+}
+export interface DeliveryObligationV2 extends KeyedStatementV2 {
+    required_proof_surfaces: ProofSurface[];
+}
+export interface DeliveryBindingV2 {
+    key: string;
+    kind: "path_glob" | "file" | "verified";
+    target: string;
+    carrier_paths: string[];
+    existence: "existing" | "planned";
+    verification_check_key?: string;
+}
+export interface RollbackRecoveryV2 {
+    rollback: string;
+    recovery: string;
+    verification_check_keys: string[];
+}
+export interface PopulationRequirementV2 {
+    check_key: string;
+    claims: string[];
+    observations: {
+        eligible_ids: string;
+        observed_ids: string;
+        excluded_items: string;
+    };
+    exclusion_rules: KeyedStatementV2[];
+}
+export interface DeliveryOutcomeV2 {
+    key: string;
+    title: string;
+    depends_on: string[];
+    product: {
+        observable_result: string;
+        owner: DeliveryOwnerV2;
+        requirements: DeliveryRequirementV2[];
+        owner_surfaces: string[];
+        controls: DeliveryControlV2[];
+        non_completing_outcomes: KeyedStatementV2[];
+    };
+    technical: {
+        obligations: DeliveryObligationV2[];
+        expected_change_paths: string[];
+        allowed_support_paths: string[];
+        forbidden_paths: string[];
+        bindings: DeliveryBindingV2[];
+        forbidden_shortcuts: KeyedStatementV2[];
+        rollback_and_recovery: RollbackRecoveryV2 | null;
+    };
+    acceptance: {
+        checks: DeliveryCheckV2[];
+        population: PopulationRequirementV2 | null;
+        counterfactual_controls: CounterfactualControlV2[];
+    };
+}
+export interface DeliveryContractV2 {
+    schema_version: "long-task-delivery-v2";
+    task: {
+        id: string;
+        title: string;
+        goal: string;
+        source_paths: string[];
+        context_refs: string[];
+        context_snapshot_mode: "referenced" | "full";
+    };
+    source_claims: SourceClaimV2[];
+    risk: {
+        requested_level: RequestedRiskLevel;
+        facts: LongTaskRiskFacts;
+    };
+    global: {
+        product: {
+            non_goals: KeyedStatementV2[];
+        };
+        technical: {
+            constraints: KeyedStatementV2[];
+            forbidden_paths: KeyedPathV2[];
+            forbidden_shortcuts: KeyedStatementV2[];
+        };
+        acceptance: {
+            checks: DeliveryCheckV2[];
+            counterfactual_controls: GlobalCounterfactualControlV2[];
+            external_confirmations: ExternalConfirmationV2[];
+        };
+    };
+    outcomes: DeliveryOutcomeV2[];
+}
+export {};

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

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

package/dist/lib/long-task-counterfactual-claim-policy.d.ts

@@ -0,0 +1,10 @@
+import type { CounterfactualControlV2, DeliveryContractV2, DeliveryBindingV2, DeliveryOutcomeV2, GlobalCounterfactualControlV2 } from "./long-task-delivery-types.js";
+export declare function validateCounterfactualBindingClaims(outcome: DeliveryOutcomeV2, control: CounterfactualControlV2, binding: DeliveryBindingV2): void;
+export declare function resolveGlobalCounterfactualBinding(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): {
+    outcome: DeliveryOutcomeV2;
+    binding: DeliveryBindingV2;
+};
+export declare function validateGlobalCounterfactualBindingClaims(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): {
+    outcome: DeliveryOutcomeV2;
+    binding: DeliveryBindingV2;
+};

package/dist/lib/long-task-counterfactual-claim-policy.js

@@ -0,0 +1,57 @@
+export function validateCounterfactualBindingClaims(outcome, control, binding) {
+    if (binding.verification_check_key &&
+        binding.verification_check_key !== control.check_key)
+        throw new Error(`counterfactual_binding_check_mismatch:${outcome.key}:${control.key}:${binding.key}:${control.check_key}`);
+    const check = outcome.acceptance.checks.find((item) => item.key === control.check_key);
+    if (!check)
+        throw new Error(`counterfactual_check_unknown:${outcome.key}:${control.key}:${control.check_key}`);
+    validateExpectedAssertions(control, check, `counterfactual_assertion_unknown:${outcome.key}:${control.key}`);
+    const expectedAssertions = new Set(control.expected_assertion_failures);
+    const expectedClaims = new Set([
+        ...(check?.positive_assertions ?? []),
+        ...(check?.negative_assertions ?? []),
+    ]
+        .filter((assertion) => expectedAssertions.has(assertion.key))
+        .flatMap((assertion) => assertion.claims));
+    if (control.claims.some((claim) => !expectedClaims.has(claim)))
+        throw new Error(`counterfactual_binding_claim_unrelated:${outcome.key}:${control.key}`);
+}
+export function resolveGlobalCounterfactualBinding(contract, control) {
+    const [outcomeKey, bindingKey] = control.binding_ref.split(".");
+    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
+    if (!outcome)
+        throw new Error(`global_counterfactual_binding_ref_invalid:${control.key}:${control.binding_ref}`);
+    const binding = outcome.technical.bindings.find((item) => item.key === bindingKey);
+    if (!binding)
+        throw new Error(`global_counterfactual_binding_unknown:${control.key}:${control.binding_ref}`);
+    return { outcome, binding };
+}
+export function validateGlobalCounterfactualBindingClaims(contract, control) {
+    const resolved = resolveGlobalCounterfactualBinding(contract, control);
+    const check = contract.global.acceptance.checks.find((item) => item.key === control.check_key);
+    if (!check)
+        throw new Error(`global_counterfactual_check_unknown:${control.key}:${control.check_key}`);
+    validateExpectedAssertions(control, check, `global_counterfactual_assertion_unknown:${control.key}`);
+    const allowedClaims = new Set([
+        ...contract.global.product.non_goals.map((item) => `non_goal.${item.key}`),
+        ...contract.global.technical.constraints.map((item) => `constraint.${item.key}`),
+        ...contract.global.technical.forbidden_shortcuts.map((item) => `forbidden_shortcut.${item.key}`),
+    ]);
+    if (control.claims.some((claim) => !allowedClaims.has(claim)))
+        throw new Error(`global_counterfactual_claim_invalid:${control.key}:${control.claims.filter((claim) => !allowedClaims.has(claim)).join(",")}`);
+    const expectedAssertions = new Set(control.expected_assertion_failures);
+    const expectedClaims = new Set([...check.positive_assertions, ...check.negative_assertions]
+        .filter((assertion) => expectedAssertions.has(assertion.key))
+        .flatMap((assertion) => assertion.claims));
+    if (control.claims.some((claim) => !expectedClaims.has(claim)))
+        throw new Error(`global_counterfactual_claim_unrelated:${control.key}`);
+    return resolved;
+}
+function validateExpectedAssertions(control, check, unknownPrefix) {
+    if (!control.expected_assertion_failures.length)
+        throw new Error(`${unknownPrefix}:required`);
+    const assertions = new Set([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key));
+    for (const key of control.expected_assertion_failures)
+        if (!assertions.has(key))
+            throw new Error(`${unknownPrefix}:${key}`);
+}

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

@@ -0,0 +1,6 @@
+import type { CompiledCheckV2, CounterfactualControlV2, GlobalCounterfactualControlV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export interface CounterfactualSandboxV2 {
+    root: string;
+    dispose(): Promise<void>;
+}
+export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2): Promise<CounterfactualSandboxV2>;

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

@@ -0,0 +1,87 @@
+import { copyFile, cp, lstat, mkdir, mkdtemp, readlink, realpath, rm, symlink, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { matchesRepoPattern } from "./long-task-paths.js";
+export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest) {
+    const root = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-"));
+    if (!manifest) {
+        await cp(snapshotRoot, root, {
+            recursive: true,
+            force: true,
+            dereference: false,
+        });
+        return disposable(root);
+    }
+    const exactPaths = new Set([
+        ...Object.keys(check.runner.frozen_files),
+        ...Object.keys(check.verification_input_hashes),
+        check.runner.resolved_target,
+        ...(control.mutation.type === "replace_file"
+            ? [control.mutation.fixture_path]
+            : []),
+    ]);
+    const patterns = [
+        ...check.input_paths,
+        ...check.expected_output_paths,
+        ...check.artifact_globs,
+        ...bindingCarrierPaths,
+        ...(control.mutation.type === "remove_paths"
+            ? control.mutation.paths
+            : [control.mutation.path]),
+    ];
+    for (const requirement of check.environment_requirements) {
+        if (requirement.kind === "file")
+            exactPaths.add(requirement.target);
+        if (requirement.kind === "directory")
+            patterns.push(`${requirement.target}/**`);
+    }
+    const selected = manifest.files
+        .map((file) => file.path)
+        .filter((relative) => exactPaths.has(relative) ||
+        patterns.some((pattern) => matchesRepoPattern(relative, pattern)));
+    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);
+}
+async function copyInBatches(sourceRoot, targetRoot, paths) {
+    const concurrency = 32;
+    for (let index = 0; index < paths.length; index += concurrency)
+        await Promise.all(paths
+            .slice(index, index + concurrency)
+            .map((relative) => copyEntry(path.join(sourceRoot, relative), path.join(targetRoot, relative))));
+}
+async function copyEntry(source, target) {
+    await mkdir(path.dirname(target), { recursive: true });
+    const info = await lstat(source);
+    if (!info.isSymbolicLink()) {
+        await copyFile(source, target);
+        return;
+    }
+    const link = await readlink(source);
+    if (process.platform === "win32")
+        await symlink(link, target, "junction");
+    else
+        await symlink(link, target);
+}
+async function linkDependencyRoots(sourceRoot, targetRoot, resolvedCwd) {
+    const segments = resolvedCwd === "." ? [] : resolvedCwd.split("/");
+    for (let length = 0; length <= segments.length; length += 1) {
+        const relative = path.join(...segments.slice(0, length), "node_modules");
+        const source = path.join(sourceRoot, relative);
+        if (!(await lstat(source).catch(() => null)))
+            continue;
+        const target = path.join(targetRoot, relative);
+        await mkdir(path.dirname(target), { recursive: true });
+        await rm(target, { recursive: true, force: true });
+        await symlink(await realpath(source), target, process.platform === "win32" ? "junction" : "dir");
+    }
+}
+function disposable(root) {
+    return {
+        root,
+        async dispose() {
+            await rm(root, { recursive: true, force: true });
+        },
+    };
+}

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

@@ -0,0 +1,24 @@
+export type CounterfactualMutationV2 = {
+    type: "remove_paths";
+    paths: string[];
+} | {
+    type: "replace_file";
+    path: string;
+    fixture_path: string;
+};
+export interface CounterfactualControlV2 {
+    key: string;
+    binding_key: string;
+    claims: string[];
+    check_key: string;
+    mutation: CounterfactualMutationV2;
+    expected_assertion_failures: string[];
+}
+export interface GlobalCounterfactualControlV2 {
+    key: string;
+    binding_ref: string;
+    claims: string[];
+    check_key: string;
+    mutation: CounterfactualMutationV2;
+    expected_assertion_failures: string[];
+}

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

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

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

@@ -0,0 +1,10 @@
+import type { CompiledDeliveryContractV2, InitialTaskBaseV2 } from "./long-task-delivery-types.js";
+export interface CompileDeliveryOptionsV2 {
+    require_completion_gate?: boolean;
+    revise?: boolean;
+    live_gate?: boolean;
+    initial_task_base?: InitialTaskBaseV2;
+    authority_revision?: number;
+    previous_authority?: CompiledDeliveryContractV2 | null;
+}
+export declare function compileDeliveryContract(workdirInput: string, projectRootInput?: string, options?: CompileDeliveryOptionsV2): Promise<CompiledDeliveryContractV2>;

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

@@ -0,0 +1,129 @@
+import path from "node:path";
+import { validateContractForActivation } from "./long-task-activation-validation.js";
+import { DELIVERY_CONTRACT_FILE, parseDeliveryContractBundle, } from "./long-task-delivery-parser.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+import { changedAuthoritySections, computeAuthorityHashes, } from "./long-task-authority.js";
+import { authorityMaterialsChanged, compiledAuthorityMaterials, computeAuthorityMaterials, } from "./long-task-authority-materials.js";
+import { normalizeContextAuthoritySnapshot } from "./long-task-context-authority.js";
+import { assertRiskNotDowngraded, 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, currentGitTree, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
+export async function compileDeliveryContract(workdirInput, projectRootInput = process.cwd(), options = {}) {
+    const repository = await repositoryRoot(projectRootInput);
+    const workdir = path.resolve(workdirInput);
+    const workdirRelative = repoRelative(repository, workdir);
+    if (!workdirRelative)
+        throw new Error("long_task_workdir_must_not_be_repository_root");
+    const contractFile = path.join(workdir, DELIVERY_CONTRACT_FILE);
+    const parsed = await parseDeliveryContractBundle(workdir, repository, {
+        validate_structure: false,
+    });
+    const contract = parsed.contract;
+    const validation = await validateContractForActivation({
+        contract,
+        repository,
+        workdir,
+        mode: "fail_fast",
+    });
+    const claims = validation.claims;
+    const risk = validation.risk;
+    const sourceHashes = validation.source_hashes;
+    const sourceItems = validation.source_items;
+    const context = validation.context_snapshot;
+    const current = validation.workspace;
+    const globalChecks = validation.global_checks;
+    const outcomes = validation.outcomes;
+    const contractHash = sha256Hex(canonicalValueJson(contract));
+    const authorityMaterials = computeAuthorityMaterials(contract, sourceHashes, sourceItems, context);
+    const previous = options.live_gate
+        ? null
+        : (options.previous_authority ?? null);
+    const initialTaskBase = options.initial_task_base ??
+        previous?.initial_task_base ?? {
+        git_commit: current.git_head,
+        git_tree: await currentGitTree(repository),
+        workspace_manifest: current,
+    };
+    await validateActualRiskSurfaces(repository, changedWorkspacePaths(initialTaskBase.workspace_manifest, current), contract);
+    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,
+        })),
+    }));
+    let authorityRevision = options.authority_revision ?? previous?.authority_revision ?? 1;
+    if (previous) {
+        const changes = changedAuthoritySections(previous.authority_hashes, authorityHashes);
+        const contractChanged = previous.contract_sha256 !== contractHash;
+        const materialsChanged = authorityMaterialsChanged(compiledAuthorityMaterials(previous), authorityMaterials);
+        const verifierChanged = verifierAuthorityDiff(previous.verifier_identity, verifier);
+        const authorityChanged = changes.length > 0 ||
+            contractChanged ||
+            materialsChanged ||
+            verifierChanged.verifier_content_changed ||
+            verifierChanged.verifier_runtime_locator_changed;
+        if (authorityChanged && !options.revise)
+            throw new Error("authority_revision_requires_revise_flag");
+        if (options.revise && authorityChanged) {
+            assertRiskNotDowngraded(previous, risk.effective_level, risk.reasons);
+            authorityRevision = previous.authority_revision + 1;
+            await enforceAuthorityRevision(previous, contract, authorityHashes, authorityMaterials, globalChecks, outcomes, verifier, workdir, risk.minimum_level);
+        }
+    }
+    const unsigned = {
+        schema_version: "compiled-long-task-delivery-v2",
+        repository_root: repository,
+        workdir,
+        contract_file: repoRelative(repository, contractFile),
+        contract_sha256: contractHash,
+        contract_files: Object.fromEntries(Object.entries(parsed.contract_files).map(([relative, hash]) => [
+            repoRelative(repository, path.join(workdir, ...relative.split("/"))),
+            hash,
+        ])),
+        source_hashes: sourceHashes,
+        source_items: sourceItems,
+        context_snapshot: normalizeContextAuthoritySnapshot(context),
+        verifier_identity: verifier,
+        effective_risk: risk.effective_level,
+        risk_reasons: risk.reasons,
+        baseline_workspace: initialTaskBase.workspace_manifest,
+        initial_task_base: initialTaskBase,
+        authority_hashes: authorityHashes,
+        authority_materials: authorityMaterials,
+        authority_revision: authorityRevision,
+        claim_coverage: claims.summary,
+        task: contract.task,
+        risk: contract.risk,
+        source_claims: contract.source_claims,
+        global: {
+            product: contract.global.product,
+            technical: contract.global.technical,
+            acceptance: {
+                checks: globalChecks,
+                counterfactual_controls: contract.global.acceptance.counterfactual_controls,
+                external_confirmations: contract.global.acceptance.external_confirmations,
+            },
+        },
+        outcomes,
+    };
+    return {
+        ...unsigned,
+        compiled_identity: sha256Hex(canonicalValueJson(unsigned)),
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+export declare const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
+export interface ParsedDeliveryContractV2 {
+    contract: DeliveryContractV2;
+    contract_files: Record<string, string>;
+    outcome_files: string[];
+}
+export interface ParseDeliveryContractOptions {
+    validate_structure?: boolean;
+}
+export declare function parseDeliveryContract(workdir: string): Promise<DeliveryContractV2>;
+export declare function parseDeliveryContractBundle(workdirInput: string, repositoryInput?: string, options?: ParseDeliveryContractOptions): Promise<ParsedDeliveryContractV2>;
+export declare function parseDeliveryContractText(raw: string): DeliveryContractV2;

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

@@ -0,0 +1,90 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
+import { validateDeliveryContractStructure } from "./long-task-delivery-validation.js";
+import { parseOutcome, parseOutcomeFragment, safeFragmentPath, } from "./long-task-outcome-parser.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { array, literal, object, parseSourceClaims, strings, } from "./long-task-delivery-shape.js";
+import { parseGlobal, parseRisk, parseTask } from "./long-task-root-shape.js";
+import { repositoryRoot } from "./long-task-workspace.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);
+    const raw = await readFile(await assertProtectedRepositoryFile(repository, file, "delivery_contract"), "utf8");
+    const root = parseRoot(raw, true);
+    const hasInline = Object.hasOwn(root, "outcomes");
+    const hasFiles = Object.hasOwn(root, "outcome_files");
+    if (hasInline === hasFiles)
+        throw new Error("delivery_contract_invalid:$:exactly one of outcomes or outcome_files is required");
+    const files = {};
+    let outcomes;
+    let outcomeFiles = [];
+    if (hasInline) {
+        outcomes = array(root.outcomes, "outcomes").map((item, index) => parseOutcome(item, `outcomes[${index}]`));
+    }
+    else {
+        outcomeFiles = strings(root.outcome_files, "outcome_files")
+            .map((item, index) => safeFragmentPath(item, index))
+            .sort();
+        if (new Set(outcomeFiles).size !== outcomeFiles.length)
+            throw new Error("delivery_contract_invalid:outcome_files:duplicate path");
+        outcomes = [];
+        for (const relative of outcomeFiles) {
+            const target = path.resolve(workdir, ...relative.split("/"));
+            if (!target.startsWith(`${workdir}${path.sep}`))
+                throw new Error(`unsafe_path:outcome_files:${relative}`);
+            const protectedFragment = await assertProtectedRepositoryFile(repository, target, `outcome_fragment:${relative}`).catch((error) => {
+                if (error instanceof Error &&
+                    error.message.startsWith("protected_input_not_found:"))
+                    throw new Error(`outcome_fragment_not_found:${relative}`);
+                throw error;
+            });
+            const fragmentRaw = await readFile(protectedFragment, "utf8");
+            files[relative] = sha256Hex(fragmentRaw);
+            outcomes.push(...parseOutcomeFragment(fragmentRaw, relative));
+        }
+        outcomes.sort((left, right) => left.key.localeCompare(right.key));
+    }
+    const contract = parseContractRoot(root, outcomes);
+    if (options.validate_structure !== false)
+        validateDeliveryContractStructure(contract);
+    return {
+        contract,
+        contract_files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))),
+        outcome_files: outcomeFiles,
+    };
+}
+export function parseDeliveryContractText(raw) {
+    const root = parseRoot(raw, false);
+    const contract = parseContractRoot(root, array(root.outcomes, "outcomes").map((item, index) => parseOutcome(item, `outcomes[${index}]`)));
+    validateDeliveryContractStructure(contract);
+    return contract;
+}
+function parseRoot(raw, bundle) {
+    const decoded = parseStrictYaml(raw);
+    if (decoded &&
+        typeof decoded === "object" &&
+        !Array.isArray(decoded) &&
+        decoded.schema_version ===
+            "long-task-delivery-v1")
+        throw new Error("long_task_delivery_v1_retired_use_v2");
+    return object(decoded, "$", ["schema_version", "task", "source_claims", "risk", "global"], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
+}
+function parseContractRoot(root, outcomes) {
+    literal(root.schema_version, ["long-task-delivery-v2"], "schema_version");
+    return {
+        schema_version: "long-task-delivery-v2",
+        task: parseTask(root.task),
+        source_claims: parseSourceClaims(root.source_claims, "source_claims"),
+        risk: parseRisk(root.risk),
+        global: parseGlobal(root.global),
+        outcomes,
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function validateVerificationInputSeparation(contract: DeliveryContractV2, checks: CompiledDeliveryContractV2["outcomes"][number]["acceptance"]["checks"], workdirRelative: string): void;
+export declare function validateTechnicalPaths(contract: DeliveryContractV2, repository: string, workdirRelative: string, baseline: WorkspaceManifestV2): void;
+export declare function validateCounterfactualPaths(contract: DeliveryContractV2, compiledGlobalChecks: CompiledCheckV2[], compiledOutcomes: CompiledOutcomeV2[], repository: string, workdirRelative: string, protectedAuthorityPaths: string[]): Promise<void>;
+export declare function hashDeclaredFiles(repository: string, files: string[], label: string): Promise<Record<string, string>>;