project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/symbolic-denotation-runtime.js

@@ -1,90 +0,0 @@
-import { compareText, invalid } from "./symbolic-denotation-support.js";
-export function buildSymbolicRuntimeAxes(domains, numberCuts) {
-    return domains.map((domain) => {
-        if (domain.kind === "enum")
-            return {
-                domain,
-                segments: domain.values.map((value) => ({
-                    kind: "enum",
-                    values: [value],
-                })),
-            };
-        return { domain, segments: buildNumberSegments(domain, numberCuts) };
-    });
-}
-function buildNumberSegments(domain, numberCuts) {
-    const cuts = new Set([
-        domain.minimum,
-        domain.maximum + 1,
-        ...(numberCuts.get(domain.key) ?? []),
-    ]);
-    const sorted = [...cuts]
-        .filter((value) => value >= domain.minimum && value <= domain.maximum + 1)
-        .sort((left, right) => left - right);
-    const segments = [];
-    for (let index = 0; index < sorted.length - 1; index += 1) {
-        const minimum = sorted[index];
-        const maximum = sorted[index + 1] - 1;
-        if (minimum <= maximum)
-            segments.push({ kind: "number", minimum, maximum });
-    }
-    return segments;
-}
-export function canonicalSymbolicEdges(axis, childRefs) {
-    return axis.domain.kind === "enum"
-        ? canonicalEnumEdges(axis, childRefs)
-        : canonicalNumberEdges(axis, childRefs);
-}
-function canonicalEnumEdges(axis, childRefs) {
-    const groups = new Map();
-    axis.segments.forEach((segment, index) => {
-        const values = groups.get(childRefs[index]) ?? [];
-        values.push(...segment.values);
-        groups.set(childRefs[index], values);
-    });
-    return [...groups.entries()]
-        .map(([child_ref, values]) => ({
-        region: { kind: "enum_set", values },
-        child_ref,
-    }))
-        .sort((left, right) => compareText(left.region.values[0], right.region.values[0]));
-}
-function canonicalNumberEdges(axis, childRefs) {
-    const edges = [];
-    axis.segments.forEach((segment, index) => {
-        const numeric = segment;
-        const previous = edges.at(-1);
-        if (previous?.region.kind === "integer_range" &&
-            previous.child_ref === childRefs[index] &&
-            previous.region.maximum + 1 === numeric.minimum) {
-            previous.region.maximum = numeric.maximum;
-            return;
-        }
-        edges.push({
-            region: {
-                kind: "integer_range",
-                minimum: numeric.minimum,
-                maximum: numeric.maximum,
-            },
-            child_ref: childRefs[index],
-        });
-    });
-    return edges;
-}
-export function symbolicEdgeMatches(edge, value) {
-    if (edge.region.kind === "enum_set")
-        return typeof value === "string" && edge.region.values.includes(value);
-    return (typeof value === "number" &&
-        Number.isSafeInteger(value) &&
-        value >= edge.region.minimum &&
-        value <= edge.region.maximum);
-}
-export function symbolicSegmentMatches(segment, matches) {
-    if (segment.kind === "enum")
-        return matches(segment.values[0]);
-    const atMinimum = matches(segment.minimum);
-    const atMaximum = matches(segment.maximum);
-    if (atMinimum !== atMaximum)
-        invalid("numeric_partition_not_theory_complete", `${segment.minimum}:${segment.maximum}`);
-    return atMinimum;
-}

package/dist/lib/symbolic-denotation-support.d.ts

@@ -1,11 +0,0 @@
-import type { SymbolicDenotationAxisDomain, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
-export declare function exactKeys(value: object, expected: string[], label: string): void;
-export declare function stableKey(value: unknown, label: string): asserts value is string;
-export declare function stableJson(value: unknown): string;
-export declare function sha256(value: string): string;
-export declare function compareText(left: string, right: string): number;
-export declare function compareScalar(left: SymbolicDenotationScalar, right: SymbolicDenotationScalar): number;
-export declare function scalarEqual(left: SymbolicDenotationScalar, right: SymbolicDenotationScalar): boolean;
-export declare function domainCardinality(domain: SymbolicDenotationAxisDomain): bigint;
-export declare function neverValue(value: never): string;
-export declare function invalid(code: string, detail: string): never;

package/dist/lib/symbolic-denotation-support.js

@@ -1,49 +0,0 @@
-import { createHash } from "node:crypto";
-export function exactKeys(value, expected, label) {
-    const actual = Object.keys(value).sort(compareText);
-    const required = [...expected].sort(compareText);
-    if (actual.length !== required.length ||
-        actual.some((key, index) => key !== required[index]))
-        invalid("shape_keys_invalid", `${label}:actual=${actual.join(",")}:expected=${required.join(",")}`);
-}
-export function stableKey(value, label) {
-    if (typeof value !== "string" || !/^[a-z0-9][a-z0-9._-]*$/u.test(value))
-        invalid("stable_key_invalid", `${label}:${String(value)}`);
-}
-export function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map((item) => stableJson(item)).join(",")}]`;
-    if (value && typeof value === "object")
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => compareText(left, right))
-            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
-            .join(",")}}`;
-    return JSON.stringify(value);
-}
-export function sha256(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-export function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-export function compareScalar(left, right) {
-    if (typeof left !== typeof right)
-        return typeof left === "number" ? -1 : 1;
-    return typeof left === "number"
-        ? left - right
-        : compareText(left, right);
-}
-export function scalarEqual(left, right) {
-    return typeof left === typeof right && left === right;
-}
-export function domainCardinality(domain) {
-    return domain.kind === "enum"
-        ? BigInt(domain.values.length)
-        : BigInt(domain.maximum) - BigInt(domain.minimum) + 1n;
-}
-export function neverValue(value) {
-    return String(value);
-}
-export function invalid(code, detail) {
-    throw new Error(`symbolic_denotation_invalid:${code}:${detail}`);
-}

package/dist/lib/symbolic-denotation-types.d.ts

@@ -1,133 +0,0 @@
-export type SymbolicDenotationScalar = string | number;
-export type SymbolicDenotationAxisDomain = {
-    key: string;
-    kind: "enum";
-    values: string[];
-} | {
-    key: string;
-    kind: "bounded_number";
-    minimum: number;
-    maximum: number;
-    integer: true;
-};
-export type SymbolicDenotationPredicate = {
-    op: "eq";
-    axis_ref: string;
-    value: SymbolicDenotationScalar;
-} | {
-    op: "in";
-    axis_ref: string;
-    values: SymbolicDenotationScalar[];
-} | {
-    op: "range";
-    axis_ref: string;
-    minimum: number;
-    maximum: number;
-    minimum_inclusive: boolean;
-    maximum_inclusive: boolean;
-} | {
-    op: "all" | "any";
-    predicates: SymbolicDenotationPredicate[];
-} | {
-    op: "not";
-    predicate: SymbolicDenotationPredicate;
-};
-export interface SymbolicDenotationComplexityLimits {
-    max_predicate_depth: number;
-    max_input_predicate_nodes: number;
-    max_canonical_dag_nodes: number;
-    max_partition_edges: number;
-    max_canonical_bytes: number;
-}
-export interface SymbolicDenotationCanonicalDagV1 {
-    schema_version: "symbolic-denotation-canonical-dag-v1";
-    root_ref: string;
-    nodes: SymbolicDenotationCanonicalNodeV1[];
-}
-export interface SymbolicDenotationCanonicalNodeV1 {
-    key: string;
-    axis_ref: string;
-    edges: SymbolicDenotationCanonicalEdgeV1[];
-}
-export type SymbolicDenotationCanonicalEdgeV1 = {
-    region: {
-        kind: "enum_set";
-        values: string[];
-    };
-    child_ref: string;
-} | {
-    region: {
-        kind: "integer_range";
-        minimum: number;
-        maximum: number;
-    };
-    child_ref: string;
-};
-export interface CompiledSymbolicDenotationV1 {
-    canonical_dag: SymbolicDenotationCanonicalDagV1;
-    canonical_sha256: string;
-    canonical_bytes: number;
-    referenced_axis_refs: string[];
-    omitted_axis_refs: string[];
-    theoretical_ground_cardinality: string;
-    metrics: {
-        input_predicate_nodes: number;
-        canonical_dag_nodes: number;
-        partition_edges: number;
-        canonical_bytes: number;
-    };
-}
-export declare const SYMBOLIC_DENOTATION_DISPOSITIONS: readonly ["specified", "not_applicable", "excluded", "decision_required", "unavailable", "blocking"];
-export type SymbolicDenotationDisposition = (typeof SYMBOLIC_DENOTATION_DISPOSITIONS)[number];
-export declare const SYMBOLIC_DENOTATION_QUANTIFIERS: readonly ["one", "all", "any", "none", "exactly", "at_least", "at_most", "range"];
-export type SymbolicDenotationQuantifier = (typeof SYMBOLIC_DENOTATION_QUANTIFIERS)[number];
-export interface SymbolicExtensionalPointV1 {
-    subject_or_relation_ref: string;
-    target_ref: string;
-    condition_assignment: Record<string, SymbolicDenotationScalar>;
-    variation_assignment: Record<string, SymbolicDenotationScalar>;
-    property_ref: string;
-    population_ref: string | null;
-    quantifier: {
-        kind: SymbolicDenotationQuantifier;
-        minimum: number | null;
-        maximum: number | null;
-    };
-}
-export interface SymbolicExpectedSemanticsV1 {
-    value_type: string;
-    expected: {
-        locator: {
-            resource_ref: string;
-            kind: string;
-            value: string;
-        };
-        sha256: string;
-    };
-    provenance_ref: string;
-    sensitivity: string;
-    population_ref: string | null;
-    quantifier: SymbolicExtensionalPointV1["quantifier"];
-    lineage: unknown;
-}
-export interface SymbolicProofObligationDenotationV1 {
-    method: string;
-    proof_surface: string;
-    observation_boundary: string;
-    comparison: {
-        comparator: string;
-        mode: "exact" | "tolerance";
-        parameters: unknown;
-        tolerance: unknown;
-        mask: unknown;
-    };
-    oracle: unknown;
-    environment: unknown;
-    protected_value_policy: string;
-    completion_effect: string;
-}
-export interface SymbolicPointDenotationV1 {
-    disposition: SymbolicDenotationDisposition;
-    expected_semantics: SymbolicExpectedSemanticsV1 | null;
-    proof_obligations: SymbolicProofObligationDenotationV1[];
-}

package/dist/lib/symbolic-denotation-types.js

@@ -1,18 +0,0 @@
-export const SYMBOLIC_DENOTATION_DISPOSITIONS = [
-    "specified",
-    "not_applicable",
-    "excluded",
-    "decision_required",
-    "unavailable",
-    "blocking",
-];
-export const SYMBOLIC_DENOTATION_QUANTIFIERS = [
-    "one",
-    "all",
-    "any",
-    "none",
-    "exactly",
-    "at_least",
-    "at_most",
-    "range",
-];

package/dist/lib/symbolic-denotation-validation.d.ts

@@ -1,6 +0,0 @@
-import type { SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
-export interface SymbolicPredicateInspection {
-    input_nodes: number;
-    number_cuts: Map<string, Set<number>>;
-}
-export declare function validateSymbolicPredicate(input: SymbolicDenotationPredicate, domains: SymbolicDenotationAxisDomain[], domainIndex: ReadonlyMap<string, number>, inspection: SymbolicPredicateInspection, depth: number, limits: SymbolicDenotationComplexityLimits): SymbolicDenotationPredicate;

package/dist/lib/symbolic-denotation-validation.js

@@ -1,126 +0,0 @@
-import { compareScalar, exactKeys, invalid, } from "./symbolic-denotation-support.js";
-export function validateSymbolicPredicate(input, domains, domainIndex, inspection, depth, limits) {
-    inspectPredicateNode(input, depth, inspection, limits);
-    switch (input.op) {
-        case "eq":
-            return validateEq(input, domains, domainIndex, inspection);
-        case "in":
-            return validateIn(input, domains, domainIndex, inspection);
-        case "range":
-            return validateRange(input, domains, domainIndex, inspection);
-        case "all":
-        case "any":
-            return validateGroup(input, domains, domainIndex, inspection, depth, limits);
-        case "not":
-            return validateNot(input, domains, domainIndex, inspection, depth, limits);
-        default:
-            return invalid("predicate_operator_unknown", String(input.op));
-    }
-}
-function inspectPredicateNode(input, depth, inspection, limits) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        invalid("predicate_invalid", "not_object");
-    if (depth > limits.max_predicate_depth)
-        invalid("predicate_depth_limit_exceeded", `actual=${depth}:limit=${limits.max_predicate_depth}`);
-    inspection.input_nodes += 1;
-    if (inspection.input_nodes > limits.max_input_predicate_nodes)
-        invalid("predicate_node_limit_exceeded", `actual=${inspection.input_nodes}:limit=${limits.max_input_predicate_nodes}`);
-}
-function validateEq(input, domains, domainIndex, inspection) {
-    exactKeys(input, ["op", "axis_ref", "value"], "predicate:eq");
-    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
-    validateScalar(domain, input.value);
-    addNumberCuts(domain, [input.value], inspection);
-    return { ...input };
-}
-function validateIn(input, domains, domainIndex, inspection) {
-    exactKeys(input, ["op", "axis_ref", "values"], "predicate:in");
-    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
-    if (!Array.isArray(input.values) || !input.values.length)
-        invalid("predicate_in_values_required", input.axis_ref);
-    const values = input.values.map((value) => {
-        validateScalar(domain, value);
-        return value;
-    });
-    if (new Set(values.map((value) => `${typeof value}:${value}`)).size !==
-        values.length)
-        invalid("predicate_in_value_duplicate", input.axis_ref);
-    addNumberCuts(domain, values, inspection);
-    return { ...input, values: [...values].sort(compareScalar) };
-}
-function validateRange(input, domains, domainIndex, inspection) {
-    exactKeys(input, [
-        "op",
-        "axis_ref",
-        "minimum",
-        "maximum",
-        "minimum_inclusive",
-        "maximum_inclusive",
-    ], "predicate:range");
-    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
-    validateRangeBounds(input, domain);
-    const effectiveMinimum = input.minimum + (input.minimum_inclusive ? 0 : 1);
-    const effectiveMaximum = input.maximum - (input.maximum_inclusive ? 0 : 1);
-    if (effectiveMinimum > effectiveMaximum)
-        invalid("predicate_range_empty", input.axis_ref);
-    addCuts(inspection, domain.key, effectiveMinimum, effectiveMaximum + 1);
-    return { ...input };
-}
-function validateRangeBounds(input, domain) {
-    if (domain.kind !== "bounded_number" ||
-        !Number.isSafeInteger(input.minimum) ||
-        !Number.isSafeInteger(input.maximum) ||
-        typeof input.minimum_inclusive !== "boolean" ||
-        typeof input.maximum_inclusive !== "boolean" ||
-        input.minimum < domain.minimum ||
-        input.maximum > domain.maximum ||
-        input.minimum > input.maximum)
-        invalid("predicate_range_invalid", input.axis_ref);
-}
-function validateGroup(input, domains, domainIndex, inspection, depth, limits) {
-    exactKeys(input, ["op", "predicates"], `predicate:${input.op}`);
-    if (!Array.isArray(input.predicates) || !input.predicates.length)
-        invalid("predicate_children_required", input.op);
-    return {
-        op: input.op,
-        predicates: input.predicates.map((predicate) => validateSymbolicPredicate(predicate, domains, domainIndex, inspection, depth + 1, limits)),
-    };
-}
-function validateNot(input, domains, domainIndex, inspection, depth, limits) {
-    exactKeys(input, ["op", "predicate"], "predicate:not");
-    return {
-        op: "not",
-        predicate: validateSymbolicPredicate(input.predicate, domains, domainIndex, inspection, depth + 1, limits),
-    };
-}
-function predicateDomain(axisRef, domains, domainIndex) {
-    if (typeof axisRef !== "string")
-        invalid("predicate_axis_invalid", "");
-    const index = domainIndex.get(axisRef);
-    if (index === undefined)
-        invalid("predicate_axis_unknown", axisRef);
-    return domains[index];
-}
-function validateScalar(domain, value) {
-    if (domain.kind === "enum") {
-        if (typeof value !== "string" || !domain.values.includes(value))
-            invalid("predicate_value_outside_domain", `${domain.key}:${String(value)}`);
-        return;
-    }
-    if (typeof value !== "number" ||
-        !Number.isSafeInteger(value) ||
-        value < domain.minimum ||
-        value > domain.maximum)
-        invalid("predicate_value_outside_domain", `${domain.key}:${String(value)}`);
-}
-function addNumberCuts(domain, values, inspection) {
-    if (domain.kind !== "bounded_number")
-        return;
-    for (const value of values)
-        addCuts(inspection, domain.key, value, value + 1);
-}
-function addCuts(inspection, axisRef, ...cuts) {
-    const values = inspection.number_cuts.get(axisRef) ?? new Set();
-    cuts.forEach((cut) => values.add(cut));
-    inspection.number_cuts.set(axisRef, values);
-}

package/dist/long-task-hook.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/long-task-hook.js

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-import { readConfig } from "./lib/config.js";
-import { harnessRoot } from "./lib/harness-root.js";
-import { longTaskCodexAgentProfileBootstrapPaths } from "./lib/long-task-codex-agent-profile.js";
-import { isProfileEnabled } from "./lib/profiles.js";
-import { readActiveLongTaskBinding } from "./lib/long-task-state.js";
-import { stopCheckDeliveryTask } from "./lib/long-task-status-v2.js";
-import { LONG_TASK_IMPLEMENTATION_AGENT, selectedAgentType, } from "./lib/long-task-worker-selection.js";
-import { repositoryRoot } from "./lib/long-task-workspace.js";
-const LONG_TASK_IMPLEMENTATION_BOUNDARY = [
-    "This is a delegated rolling implementation worker, not the parent Long-Task Goal.",
-    "Follow only the bounded packet from the parent.",
-    "Do not run long-task resume, Preflight, Compile, Authority Revision, verify as formal Progress, Final Gate, Stop/close, abandon, or completion.",
-    "The parent Goal owns Source, Contract, Authority, Context writeback, integration and formal acceptance.",
-    "Your report is advisory and is not Progress, Evidence or acceptance.",
-].join("\n");
-const AGENT_SPAWN_TOOLS = new Set(["spawn_agent", "Agent"]);
-const EXACT_WORKER_REQUIRED = "Active Tiny Context Long-Task permits delegation only to the exact custom agent long_task_implementation. The current host request does not explicitly select it. Do not substitute a generic worker; complete this packet in the parent Goal.";
-const EXACT_WORKER_UNAVAILABLE = "Active Tiny Context Long-Task cannot use the exact custom agent long_task_implementation because its current package-managed profile is unavailable, invalid, outdated or conflicting. Do not spawn a substitute agent; complete this packet in the parent Goal.";
-const input = await readStdin();
-const isAgentSpawnPreToolUse = input.hook_event_name === "PreToolUse" &&
-    AGENT_SPAWN_TOOLS.has(input.tool_name ?? "");
-if (input.hook_event_name === "PreToolUse" && !isAgentSpawnPreToolUse)
-    output({});
-try {
-    const root = await repositoryRoot(input.cwd || process.cwd());
-    const active = await readActiveLongTaskBinding(root);
-    if (!active)
-        output({});
-    if (isAgentSpawnPreToolUse) {
-        if (selectedAgentType(input.tool_input) !== LONG_TASK_IMPLEMENTATION_AGENT)
-            denyAgentSpawn(EXACT_WORKER_REQUIRED);
-        const rootConfig = await readConfig(root);
-        const profilePaths = await longTaskCodexAgentProfileBootstrapPaths(root, await harnessRoot(root), isProfileEnabled(rootConfig, "long-task"));
-        if (profilePaths.length === 0)
-            denyAgentSpawn(EXACT_WORKER_UNAVAILABLE);
-        output({});
-    }
-    if (input.hook_event_name === "SubagentStart")
-        output(input.agent_type === LONG_TASK_IMPLEMENTATION_AGENT
-            ? {
-                hookSpecificOutput: {
-                    hookEventName: "SubagentStart",
-                    additionalContext: LONG_TASK_IMPLEMENTATION_BOUNDARY,
-                },
-            }
-            : {});
-    if (input.hook_event_name === "SessionStart" ||
-        input.hook_event_name === "PostCompact")
-        output({
-            hookSpecificOutput: {
-                hookEventName: input.hook_event_name,
-                additionalContext: [
-                    "Active Single-Goal Long-Task Workflow V2",
-                    `Workdir: ${active.workdir}`,
-                    `Task: ${active.task_id}`,
-                    `Authority revision: ${active.authority_revision}`,
-                    `Resume: ty-context long-task resume ${JSON.stringify(active.workdir)}`,
-                ].join("\n"),
-            },
-        });
-    if (input.hook_event_name !== "Stop")
-        output({});
-    const result = await stopCheckDeliveryTask(active.workdir, input.last_assistant_message ?? "");
-    if (result.continue)
-        output(result.message ? { systemMessage: result.message } : {});
-    output({
-        decision: "block",
-        reason: result.message ||
-            result.reason ||
-            "The Live Final Gate did not accept the current candidate.",
-    });
-}
-catch (error) {
-    const reason = `Tiny Context Long-Task Hook failed closed: ${message(error)}`;
-    if (isAgentSpawnPreToolUse)
-        denyAgentSpawn(`${reason} Do not spawn a substitute agent; complete the packet in the parent Goal.`);
-    if (input.hook_event_name === "Stop")
-        output({ decision: "block", reason });
-    output({ continue: false, stopReason: reason });
-}
-async function readStdin() {
-    let value = "";
-    for await (const chunk of process.stdin)
-        value += chunk;
-    return value.trim() ? JSON.parse(value) : {};
-}
-function output(value) {
-    process.stdout.write(`${JSON.stringify(value)}\n`);
-    process.exit(0);
-}
-function denyAgentSpawn(reason) {
-    output({
-        hookSpecificOutput: {
-            hookEventName: "PreToolUse",
-            permissionDecision: "deny",
-            permissionDecisionReason: reason,
-        },
-    });
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/public-api-long-task.d.ts

@@ -1,10 +0,0 @@
-export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
-export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
-export { captureFinalizationIdentity, finalizationIdentityDigest, type FinalizationIdentityV1, } from "./lib/long-task-finalization-identity.js";
-export { finalizeDeliveryGateCas } from "./lib/long-task-terminal-finalization.js";
-export { externalConfirmationStatus, prepareExternalConfirmations, revokeExternalConfirmation, rotateExternalConfirmation, submitExternalConfirmation, } from "./lib/long-task-external-confirmation-plan.js";
-export { externalConfirmationRecordHash, externalConfirmationRecordV2Hash, externalConfirmationV2SignablePayload, parseExternalConfirmationRecord, parseExternalConfirmationRecordV1, parseExternalConfirmationRecordV2, signExternalConfirmationRecordV1, } from "./lib/long-task-external-confirmation-shape.js";
-export { verifyExternalConfirmationAttestation } from "./lib/long-task-external-confirmation-attestation.js";
-export { deriveRepairFrontier } from "./lib/long-task-repair-frontier.js";
-export { closeDeliveryTask, type DeliveryStatusV2, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
-export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";

package/dist/public-api-long-task.js

@@ -1,10 +0,0 @@
-export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
-export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
-export { captureFinalizationIdentity, finalizationIdentityDigest, } from "./lib/long-task-finalization-identity.js";
-export { finalizeDeliveryGateCas } from "./lib/long-task-terminal-finalization.js";
-export { externalConfirmationStatus, prepareExternalConfirmations, revokeExternalConfirmation, rotateExternalConfirmation, submitExternalConfirmation, } from "./lib/long-task-external-confirmation-plan.js";
-export { externalConfirmationRecordHash, externalConfirmationRecordV2Hash, externalConfirmationV2SignablePayload, parseExternalConfirmationRecord, parseExternalConfirmationRecordV1, parseExternalConfirmationRecordV2, signExternalConfirmationRecordV1, } from "./lib/long-task-external-confirmation-shape.js";
-export { verifyExternalConfirmationAttestation } from "./lib/long-task-external-confirmation-attestation.js";
-export { deriveRepairFrontier } from "./lib/long-task-repair-frontier.js";
-export { closeDeliveryTask, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
-export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";