@atcn/subledger 1.3.0

package/dist/documents.js

@@ -0,0 +1,310 @@
+import { z } from "zod";
+import { ASSURANCE_LABELS, ATTESTABLE_FIELDS, CLAIM_ASSERTERS, Currency, DELIVERY_EVENT_TYPES, EvidenceRefSchema, FINANCIAL_EVENT_TYPES, FxSchema, Minor, NORMALIZED_STATUSES, PAYERS, RESPONSE_TYPES } from "./types.js";
+/**
+ * Signed documents of the Agent Work Subledger (PRD v1.2 §6, §16).
+ * Schema 1.3 adds closure `obligation_links`, the clearing-network claim asserters, and the `network_recorded` assurance label;
+ * 1.2 documents must use neither (see packages/schema/COMPATIBILITY.md).
+ */
+export const SUBLEDGER_SCHEMA_VERSION = "1.3";
+export const SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS = ["1.2", "1.3"];
+/** Must equal this package's version in package.json (checked by a test). */
+export const SUBLEDGER_VERIFIER_VERSION = "1.3.0";
+export const RECEIPT_DOCUMENT_TYPE = "atcn.subledger.receipt";
+export const CLOSURE_DOCUMENT_TYPE = "atcn.subledger.closure";
+export const RESPONSE_STATEMENT_TYPE = "atcn.subledger.receipt_response";
+export const SIGNED_BY_HOSTED_SERVICE = "atcn-hosted-service";
+export const SIGNED_BY_LOCAL_RUNNER = "atcn-local-runner";
+const Iso = z.string().min(1);
+const Digest = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const Assurance = z.array(z.enum(ASSURANCE_LABELS));
+export const SignatureSchema = z.object({
+    key_id: z.string(),
+    key_version: z.number().int().positive(),
+    algorithm: z.literal("Ed25519"),
+    value: z.string(),
+});
+/** A countersignature by the operator's own key over the same canonical payload bytes the service signed. */
+export const OperatorSignatureSchema = z.object({
+    key_id: z.string(),
+    algorithm: z.literal("Ed25519"),
+    value: z.string(),
+    /** Recorded by the service when the countersignature was submitted; not covered by the signature. */
+    signed_at: Iso,
+});
+/** A published operator public key (GET /v1/operators/{operator_id}/keys). The private key never reaches ATCN. */
+export const OperatorKeyRecordSchema = z.object({
+    operator_id: z.string(),
+    key_id: z.string(),
+    algorithm: z.literal("Ed25519"),
+    public_key: z.string(),
+    created_at: Iso,
+    revoked_at: Iso.nullable(),
+});
+export const IssuerSchema = z.object({
+    operator_id: z.string(),
+    operator_name: z.string(),
+    /**
+     * The hosted service signs on the operator's behalf with its published key. The local reference runner signs
+     * with a key generated on the developer's machine, which only that developer can vouch for.
+     */
+    signed_by: z.enum([SIGNED_BY_HOSTED_SERVICE, SIGNED_BY_LOCAL_RUNNER]),
+});
+export const TotalsSchema = z.object({
+    quoted: Minor,
+    accepted: Minor,
+    invoiced: Minor,
+    charged: Minor,
+    fees: Minor,
+    adjustments: Minor,
+    refunded: Minor,
+    credits: Minor,
+    reported_paid: Minor,
+    net_cost: Minor,
+    unresolved: Minor,
+    downstream_reported: Minor,
+    allocated: Minor,
+    unallocated: Minor,
+});
+export const CurrencyTotalsSchema = z.record(Currency, TotalsSchema);
+export const ReceiptTotalsSchema = z.record(Currency, TotalsSchema.omit({ allocated: true, unallocated: true }));
+export const FinancialEventRecordSchema = z.object({
+    financial_event_id: z.string(),
+    type: z.enum(FINANCIAL_EVENT_TYPES),
+    source: z.string(),
+    source_event_id: z.string(),
+    provider_id: z.string().nullable(),
+    provider_reference: z.string().nullable(),
+    amount_minor: Minor,
+    currency: Currency,
+    event_date: Iso,
+    imported_at: Iso,
+    provider_status: z.string().nullable(),
+    normalized_status: z.enum(NORMALIZED_STATUSES),
+    evidence: EvidenceRefSchema.nullable(),
+    retrospective: z.boolean(),
+    payer: z.enum(PAYERS),
+    liability_owner: z.string().nullable(),
+    economic_event_id: z.string().nullable(),
+    included_in_event_id: z.string().nullable(),
+    reverses_event_id: z.string().nullable(),
+    settles_event_id: z.string().nullable(),
+    fx: FxSchema.nullable(),
+    reason: z.string().nullable(),
+});
+export const DeliveryClaimSchema = z.object({
+    event_id: z.string(),
+    delegation_id: z.string(),
+    type: z.enum(DELIVERY_EVENT_TYPES),
+    asserted_by: z.enum(CLAIM_ASSERTERS),
+    assurance: Assurance,
+    note: z.string().nullable(),
+    evidence: z.array(EvidenceRefSchema),
+    supersedes_event_id: z.string().nullable(),
+    reason: z.string().nullable(),
+    retrospective: z.boolean(),
+    occurred_at: Iso,
+    recorded_at: Iso,
+});
+export const FIELD_STATES = ["missing", "imported", "buyer_asserted", "provider_reported", "contested"];
+export const FieldStatusSchema = z.record(z.enum(ATTESTABLE_FIELDS), z.enum(FIELD_STATES));
+export const CorrectionSchema = z.object({ field: z.enum(ATTESTABLE_FIELDS), proposed_value: z.string().max(1000), reason: z.string().max(2000) });
+/** The exact statement a provider signs (or a link holder submits). Binds receipt, digest, revision, issuer tenant, type, and fields. */
+export const ResponseStatementSchema = z.object({
+    document_type: z.literal(RESPONSE_STATEMENT_TYPE),
+    receipt_id: z.string(),
+    receipt_digest: Digest,
+    receipt_revision: z.number().int().positive(),
+    issuer_operator_id: z.string(),
+    response_type: z.enum(RESPONSE_TYPES),
+    fields: z.array(z.enum(ATTESTABLE_FIELDS)),
+    note: z.string().max(2000).nullable(),
+    evidence: z.array(EvidenceRefSchema).max(20),
+    corrections: z.array(CorrectionSchema).max(20),
+});
+export const ResponseRecordSchema = z.object({
+    response_id: z.string(),
+    receipt_id: z.string(),
+    receipt_revision: z.number().int().positive(),
+    provider_id: z.string().nullable(),
+    statement: ResponseStatementSchema,
+    statement_digest: Digest,
+    provider_signature: z.object({ key_id: z.string(), binding_id: z.string(), value: z.string() }).nullable(),
+    assurance: Assurance,
+    decision: z.object({ status: z.enum(["accepted", "rejected"]), reason: z.string(), decided_by: z.string(), decided_at: Iso }).nullable(),
+    created_at: Iso,
+});
+export const KeyBindingRecordSchema = z.object({
+    binding_id: z.string(),
+    provider_id: z.string(),
+    key_id: z.string(),
+    public_key: z.string(),
+    method: z.enum(["operator_configured", "domain_challenge"]),
+    /** The domain whose DNS TXT record named this key (domain_challenge bindings only). */
+    domain: z.string().nullable().optional(),
+    created_by: z.string(),
+    created_at: Iso,
+    revoked_at: Iso.nullable(),
+});
+export const CaptureGapSchema = z.object({
+    gap_id: z.string(),
+    delegation_id: z.string().nullable(),
+    kind: z.string(),
+    detail: z.string(),
+    reported_at: Iso,
+});
+// ---------- Provider receipt (one delegation; PRD §16 "Receipt contents") ----------
+export const ReceiptFinancialEventSchema = FinancialEventRecordSchema.omit({ liability_owner: true, economic_event_id: true, fx: true }).extend({
+    allocation_version: z.number().int().nonnegative(),
+});
+export const ReceiptPayloadSchema = z.object({
+    document_type: z.literal(RECEIPT_DOCUMENT_TYPE),
+    schema_version: z.enum(SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS),
+    receipt_id: z.string(),
+    revision: z.number().int().positive(),
+    previous_receipt_id: z.string().nullable(),
+    previous_receipt_digest: Digest.nullable(),
+    issued_at: Iso,
+    expires_at: Iso.nullable(),
+    issuer: IssuerSchema,
+    delegation: z.object({
+        delegation_id: z.string(),
+        root_task_id: z.string(),
+        external_ref: z.string().nullable(),
+        provider_job_ref: z.string().nullable(),
+        shared_description: z.string().nullable(),
+        terms_digest: Digest.nullable(),
+        currency: Currency,
+        quoted_max_minor: Minor.nullable(),
+        quote_basis: z.string().nullable(),
+        accepted_amount_minor: Minor.nullable(),
+        expected_delivery: Iso.nullable(),
+        retrospective: z.boolean(),
+        downstream_visibility: z.enum(["unknown", "disclosed", "none"]),
+    }),
+    provider: z.object({
+        provider_id: z.string().nullable(),
+        name_stated: z.string().nullable(),
+        provider_own_id: z.string().nullable(),
+        identity_binding: z.enum(["key_bound", "not_bound"]),
+    }),
+    delivery_claims: z.array(DeliveryClaimSchema.omit({ delegation_id: true })),
+    financial_events: z.array(ReceiptFinancialEventSchema),
+    totals: ReceiptTotalsSchema,
+    field_status: FieldStatusSchema,
+    /** Every non-missing field is unverified by the provider at issuance; attestations live in responses bound to this revision. */
+    unverified_fields: z.array(z.enum(ATTESTABLE_FIELDS)),
+    corrections: z.array(z.object({ response_id: z.string(), receipt_revision: z.number().int().positive(), fields: z.array(z.enum(ATTESTABLE_FIELDS)), decision: z.enum(["accepted", "rejected", "open"]) })),
+    lineage: z.object({ complete: z.boolean(), capture_gaps: z.array(CaptureGapSchema.omit({ delegation_id: true })) }),
+});
+export const SignedReceiptSchema = z.object({ payload: ReceiptPayloadSchema, signature: SignatureSchema, operator_signatures: z.array(OperatorSignatureSchema).optional() });
+// ---------- Private closure snapshot (full root task; PRD §4 step 6, §6) ----------
+export const ClosureDelegationSchema = z.object({
+    delegation_id: z.string(),
+    parent_delegation_id: z.string().nullable(),
+    depth: z.number().int().positive(),
+    provider_id: z.string().nullable(),
+    provider_name_stated: z.string().nullable(),
+    provider_own_id: z.string().nullable(),
+    external_ref: z.string().nullable(),
+    provider_job_ref: z.string().nullable(),
+    scope_ref: z.string().nullable(),
+    currency: Currency,
+    quoted_max_minor: Minor.nullable(),
+    quote_basis: z.string().nullable(),
+    quote_valid_until: Iso.nullable(),
+    accepted_amount_minor: Minor.nullable(),
+    terms_digest: Digest.nullable(),
+    expected_delivery: Iso.nullable(),
+    downstream_visibility: z.enum(["unknown", "disclosed", "none"]),
+    delivery_status: z.string(),
+    retrospective: z.boolean(),
+    created_at: Iso,
+});
+export const AllocationRecordSchema = z.object({
+    allocation_id: z.string(),
+    financial_event_id: z.string(),
+    version: z.number().int().positive(),
+    source_event_digest: Digest,
+    source_amount_minor: Minor,
+    currency: Currency,
+    lines: z.array(z.object({ target: z.object({ type: z.enum(["task", "delegation", "cost_center", "unallocated"]), id: z.string().nullable() }), amount_minor: Minor.nonnegative() })),
+    rounding: z.object({ method: z.enum(["largest_remainder", "none"]), remainder_units: z.array(z.object({ line_index: z.number().int().nonnegative(), units: z.number().int().positive() })) }),
+    rule: z.object({ rule_id: z.string(), version: z.number().int().positive() }).nullable(),
+    reason: z.string(),
+    after_close: z.boolean(),
+    created_by: z.string(),
+    created_at: Iso,
+});
+export const ExceptionRecordSchema = z.object({
+    exception_id: z.string(),
+    kind: z.string(),
+    status: z.enum(["open", "resolved", "dismissed"]),
+    delegation_id: z.string().nullable(),
+    financial_event_id: z.string().nullable(),
+    detail: z.string(),
+    created_at: Iso,
+});
+export const NodeRollupSchema = z.object({
+    node_id: z.string(),
+    parent_id: z.string().nullable(),
+    direct: CurrencyTotalsSchema,
+    descendant: CurrencyTotalsSchema,
+    total: CurrencyTotalsSchema,
+    event_ids: z.array(z.string()),
+});
+export const RollupSchema = z.object({
+    root_task_id: z.string(),
+    nodes: z.array(NodeRollupSchema),
+    root_total: CurrencyTotalsSchema,
+    excluded_event_ids: z.object({ reversed: z.array(z.string()), reversals: z.array(z.string()), fx_rates: z.array(z.string()) }),
+});
+export const DisclosureSchema = z.object({
+    missing: z.array(z.string()),
+    unverified: z.array(z.string()),
+    contested: z.array(z.string()),
+    provider_reported: z.array(z.string()),
+    retrospective: z.array(z.string()),
+});
+/** A delegation backed by a clearing-network obligation, with the obligation's latest decision when the task was closed. */
+export const ObligationLinkSchema = z.object({
+    delegation_id: z.string(),
+    obligation_id: z.string(),
+    decision_id: z.string().nullable(),
+    decision_digest: Digest.nullable(),
+});
+export const ClosurePayloadSchema = z.object({
+    document_type: z.literal(CLOSURE_DOCUMENT_TYPE),
+    schema_version: z.enum(SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS),
+    closure_id: z.string(),
+    version: z.number().int().positive(),
+    previous_closure_id: z.string().nullable(),
+    previous_closure_digest: Digest.nullable(),
+    generated_at: Iso,
+    issuer: IssuerSchema,
+    task: z.object({
+        task_id: z.string(),
+        external_ref: z.string(),
+        currency: Currency,
+        budget_minor: Minor.nullable(),
+        customer_ref: z.string().nullable(),
+        project_ref: z.string().nullable(),
+        cost_center: z.string().nullable(),
+        scope_ref: z.string().nullable(),
+        retrospective: z.boolean(),
+        created_at: Iso,
+    }),
+    delegations: z.array(ClosureDelegationSchema),
+    delivery_claims: z.array(DeliveryClaimSchema),
+    financial_events: z.array(z.object({ record: FinancialEventRecordSchema, event_digest: Digest, attributed_to: z.string() })),
+    allocations: z.array(AllocationRecordSchema),
+    rollup: RollupSchema,
+    open_exceptions: z.array(ExceptionRecordSchema),
+    receipts: z.array(z.object({ receipt_id: z.string(), delegation_id: z.string(), revision: z.number().int().positive(), digest: Digest })),
+    responses: z.array(ResponseRecordSchema),
+    key_bindings: z.array(KeyBindingRecordSchema),
+    lineage: z.object({ complete: z.boolean(), capture_gaps: z.array(CaptureGapSchema), unknown_downstream: z.array(z.string()) }),
+    disclosure: DisclosureSchema,
+    /** Present only when at least one delegation is backed by an obligation, so older closures keep their bytes. */
+    obligation_links: z.array(ObligationLinkSchema).optional(),
+});
+export const SignedClosureSchema = z.object({ payload: ClosurePayloadSchema, signature: SignatureSchema, operator_signatures: z.array(OperatorSignatureSchema).optional() });

package/dist/exceptions.d.ts

@@ -0,0 +1,46 @@
+import type { Rollup } from "./rollup.js";
+import type { DeliveryClaim } from "./documents.js";
+import type { ExceptionKind } from "./types.js";
+/** Exception kinds recomputed from current state; they resolve automatically when the condition clears. */
+export declare const DERIVED_EXCEPTION_KINDS: ExceptionKind[];
+export interface DerivedException {
+    kind: ExceptionKind;
+    /** Stable per condition, so re-deriving never duplicates an open exception. */
+    dedupe_key: string;
+    delegation_id: string | null;
+    detail: string;
+}
+export interface DeriveInput {
+    task: {
+        task_id: string;
+        currency: string;
+        budget_minor: number | null;
+    };
+    delegations: {
+        delegation_id: string;
+        currency: string;
+        quoted_max_minor: number | null;
+        accepted_amount_minor: number | null;
+        quote_valid_until: string | null;
+    }[];
+    claims: DeliveryClaim[];
+    rollup: Rollup;
+    now: string;
+}
+/**
+ * Condition-based exceptions recomputed from current state (PRD §6). They resolve automatically when the
+ * condition clears. Flags only: the product records an overrun, it never claims to have prevented spend.
+ */
+export declare function deriveTaskExceptions(input: DeriveInput): DerivedException[];
+/** The latest exception recorded under a derived exception's dedupe key. */
+export interface LatestException {
+    status: string;
+    resolved_by: string | null;
+    detail: string;
+}
+/**
+ * What to do with a derived exception given the latest one under its dedupe key: a person's resolution of this exact
+ * condition stands ("keep"); an open exception whose condition changed shows the current detail ("update_detail");
+ * otherwise it is opened, which is a no-op when one is already open.
+ */
+export declare function derivedExceptionAction(latest: LatestException | null, derived: DerivedException): "keep" | "update_detail" | "open";

package/dist/exceptions.js

@@ -0,0 +1,52 @@
+/** Exception kinds recomputed from current state; they resolve automatically when the condition clears. */
+export const DERIVED_EXCEPTION_KINDS = ["budget_overrun", "missing_receipt", "amount_mismatch", "stale_quote"];
+/**
+ * Condition-based exceptions recomputed from current state (PRD §6). They resolve automatically when the
+ * condition clears. Flags only: the product records an overrun, it never claims to have prevented spend.
+ */
+export function deriveTaskExceptions(input) {
+    const result = [];
+    const rootTotals = input.rollup.root_total[input.task.currency];
+    if (input.task.budget_minor !== null && rootTotals && rootTotals.net_cost > input.task.budget_minor) {
+        result.push({
+            kind: "budget_overrun",
+            dedupe_key: `budget_overrun:${input.task.task_id}`,
+            delegation_id: null,
+            detail: `net cost ${rootTotals.net_cost} ${input.task.currency} exceeds budget ${input.task.budget_minor}; recorded after the fact, not prevented`,
+        });
+    }
+    for (const d of input.delegations) {
+        const node = input.rollup.nodes.find((n) => n.node_id === d.delegation_id);
+        const own = node?.direct[d.currency];
+        const billed = own ? own.invoiced + own.charged + own.fees + own.adjustments - own.credits - own.refunded : 0;
+        const claims = input.claims.filter((c) => c.delegation_id === d.delegation_id);
+        const superseded = new Set(claims.map((c) => c.supersedes_event_id).filter((id) => id !== null));
+        const active = claims.filter((c) => !superseded.has(c.event_id));
+        const hasDeliveryReceipt = active.some((c) => c.type === "completion" || c.type === "partial_completion");
+        if (billed > 0 && !hasDeliveryReceipt) {
+            result.push({ kind: "missing_receipt", dedupe_key: `missing_receipt:${d.delegation_id}`, delegation_id: d.delegation_id, detail: `billed ${billed} ${d.currency} with no completion receipt recorded` });
+        }
+        const agreed = d.accepted_amount_minor ?? d.quoted_max_minor;
+        if (agreed !== null && billed > agreed) {
+            const basis = d.accepted_amount_minor !== null ? "accepted amount" : "quoted maximum";
+            result.push({ kind: "amount_mismatch", dedupe_key: `amount_mismatch:${d.delegation_id}`, delegation_id: d.delegation_id, detail: `billed ${billed} ${d.currency} exceeds ${basis} ${agreed}` });
+        }
+        const accepted = active.some((c) => c.type === "acceptance");
+        if (d.quote_valid_until !== null && d.quote_valid_until < input.now && !accepted) {
+            result.push({ kind: "stale_quote", dedupe_key: `stale_quote:${d.delegation_id}`, delegation_id: d.delegation_id, detail: `quote expired at ${d.quote_valid_until} without a recorded acceptance` });
+        }
+    }
+    return result;
+}
+/**
+ * What to do with a derived exception given the latest one under its dedupe key: a person's resolution of this exact
+ * condition stands ("keep"); an open exception whose condition changed shows the current detail ("update_detail");
+ * otherwise it is opened, which is a no-op when one is already open.
+ */
+export function derivedExceptionAction(latest, derived) {
+    if (latest && latest.status !== "open" && latest.resolved_by !== "system" && latest.detail === derived.detail)
+        return "keep";
+    if (latest?.status === "open" && latest.detail !== derived.detail)
+        return "update_detail";
+    return "open";
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./documents.js";
+export * from "./allocation.js";
+export * from "./rollup.js";
+export * from "./projection.js";
+export * from "./exceptions.js";
+export * from "./response.js";
+export * from "./verify.js";
+export * from "./bridge.js";
+export * from "./matching.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./documents.js";
+export * from "./allocation.js";
+export * from "./rollup.js";
+export * from "./projection.js";
+export * from "./exceptions.js";
+export * from "./response.js";
+export * from "./verify.js";
+export * from "./bridge.js";
+export * from "./matching.js";

package/dist/matching.d.ts

@@ -0,0 +1,12 @@
+/** A node a financial event's stable references point to, and which references matched. */
+export interface MatchCandidate {
+    task_id: string;
+    delegation_id: string | null;
+    reason: string;
+}
+/**
+ * Candidates from stable references only (PRD §6): one per node, with the matching references joined by "+". A
+ * delegation candidate replaces a task-level candidate for the same task, because it is more specific. An event is
+ * attributed automatically only when exactly one candidate remains.
+ */
+export declare function mergeMatchCandidates(found: MatchCandidate[]): MatchCandidate[];

package/dist/matching.js

@@ -0,0 +1,15 @@
+/**
+ * Candidates from stable references only (PRD §6): one per node, with the matching references joined by "+". A
+ * delegation candidate replaces a task-level candidate for the same task, because it is more specific. An event is
+ * attributed automatically only when exactly one candidate remains.
+ */
+export function mergeMatchCandidates(found) {
+    const byNode = new Map();
+    for (const c of found) {
+        const key = c.delegation_id ?? `task:${c.task_id}`;
+        const existing = byNode.get(key);
+        byNode.set(key, existing ? { ...existing, reason: `${existing.reason}+${c.reason}` } : c);
+    }
+    const delegationTasks = new Set([...byNode.values()].filter((c) => c.delegation_id).map((c) => c.task_id));
+    return [...byNode.values()].filter((c) => c.delegation_id !== null || !delegationTasks.has(c.task_id));
+}

package/dist/projection.d.ts

@@ -0,0 +1,99 @@
+import { type Rollup } from "./rollup.js";
+import { type AllocationRecord, type CaptureGap, type ClosureDelegation, type ClosurePayload, type DeliveryClaim, type Disclosure, type ExceptionRecord, type FieldState, type Issuer, type KeyBindingRecord, type ObligationLink, type ReceiptPayload, type ReceiptTotals, type ResponseRecord } from "./documents.js";
+import { type AttestableField, type FinancialEventRecord } from "./types.js";
+/**
+ * Pure builders for the two projections of one root task (PRD §16): the private closure snapshot
+ * and the provider-specific receipt. The service loads rows; these functions decide what is disclosed.
+ */
+export interface TaskRecord {
+    task_id: string;
+    external_ref: string;
+    currency: string;
+    budget_minor: number | null;
+    customer_ref: string | null;
+    project_ref: string | null;
+    cost_center: string | null;
+    scope_ref: string | null;
+    retrospective: boolean;
+    created_at: string;
+}
+export type DelegationRecord = ClosureDelegation & {
+    root_task_id: string;
+    shared_description: string | null;
+};
+/** Claims superseded by a later correction stay visible and gain the "superseded" label. */
+export declare function labelClaims(claims: DeliveryClaim[]): DeliveryClaim[];
+/** Delivery status is the latest non-superseded status claim. It is a recorded claim, not an adjudicated truth. */
+export declare function deliveryStatus(claims: DeliveryClaim[]): string;
+/** Totals for a single delegation's own events (no allocation detail, which may name other cost centers). */
+export declare function receiptTotals(delegation: Pick<DelegationRecord, "delegation_id" | "currency" | "quoted_max_minor" | "accepted_amount_minor">, events: FinancialEventRecord[]): ReceiptTotals;
+export declare function receiptFieldStatus(delegation: Pick<DelegationRecord, "terms_digest">, claims: DeliveryClaim[], events: FinancialEventRecord[], priorResponses: ResponseRecord[]): Record<AttestableField, FieldState>;
+export interface ReceiptInput {
+    receipt_id: string;
+    revision: number;
+    previous: {
+        receipt_id: string;
+        digest: string;
+    } | null;
+    issued_at: string;
+    expires_at: string | null;
+    issuer: Issuer;
+    delegation: DelegationRecord;
+    provider: {
+        provider_id: string;
+        name: string;
+        provider_own_id: string | null;
+    } | null;
+    provider_key_bound: boolean;
+    claims: DeliveryClaim[];
+    /** Only events attributed to this delegation, including reversals of them. */
+    events: FinancialEventRecord[];
+    /** Current allocation version per financial event (0 = never allocated). */
+    allocation_versions: Record<string, number>;
+    /** Responses to earlier revisions of this receipt chain. */
+    prior_responses: ResponseRecord[];
+    capture_gaps: CaptureGap[];
+}
+/**
+ * Provider receipt: one delegation only. Omits sibling delegations, root customer/project/cost-center data,
+ * allocation lines, liability and economic-event IDs, and private event hashes (acceptance 8, 19).
+ */
+export declare function buildReceiptPayload(input: ReceiptInput): ReceiptPayload;
+/** Latest allocation lines per financial event, the input the roll-up uses. */
+export declare function latestAllocations(allocations: AllocationRecord[]): Record<string, AllocationRecord>;
+export declare function rollupFor(task: TaskRecord, delegations: ClosureDelegation[], events: {
+    record: FinancialEventRecord;
+    attributed_to: string;
+}[], allocations: AllocationRecord[]): Rollup;
+export interface ClosureInput {
+    closure_id: string;
+    version: number;
+    previous: {
+        closure_id: string;
+        digest: string;
+    } | null;
+    generated_at: string;
+    issuer: Issuer;
+    task: TaskRecord;
+    delegations: ClosureDelegation[];
+    claims: DeliveryClaim[];
+    events: {
+        record: FinancialEventRecord;
+        attributed_to: string;
+    }[];
+    allocations: AllocationRecord[];
+    open_exceptions: ExceptionRecord[];
+    receipts: {
+        receipt_id: string;
+        delegation_id: string;
+        revision: number;
+        digest: string;
+    }[];
+    responses: ResponseRecord[];
+    key_bindings: KeyBindingRecord[];
+    capture_gaps: CaptureGap[];
+    obligation_links?: ObligationLink[];
+}
+export declare function closureDisclosure(input: Pick<ClosureInput, "task" | "delegations" | "claims" | "events" | "responses" | "receipts">): Disclosure;
+/** Private closure snapshot of the full root task: lineage, event digests, all allocation versions, roll-up, and open exceptions. */
+export declare function buildClosurePayload(input: ClosureInput): ClosurePayload;