project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,181 +0,0 @@
-import { machineAuthorizedAssertions } from "./long-task-acceptance-reachability-helpers.js";
-import { resultApplicabilityEffectivelyExternallyBlocked, resultApplicabilityProfiles, } from "./long-task-effective-external-takeover.js";
-const FAMILY_CAPABILITY = {
-    browser: "browser-runtime",
-    native: "native-runtime",
-    desktop: "desktop-runtime",
-    service: "service-runtime",
-    process: "process-runtime",
-    external: "external-runtime",
-};
-export function validateExecutionTargets(contract, report, options = {}) {
-    const targets = indexExecutionTargets(contract, report);
-    const requiredTargetRefs = contract.task.target_profile.required_target_refs;
-    validateRequiredTargetRefs(contract, targets, report);
-    for (const [outcomeKey, check] of allChecks(contract))
-        validateCheckTarget(outcomeKey, check, targets, report);
-    if (!options.defer_completion_authority_closure)
-        validateCriticalPathTargets(contract, requiredTargetRefs, report, options.acceptance_reachability, options.compiled_outcomes);
-}
-function indexExecutionTargets(contract, report) {
-    const targets = new Map();
-    for (const target of contract.task.execution_targets) {
-        if (targets.has(target.key))
-            issue(report, "execution_target_key_duplicate", target.key);
-        targets.set(target.key, target);
-        if (!target.capabilities.length)
-            issue(report, "execution_target_capability_required", target.key);
-        if (new Set(target.capabilities).size !== target.capabilities.length)
-            issue(report, "execution_target_capability_duplicate", target.key);
-        const familyCapability = FAMILY_CAPABILITY[target.runtime_family];
-        if (!target.capabilities.includes(familyCapability))
-            issue(report, "execution_target_family_capability_required", `${target.key}:${familyCapability}`);
-    }
-    if (![...targets.values()].some((target) => target.role === "product"))
-        issue(report, "product_execution_target_required", contract.task.id);
-    return targets;
-}
-function validateRequiredTargetRefs(contract, targets, report) {
-    const required = contract.task.target_profile.required_target_refs;
-    if (!required.length)
-        issue(report, "target_profile_required_target_refs_required", contract.task.id);
-    if (new Set(required).size !== required.length)
-        issue(report, "target_profile_required_target_refs_duplicate", contract.task.id);
-    for (const targetRef of required) {
-        const target = targets.get(targetRef);
-        if (!target)
-            issue(report, "target_profile_required_target_ref_unknown", targetRef);
-        else if (target.role !== "product")
-            issue(report, "target_profile_required_target_must_be_product", targetRef);
-        else {
-            for (const capability of ["cold-start", "production-root"])
-                if (!target.capabilities.includes(capability))
-                    issue(report, "required_target_capability_missing", `${targetRef}:${capability}`);
-        }
-    }
-}
-function validateCheckTarget(outcomeKey, check, targets, report) {
-    const target = targets.get(check.execution_target.target_ref);
-    const label = `${outcomeKey ?? "GLOBAL"}:${check.key}`;
-    if (!target) {
-        issue(report, "check_execution_target_unknown", `${label}:${check.execution_target.target_ref}`);
-        return;
-    }
-    if ((check.runner.type === "playwright_test" ||
-        check.proof_surface === "ui_browser") &&
-        target.runtime_family !== "browser")
-        issue(report, "browser_check_target_mismatch", `${label}:${target.key}`);
-    if (provesTargetRuntime(check) &&
-        target.runtime_family === "browser" &&
-        check.runner.type !== "playwright_test")
-        issue(report, "browser_target_runtime_requires_playwright", `${label}:${target.key}`);
-    if (provesTargetRuntime(check) &&
-        ["native", "desktop"].includes(target.runtime_family) &&
-        check.runner.type !== "project_binary")
-        issue(report, "native_target_runtime_requires_project_binary", `${label}:${target.key}`);
-    validateStageGateTarget(label, check, target, report);
-    validateConformanceTarget(outcomeKey, check, target, report);
-}
-function validateStageGateTarget(label, check, target, report) {
-    if (!check.journey_roles.includes("stage_gate"))
-        return;
-    if (target.role !== "product")
-        issue(report, "stage_gate_product_target_required", `${label}:${target.key}`);
-    if (check.execution_target.entrypoint !== "root")
-        issue(report, "stage_gate_root_entrypoint_required", label);
-}
-function validateConformanceTarget(outcomeKey, check, target, report) {
-    if (!check.journey_roles.includes("conformance"))
-        return;
-    if (outcomeKey !== null)
-        issue(report, "conformance_check_must_be_global", `${outcomeKey}:${check.key}`);
-    if (target.role !== "product" || check.execution_target.entrypoint !== "root")
-        issue(report, "conformance_root_product_target_required", check.key);
-}
-function validateCriticalPathTargets(contract, requiredTargetRefs, report, reachability, compiledOutcomes) {
-    for (const outcomeKey of contract.risk.facts.critical_user_path) {
-        const outcome = contract.outcomes.find((candidate) => candidate.key === outcomeKey);
-        if (!outcome)
-            continue;
-        const compiledOutcome = compiledOutcomes?.find((candidate) => candidate.key === outcome.key);
-        for (const targetRef of requiredTargetRefs)
-            if (!provesEverySuccessApplicability({
-                outcome,
-                compiledOutcome,
-                targetRef,
-                reachability,
-                useCompiledAuthority: compiledOutcomes !== undefined,
-            }))
-                issue(report, "critical_path_required_target_proof_missing", `${outcome.key}:${targetRef}`);
-    }
-}
-function provesEverySuccessApplicability(options) {
-    const profiles = resultApplicabilityProfiles(options.outcome, {
-        target_ref: options.targetRef,
-        journey_role: "success",
-    });
-    if (!profiles.length)
-        return false;
-    return profiles.every((profile) => resultApplicabilityEffectivelyExternallyBlocked(options.reachability, options.outcome.key, profile.key, profile.target_ref) ||
-        (options.useCompiledAuthority
-            ? provesCompiledSuccess(options.compiledOutcome?.acceptance.checks ?? [], options.targetRef, profile.key)
-            : options.outcome.acceptance.checks.some((check) => provesDeclaredSuccess(check, options.targetRef, profile.key))));
-}
-function provesCompiledSuccess(checks, targetRef, applicabilityRef) {
-    return machineAuthorizedAssertions(checks, {
-        authority_scope: "ordinary_claim",
-        local_claim_ref: "result",
-        applicability_ref: applicabilityRef,
-        target_ref: targetRef,
-        check_journey_role: "success",
-        required_evidence_capability: "target_runtime",
-    }).some((match) => match.check.execution_target.entrypoint === "root");
-}
-function provesDeclaredSuccess(check, targetRef, applicabilityRef) {
-    return (check.execution_target.target_ref === targetRef &&
-        check.journey_roles.includes("success") &&
-        check.execution_target.entrypoint === "root" &&
-        [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.claims.includes("result") &&
-            assertion.applicability_ref === applicabilityRef &&
-            assertion.evidence_capabilities.includes("target_runtime")));
-}
-function provesTargetRuntime(check) {
-    return [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime"));
-}
-export function validateExternalConfirmationImpacts(contract, claims, report) {
-    const claimRefs = new Set();
-    for (const [outcomeKey, values] of Object.entries(claims.by_outcome))
-        for (const claim of values)
-            claimRefs.add(`${outcomeKey}.${claim.local_key}`);
-    for (const claim of claims.by_global)
-        claimRefs.add(`GLOBAL.${claim.local_key}`);
-    for (const confirmation of contract.global.acceptance
-        .external_confirmations) {
-        if (!confirmation.impact_claims.length)
-            issue(report, "external_confirmation_impact_required", confirmation.key);
-        for (const claim of confirmation.impact_claims)
-            if (!claimRefs.has(claim))
-                issue(report, "external_confirmation_impact_unknown", `${confirmation.key}:${claim}`);
-        if (confirmation.kind === "functional_prerequisite" &&
-            !confirmation.blocks_target)
-            issue(report, "functional_prerequisite_must_block_target", confirmation.key);
-        if (confirmation.kind === "production_release_gate" &&
-            contract.task.target_profile.required_state ===
-                "production_release_ready" &&
-            !confirmation.blocks_target)
-            issue(report, "production_gate_must_block_release_target", confirmation.key);
-    }
-}
-function allChecks(contract) {
-    return [
-        ...contract.global.acceptance.checks.map((check) => [null, check]),
-        ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [outcome.key, check])),
-    ];
-}
-function issue(report, code, detail) {
-    const message = `delivery_contract_invalid:${code}:${detail}`;
-    if (report)
-        report(message);
-    else
-        throw new Error(message);
-}

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

@@ -1,3 +0,0 @@
-import type { DeliveryBindingV2, RollbackRecoveryV2 } from "./long-task-delivery-types.js";
-export declare function parseBindings(value: unknown, label: string): DeliveryBindingV2[];
-export declare function parseRollback(value: unknown, label: string): RollbackRecoveryV2;

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

@@ -1,44 +0,0 @@
-import { array, fail, key, literal, object, repositoryFile, repositoryPattern, repositoryPatterns, string, strings, } from "./long-task-shape-primitives.js";
-export function parseBindings(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "kind", "target", "carrier_paths"], ["existence", "verification_check_key"]);
-        const kindValue = literal(row.kind, ["path_glob", "file", "verified"], `${itemLabel}.kind`);
-        const verificationCheckKey = Object.hasOwn(row, "verification_check_key")
-            ? key(row.verification_check_key, `${itemLabel}.verification_check_key`)
-            : undefined;
-        if (kindValue === "verified" && !verificationCheckKey)
-            fail(`${itemLabel}.verification_check_key`, "is required for verified");
-        if (kindValue !== "verified" && verificationCheckKey)
-            fail(`${itemLabel}.verification_check_key`, "is only allowed for verified");
-        const target = kindValue === "file"
-            ? repositoryFile(row.target, `${itemLabel}.target`)
-            : kindValue === "path_glob"
-                ? repositoryPattern(row.target, `${itemLabel}.target`)
-                : string(row.target, `${itemLabel}.target`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            kind: kindValue,
-            target,
-            carrier_paths: repositoryPatterns(row.carrier_paths, `${itemLabel}.carrier_paths`),
-            existence: Object.hasOwn(row, "existence")
-                ? literal(row.existence, ["existing", "planned"], `${itemLabel}.existence`)
-                : "existing",
-            ...(verificationCheckKey
-                ? { verification_check_key: verificationCheckKey }
-                : {}),
-        };
-    });
-}
-export function parseRollback(value, label) {
-    const row = object(value, label, [
-        "rollback",
-        "recovery",
-        "verification_check_keys",
-    ]);
-    return {
-        rollback: string(row.rollback, `${label}.rollback`),
-        recovery: string(row.recovery, `${label}.recovery`),
-        verification_check_keys: strings(row.verification_check_keys, `${label}.verification_check_keys`),
-    };
-}

package/dist/lib/long-task-terminal-finalization.d.ts

@@ -1,12 +0,0 @@
-import type { FinalReceiptV3, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-import { type FinalizationIdentityV1 } from "./long-task-finalization-identity.js";
-import { type ActiveAuthorityIdentityExpectation } from "./long-task-state.js";
-export declare function finalizeDeliveryGateCas(input: {
-    provisional_result: Omit<FinalReceiptV3, "receipt_sha256" | "finalization_identity_sha256">;
-    expected_authority: ActiveAuthorityIdentityExpectation;
-    expected_finalization_identity: FinalizationIdentityV1;
-    repository: string;
-    workdir: string;
-    provisional_manifest: WorkspaceManifestV2;
-    close_on_accept: boolean;
-}): Promise<FinalReceiptV3>;

package/dist/lib/long-task-terminal-finalization.js

@@ -1,190 +0,0 @@
-import { access, mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
-import { evaluateExternalConfirmations } from "./long-task-external-confirmation-plan.js";
-import { captureFinalizationIdentity, finalizationIdentityDigest, } from "./long-task-finalization-identity.js";
-import { assertVerifierAuthorityCurrent, deliveryCompileFreshness, } from "./long-task-freshness.js";
-import { activeAuthorityIdentityMatches, assertMatchingActiveBinding, commitFinalReceiptTransaction, loadActiveLongTaskAuthority, sealFinalReceipt, withActiveAuthorityLock, } from "./long-task-state.js";
-import { canonicalValueJson } from "./strict-codec.js";
-import { captureWorkspaceFingerprint, currentGitState, } from "./long-task-workspace.js";
-import { workspaceFingerprintExcludedPrefixes } from "./long-task-workspace-manifest.js";
-export async function finalizeDeliveryGateCas(input) {
-    const expectedDigest = finalizationIdentityDigest(input.expected_finalization_identity);
-    return withActiveAuthorityLock(input.repository, "finalize", async (lockToken) => {
-        let currentActive = null;
-        let currentIdentity = null;
-        let currentExternal = null;
-        try {
-            currentActive = (await loadActiveLongTaskAuthority(input.repository, {
-                migrate_legacy: false,
-            })).authority;
-            if (!currentActive ||
-                currentActive.workdir !== input.workdir ||
-                !activeAuthorityIdentityMatches(currentActive, input.expected_authority))
-                throw new FinalizationCasError("finalization_authority_compare_and_swap_failed");
-            await assertVerifierAuthorityCurrent(input.repository, currentActive.verifier_identity);
-            const stale = await deliveryCompileFreshness(currentActive.authority_snapshot);
-            if (stale.length)
-                throw new FinalizationCasError(`finalization_compiled_inputs_stale:${stale.join(",")}`);
-            const compiled = await compileDeliveryContract(input.workdir, input.repository, {
-                live_gate: true,
-                initial_task_base: currentActive.initial_task_base,
-                authority_revision: currentActive.authority_revision,
-                require_completion_gate: true,
-            });
-            await assertMatchingActiveBinding(compiled);
-            const current = await captureCurrentFinalizationState(input.repository, input.workdir, currentActive, compiled, input.provisional_manifest);
-            currentIdentity = current.identity;
-            assertExpectedFinalizationIdentity(currentIdentity, input.expected_finalization_identity);
-            currentExternal = await evaluateExternalConfirmations(compiled, input.repository, input.workdir, input.provisional_manifest, current.candidate);
-            if (canonicalValueJson(currentExternal) !==
-                canonicalValueJson(input.provisional_result.external_confirmation_results))
-                throw new FinalizationCasError("finalization_external_evaluation_changed");
-            await finalizationPhaseSignal("after_finalization_evaluation");
-            const unsigned = {
-                ...input.provisional_result,
-                external_confirmation_results: currentExternal,
-                finalization_identity_sha256: expectedDigest,
-                completed_at: new Date().toISOString(),
-            };
-            const accepted = acceptedWorkflowStatus(unsigned.workflow_status);
-            return await commitFinalReceiptTransaction({
-                lock_token: lockToken,
-                repository_root: input.repository,
-                workdir: input.workdir,
-                unsigned,
-                expected_authority: input.expected_authority,
-                close_on_accept: input.close_on_accept && accepted,
-                validate_current: async (phase) => {
-                    await finalizationPhaseSignal(phase);
-                    const refreshed = await captureCurrentFinalizationState(input.repository, input.workdir, currentActive, compiled, input.provisional_manifest);
-                    assertExpectedFinalizationIdentity(refreshed.identity, input.expected_finalization_identity);
-                },
-            });
-        }
-        catch (error) {
-            const currentDigest = currentIdentity
-                ? finalizationIdentityDigest(currentIdentity)
-                : expectedDigest;
-            const failure = rejectedReceipt(input.provisional_result, currentExternal, currentDigest, error);
-            const activeNow = (await loadActiveLongTaskAuthority(input.repository, {
-                migrate_legacy: false,
-            }).catch(() => ({ authority: null }))).authority;
-            if (activeNow && activeNow.workdir === input.workdir) {
-                const currentExpectation = authorityExpectation(activeNow);
-                try {
-                    return await commitFinalReceiptTransaction({
-                        lock_token: lockToken,
-                        repository_root: input.repository,
-                        workdir: input.workdir,
-                        unsigned: failure,
-                        expected_authority: currentExpectation,
-                        close_on_accept: false,
-                        validate_current: async () => undefined,
-                    });
-                }
-                catch {
-                    // A failure Receipt is audit-only. If even its persistence CAS races,
-                    // return a sealed non-accepted result without overwriting newer state.
-                }
-            }
-            return sealFinalReceipt(failure);
-        }
-    });
-}
-async function captureCurrentFinalizationState(repository, workdir, active, compiled, provisionalManifest) {
-    // Fingerprint capture runs git write-tree. The finalization lock excludes
-    // Harness mutations, while this ordering also prevents a same-process
-    // currentGitState status refresh from competing for the repository index.
-    const fingerprint = await captureWorkspaceFingerprint(repository, workspaceFingerprintExcludedPrefixes(repository, [workdir]));
-    const git = await currentGitState(repository);
-    if (git.dirty.length ||
-        fingerprint.head !== git.head ||
-        fingerprint.head_tree !== git.tree ||
-        provisionalManifest.git_head !== git.head ||
-        provisionalManifest.fingerprint.head_tree !== git.tree ||
-        provisionalManifest.fingerprint.identity !== fingerprint.identity ||
-        provisionalManifest.snapshot_sha256 !== fingerprint.identity)
-        throw new FinalizationCasError(`finalization_candidate_not_clean_or_stable:${git.dirty.join(",")}`);
-    const candidate = {
-        git_head: git.head,
-        git_tree: git.tree,
-        snapshot_sha256: fingerprint.identity,
-    };
-    return {
-        candidate,
-        identity: await captureFinalizationIdentity({
-            repository,
-            active,
-            compiled,
-            candidate,
-            workspace_fingerprint: fingerprint,
-        }),
-    };
-}
-function assertExpectedFinalizationIdentity(current, expected) {
-    if (finalizationIdentityDigest(current) !== finalizationIdentityDigest(expected))
-        throw new FinalizationCasError("finalization_identity_compare_and_swap_failed");
-}
-function rejectedReceipt(provisional, currentExternal, finalizationIdentitySha256, error) {
-    const reason = message(error);
-    const finding = {
-        code: reason.split(":", 1)[0] || "finalization_compare_and_swap_failed",
-        outcome_key: null,
-        check_key: null,
-        message: "Finalization identity or persistence changed during the Live Final Gate; no accepted terminal was published and Active Authority was not cleared.",
-        actual: { reason },
-        invalidation_reasons: [reason],
-        next_action: "Stop concurrent mutation, inspect the current Authority/candidate/external state, and rerun the complete Live Final Gate.",
-    };
-    return {
-        ...provisional,
-        workflow_status: "needs_work",
-        target_state: "not_accepted",
-        stage_results: Object.fromEntries(Object.keys(provisional.stage_results).map((key) => [key, "failed"])),
-        outcome_results: Object.fromEntries(Object.keys(provisional.outcome_results).map((key) => [key, "failed"])),
-        external_confirmation_results: currentExternal ?? provisional.external_confirmation_results,
-        findings: [...provisional.findings, finding],
-        finalization_identity_sha256: finalizationIdentitySha256,
-        completed_at: new Date().toISOString(),
-    };
-}
-function authorityExpectation(active) {
-    return {
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        compiled_identity: active.active_authority_identity,
-        worktree_identity: active.worktree_identity,
-    };
-}
-function acceptedWorkflowStatus(status) {
-    return status === "machine_accepted" || status === "delivery_accepted";
-}
-class FinalizationCasError extends Error {
-}
-async function finalizationPhaseSignal(phase) {
-    if (process.env.NODE_ENV !== "test")
-        return false;
-    const configured = process.env.TY_CONTEXT_TEST_FINALIZATION_SIGNAL_DIR;
-    if (!configured)
-        return false;
-    if (!path.isAbsolute(configured))
-        throw new FinalizationCasError("finalization_test_signal_directory_must_be_absolute");
-    const folder = path.resolve(configured);
-    await mkdir(folder, { recursive: true });
-    const started = path.join(folder, `${phase}.started`);
-    const release = path.join(folder, `${phase}.release`);
-    await writeFile(started, `${phase}\n`, { flag: "a" });
-    const deadline = Date.now() + 45_000;
-    while (Date.now() < deadline) {
-        if (await access(release)
-            .then(() => true)
-            .catch(() => false))
-            return true;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    throw new FinalizationCasError(`finalization_test_signal_timeout:${phase}`);
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-ui-design-policy.d.ts

@@ -1,17 +0,0 @@
-import type { CompiledClaimsV2 } from "./long-task-claims.js";
-import type { DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, ProductClaimV2 } from "./long-task-delivery-types.js";
-import { type Reporter } from "./long-task-ui-surface-validation.js";
-interface UiDesignBindingContext {
-    outcome: DeliveryOutcomeV2;
-    binding: DeliveryOutcomeV2["product"]["surface_bindings"][number];
-    outcomeClaims: Map<string, ProductClaimV2>;
-    claims: CompiledClaimsV2;
-    checks: Map<string, DeliveryCheckV2>;
-    confirmations: Map<string, DeliveryContractV2["global"]["acceptance"]["external_confirmations"][number]>;
-    carriers: string[];
-    designTargetKeys: Set<string>;
-    designAssertionRefs: Set<string>;
-    report?: Reporter;
-}
-export declare function validateUiDesignBinding(context: UiDesignBindingContext): void;
-export {};