@atcn/subledger 1.3.2 → 1.4.1

package/dist/documents.d.ts

@@ -2,12 +2,14 @@ import { z } from "zod";
 /**
  * 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).
+ * 1.2 documents must use neither. Schema 1.4 adds delegation `execution`, the response statement fields `execution`,
+ * `issued_at`, `expires_at` and `refs`, and the `expired` and `revoked` labels; 1.2 and 1.3 documents must use none
+ * of them (see packages/schema/COMPATIBILITY.md).
  */
-export declare const SUBLEDGER_SCHEMA_VERSION: "1.3";
-export declare const SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS: readonly ["1.2", "1.3"];
+export declare const SUBLEDGER_SCHEMA_VERSION: "1.4";
+export declare const SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS: readonly ["1.2", "1.3", "1.4"];
 /** Must equal this package's version in package.json (checked by a test). */
-export declare const SUBLEDGER_VERIFIER_VERSION: "1.3.2";
+export declare const SUBLEDGER_VERIFIER_VERSION: "1.4.1";
 export declare const RECEIPT_DOCUMENT_TYPE: "atcn.subledger.receipt";
 export declare const CLOSURE_DOCUMENT_TYPE: "atcn.subledger.closure";
 export declare const RESPONSE_STATEMENT_TYPE: "atcn.subledger.receipt_response";
@@ -180,6 +182,8 @@ export declare const DeliveryClaimSchema: z.ZodObject<{
         provider_key_signed: "provider_key_signed";
         contested: "contested";
         superseded: "superseded";
+        expired: "expired";
+        revoked: "revoked";
     }>>;
     note: z.ZodNullable<z.ZodString>;
     evidence: z.ZodArray<z.ZodObject<{
@@ -259,6 +263,20 @@ export declare const ResponseStatementSchema: z.ZodObject<{
         proposed_value: z.ZodString;
         reason: z.ZodString;
     }, z.core.$strip>>;
+    execution: z.ZodOptional<z.ZodObject<{
+        execution_id: z.ZodString;
+        execution_digest: z.ZodString;
+    }, z.core.$strip>>;
+    issued_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        relation: z.ZodEnum<{
+            revokes: "revokes";
+            disputes: "disputes";
+        }>;
+        attestation_digest: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ResponseStatement = z.infer<typeof ResponseStatementSchema>;
 export declare const ResponseRecordSchema: z.ZodObject<{
@@ -303,6 +321,20 @@ export declare const ResponseRecordSchema: z.ZodObject<{
             proposed_value: z.ZodString;
             reason: z.ZodString;
         }, z.core.$strip>>;
+        execution: z.ZodOptional<z.ZodObject<{
+            execution_id: z.ZodString;
+            execution_digest: z.ZodString;
+        }, z.core.$strip>>;
+        issued_at: z.ZodOptional<z.ZodString>;
+        expires_at: z.ZodOptional<z.ZodString>;
+        refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            relation: z.ZodEnum<{
+                revokes: "revokes";
+                disputes: "disputes";
+            }>;
+            attestation_digest: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     statement_digest: z.ZodString;
     provider_signature: z.ZodNullable<z.ZodObject<{
@@ -320,6 +352,8 @@ export declare const ResponseRecordSchema: z.ZodObject<{
         provider_key_signed: "provider_key_signed";
         contested: "contested";
         superseded: "superseded";
+        expired: "expired";
+        revoked: "revoked";
     }>>;
     decision: z.ZodNullable<z.ZodObject<{
         status: z.ZodEnum<{
@@ -410,8 +444,9 @@ export declare const ReceiptFinancialEventSchema: z.ZodObject<{
 export declare const ReceiptPayloadSchema: z.ZodObject<{
     document_type: z.ZodLiteral<"atcn.subledger.receipt">;
     schema_version: z.ZodEnum<{
-        1.3: "1.3";
+        1.4: "1.4";
         1.2: "1.2";
+        1.3: "1.3";
     }>;
     receipt_id: z.ZodString;
     revision: z.ZodNumber;
@@ -445,6 +480,30 @@ export declare const ReceiptPayloadSchema: z.ZodObject<{
             disclosed: "disclosed";
             none: "none";
         }>;
+        execution: z.ZodOptional<z.ZodObject<{
+            execution_id: z.ZodString;
+            protocol: z.ZodOptional<z.ZodObject<{
+                name: z.ZodLiteral<"a2a">;
+                task_id: z.ZodString;
+                context_id: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            agent: z.ZodObject<{
+                agent_id: z.ZodString;
+                agent_version: z.ZodString;
+                card_digest: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    name: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strip>>;
+                config_digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            skill: z.ZodOptional<z.ZodObject<{
+                namespace: z.ZodString;
+                skill_id: z.ZodString;
+                agent_card_url: z.ZodOptional<z.ZodURL>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     provider: z.ZodObject<{
         provider_id: z.ZodNullable<z.ZodString>;
@@ -493,6 +552,8 @@ export declare const ReceiptPayloadSchema: z.ZodObject<{
             provider_key_signed: "provider_key_signed";
             contested: "contested";
             superseded: "superseded";
+            expired: "expired";
+            revoked: "revoked";
         }>>;
         recorded_at: z.ZodString;
     }, z.core.$strip>>;
@@ -612,8 +673,9 @@ export declare const SignedReceiptSchema: z.ZodObject<{
     payload: z.ZodObject<{
         document_type: z.ZodLiteral<"atcn.subledger.receipt">;
         schema_version: z.ZodEnum<{
-            1.3: "1.3";
+            1.4: "1.4";
             1.2: "1.2";
+            1.3: "1.3";
         }>;
         receipt_id: z.ZodString;
         revision: z.ZodNumber;
@@ -647,6 +709,30 @@ export declare const SignedReceiptSchema: z.ZodObject<{
                 disclosed: "disclosed";
                 none: "none";
             }>;
+            execution: z.ZodOptional<z.ZodObject<{
+                execution_id: z.ZodString;
+                protocol: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodLiteral<"a2a">;
+                    task_id: z.ZodString;
+                    context_id: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                agent: z.ZodObject<{
+                    agent_id: z.ZodString;
+                    agent_version: z.ZodString;
+                    card_digest: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodString;
+                        name: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strip>>;
+                    config_digest: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                skill: z.ZodOptional<z.ZodObject<{
+                    namespace: z.ZodString;
+                    skill_id: z.ZodString;
+                    agent_card_url: z.ZodOptional<z.ZodURL>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
         provider: z.ZodObject<{
             provider_id: z.ZodNullable<z.ZodString>;
@@ -695,6 +781,8 @@ export declare const SignedReceiptSchema: z.ZodObject<{
                 provider_key_signed: "provider_key_signed";
                 contested: "contested";
                 superseded: "superseded";
+                expired: "expired";
+                revoked: "revoked";
             }>>;
             recorded_at: z.ZodString;
         }, z.core.$strip>>;
@@ -848,6 +936,30 @@ export declare const ClosureDelegationSchema: z.ZodObject<{
     delivery_status: z.ZodString;
     retrospective: z.ZodBoolean;
     created_at: z.ZodString;
+    execution: z.ZodOptional<z.ZodObject<{
+        execution_id: z.ZodString;
+        protocol: z.ZodOptional<z.ZodObject<{
+            name: z.ZodLiteral<"a2a">;
+            task_id: z.ZodString;
+            context_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        agent: z.ZodObject<{
+            agent_id: z.ZodString;
+            agent_version: z.ZodString;
+            card_digest: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strip>>;
+            config_digest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        skill: z.ZodOptional<z.ZodObject<{
+            namespace: z.ZodString;
+            skill_id: z.ZodString;
+            agent_card_url: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ClosureDelegation = z.infer<typeof ClosureDelegationSchema>;
 export declare const AllocationRecordSchema: z.ZodObject<{
@@ -1052,8 +1164,9 @@ export type ObligationLink = z.infer<typeof ObligationLinkSchema>;
 export declare const ClosurePayloadSchema: z.ZodObject<{
     document_type: z.ZodLiteral<"atcn.subledger.closure">;
     schema_version: z.ZodEnum<{
-        1.3: "1.3";
+        1.4: "1.4";
         1.2: "1.2";
+        1.3: "1.3";
     }>;
     closure_id: z.ZodString;
     version: z.ZodNumber;
@@ -1105,6 +1218,30 @@ export declare const ClosurePayloadSchema: z.ZodObject<{
         delivery_status: z.ZodString;
         retrospective: z.ZodBoolean;
         created_at: z.ZodString;
+        execution: z.ZodOptional<z.ZodObject<{
+            execution_id: z.ZodString;
+            protocol: z.ZodOptional<z.ZodObject<{
+                name: z.ZodLiteral<"a2a">;
+                task_id: z.ZodString;
+                context_id: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            agent: z.ZodObject<{
+                agent_id: z.ZodString;
+                agent_version: z.ZodString;
+                card_digest: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    name: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strip>>;
+                config_digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            skill: z.ZodOptional<z.ZodObject<{
+                namespace: z.ZodString;
+                skill_id: z.ZodString;
+                agent_card_url: z.ZodOptional<z.ZodURL>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     delivery_claims: z.ZodArray<z.ZodObject<{
         event_id: z.ZodString;
@@ -1135,6 +1272,8 @@ export declare const ClosurePayloadSchema: z.ZodObject<{
             provider_key_signed: "provider_key_signed";
             contested: "contested";
             superseded: "superseded";
+            expired: "expired";
+            revoked: "revoked";
         }>>;
         note: z.ZodNullable<z.ZodString>;
         evidence: z.ZodArray<z.ZodObject<{
@@ -1386,6 +1525,20 @@ export declare const ClosurePayloadSchema: z.ZodObject<{
                 proposed_value: z.ZodString;
                 reason: z.ZodString;
             }, z.core.$strip>>;
+            execution: z.ZodOptional<z.ZodObject<{
+                execution_id: z.ZodString;
+                execution_digest: z.ZodString;
+            }, z.core.$strip>>;
+            issued_at: z.ZodOptional<z.ZodString>;
+            expires_at: z.ZodOptional<z.ZodString>;
+            refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                relation: z.ZodEnum<{
+                    revokes: "revokes";
+                    disputes: "disputes";
+                }>;
+                attestation_digest: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         statement_digest: z.ZodString;
         provider_signature: z.ZodNullable<z.ZodObject<{
@@ -1403,6 +1556,8 @@ export declare const ClosurePayloadSchema: z.ZodObject<{
             provider_key_signed: "provider_key_signed";
             contested: "contested";
             superseded: "superseded";
+            expired: "expired";
+            revoked: "revoked";
         }>>;
         decision: z.ZodNullable<z.ZodObject<{
             status: z.ZodEnum<{
@@ -1459,8 +1614,9 @@ export declare const SignedClosureSchema: z.ZodObject<{
     payload: z.ZodObject<{
         document_type: z.ZodLiteral<"atcn.subledger.closure">;
         schema_version: z.ZodEnum<{
-            1.3: "1.3";
+            1.4: "1.4";
             1.2: "1.2";
+            1.3: "1.3";
         }>;
         closure_id: z.ZodString;
         version: z.ZodNumber;
@@ -1512,6 +1668,30 @@ export declare const SignedClosureSchema: z.ZodObject<{
             delivery_status: z.ZodString;
             retrospective: z.ZodBoolean;
             created_at: z.ZodString;
+            execution: z.ZodOptional<z.ZodObject<{
+                execution_id: z.ZodString;
+                protocol: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodLiteral<"a2a">;
+                    task_id: z.ZodString;
+                    context_id: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                agent: z.ZodObject<{
+                    agent_id: z.ZodString;
+                    agent_version: z.ZodString;
+                    card_digest: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodString;
+                        name: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strip>>;
+                    config_digest: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                skill: z.ZodOptional<z.ZodObject<{
+                    namespace: z.ZodString;
+                    skill_id: z.ZodString;
+                    agent_card_url: z.ZodOptional<z.ZodURL>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         delivery_claims: z.ZodArray<z.ZodObject<{
             event_id: z.ZodString;
@@ -1542,6 +1722,8 @@ export declare const SignedClosureSchema: z.ZodObject<{
                 provider_key_signed: "provider_key_signed";
                 contested: "contested";
                 superseded: "superseded";
+                expired: "expired";
+                revoked: "revoked";
             }>>;
             note: z.ZodNullable<z.ZodString>;
             evidence: z.ZodArray<z.ZodObject<{
@@ -1793,6 +1975,20 @@ export declare const SignedClosureSchema: z.ZodObject<{
                     proposed_value: z.ZodString;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
+                execution: z.ZodOptional<z.ZodObject<{
+                    execution_id: z.ZodString;
+                    execution_digest: z.ZodString;
+                }, z.core.$strip>>;
+                issued_at: z.ZodOptional<z.ZodString>;
+                expires_at: z.ZodOptional<z.ZodString>;
+                refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    relation: z.ZodEnum<{
+                        revokes: "revokes";
+                        disputes: "disputes";
+                    }>;
+                    attestation_digest: z.ZodString;
+                    reason: z.ZodString;
+                }, z.core.$strip>>>;
             }, z.core.$strip>;
             statement_digest: z.ZodString;
             provider_signature: z.ZodNullable<z.ZodObject<{
@@ -1810,6 +2006,8 @@ export declare const SignedClosureSchema: z.ZodObject<{
                 provider_key_signed: "provider_key_signed";
                 contested: "contested";
                 superseded: "superseded";
+                expired: "expired";
+                revoked: "revoked";
             }>>;
             decision: z.ZodNullable<z.ZodObject<{
                 status: z.ZodEnum<{

package/dist/documents.js

@@ -1,14 +1,17 @@
+import { AttestationRefSchema, ExecutionBindingSchema, ExecutionDescriptorSchema } from "@atcn/schema";
 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).
+ * 1.2 documents must use neither. Schema 1.4 adds delegation `execution`, the response statement fields `execution`,
+ * `issued_at`, `expires_at` and `refs`, and the `expired` and `revoked` labels; 1.2 and 1.3 documents must use none
+ * of them (see packages/schema/COMPATIBILITY.md).
  */
-export const SUBLEDGER_SCHEMA_VERSION = "1.3";
-export const SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS = ["1.2", "1.3"];
+export const SUBLEDGER_SCHEMA_VERSION = "1.4";
+export const SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS = ["1.2", "1.3", "1.4"];
 /** Must equal this package's version in package.json (checked by a test). */
-export const SUBLEDGER_VERIFIER_VERSION = "1.3.2";
+export const SUBLEDGER_VERIFIER_VERSION = "1.4.1";
 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";
@@ -120,6 +123,13 @@ export const ResponseStatementSchema = z.object({
     note: z.string().max(2000).nullable(),
     evidence: z.array(EvidenceRefSchema).max(20),
     corrections: z.array(CorrectionSchema).max(20),
+    /** Schema 1.4: the run the statement is about; must match the delegation's recorded execution. */
+    execution: ExecutionBindingSchema.optional(),
+    /** Schema 1.4: when the provider signed. Required with expires_at or refs. */
+    issued_at: Iso.optional(),
+    expires_at: Iso.optional(),
+    /** Schema 1.4: earlier statements this one revokes (same provider only) or disputes, by statement digest. */
+    refs: z.array(AttestationRefSchema).max(20).optional(),
 });
 export const ResponseRecordSchema = z.object({
     response_id: z.string(),
@@ -180,6 +190,8 @@ export const ReceiptPayloadSchema = z.object({
         expected_delivery: Iso.nullable(),
         retrospective: z.boolean(),
         downstream_visibility: z.enum(["unknown", "disclosed", "none"]),
+        /** Schema 1.4, present only when recorded: the run a provider statement can cite. */
+        execution: ExecutionDescriptorSchema.optional(),
     }),
     provider: z.object({
         provider_id: z.string().nullable(),
@@ -219,6 +231,8 @@ export const ClosureDelegationSchema = z.object({
     delivery_status: z.string(),
     retrospective: z.boolean(),
     created_at: Iso,
+    /** Schema 1.4, present only when recorded, so older closures keep their bytes. */
+    execution: ExecutionDescriptorSchema.optional(),
 });
 export const AllocationRecordSchema = z.object({
     allocation_id: z.string(),

package/dist/projection.d.ts

@@ -1,3 +1,4 @@
+import { type AttestationItem } from "@atcn/schema";
 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";
@@ -23,6 +24,10 @@ export type DelegationRecord = ClosureDelegation & {
 };
 /** Claims superseded by a later correction stay visible and gain the "superseded" label. */
 export declare function labelClaims(claims: DeliveryClaim[]): DeliveryClaim[];
+/** A response as an attestation. Only a key-signed statement has a signer, so only it can revoke or be revoked. */
+export declare function responseAttestation(response: ResponseRecord): AttestationItem;
+/** Recomputes the "expired" and "revoked" labels as of `at`. Revoked and expired responses stay visible. */
+export declare function labelResponses(responses: ResponseRecord[], at: string): ResponseRecord[];
 /** 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). */

package/dist/projection.js

@@ -1,4 +1,4 @@
-import { digestOf } from "@atcn/schema";
+import { digestOf, resolveAttestations } from "@atcn/schema";
 import { computeRollup, costSign } from "./rollup.js";
 import { CLOSURE_DOCUMENT_TYPE, RECEIPT_DOCUMENT_TYPE, SUBLEDGER_SCHEMA_VERSION, } from "./documents.js";
 import { ATTESTABLE_FIELDS } from "./types.js";
@@ -7,6 +7,32 @@ export function labelClaims(claims) {
     const superseded = new Set(claims.map((c) => c.supersedes_event_id).filter((id) => id !== null));
     return claims.map((c) => (superseded.has(c.event_id) && !c.assurance.includes("superseded") ? { ...c, assurance: [...c.assurance, "superseded"] } : c));
 }
+/** A response as an attestation. Only a key-signed statement has a signer, so only it can revoke or be revoked. */
+export function responseAttestation(response) {
+    const s = response.statement;
+    return {
+        digest: response.statement_digest,
+        signer: response.assurance.includes("provider_key_signed") ? response.provider_id : null,
+        issued_at: s.issued_at,
+        expires_at: s.expires_at,
+        refs: s.refs,
+    };
+}
+const TIME_LABELS = ["expired", "revoked"];
+/** Recomputes the "expired" and "revoked" labels as of `at`. Revoked and expired responses stay visible. */
+export function labelResponses(responses, at) {
+    const { status } = resolveAttestations(responses.map(responseAttestation), at);
+    return responses.map((r) => {
+        const kept = r.assurance.filter((label) => !TIME_LABELS.includes(label));
+        const added = [];
+        if (status[r.statement_digest].time === "expired")
+            added.push("expired");
+        if (status[r.statement_digest].revoked_by !== null)
+            added.push("revoked");
+        const assurance = [...kept, ...added];
+        return assurance.length === r.assurance.length && assurance.every((label, i) => label === r.assurance[i]) ? r : { ...r, assurance };
+    });
+}
 const STATUS_BY_CLAIM = {
     acceptance: "accepted",
     completion: "completed",
@@ -103,6 +129,7 @@ export function buildReceiptPayload(input) {
             expected_delivery: d.expected_delivery,
             retrospective: d.retrospective,
             downstream_visibility: d.downstream_visibility,
+            ...(d.execution ? { execution: d.execution } : {}),
         },
         provider: {
             provider_id: input.provider?.provider_id ?? null,
@@ -205,7 +232,7 @@ export function buildClosurePayload(input) {
         rollup: rollupFor(input.task, input.delegations, input.events, input.allocations),
         open_exceptions: input.open_exceptions,
         receipts: input.receipts,
-        responses: input.responses,
+        responses: labelResponses(input.responses, input.generated_at),
         key_bindings: input.key_bindings,
         lineage: {
             complete: input.capture_gaps.length === 0,

package/dist/response.d.ts

@@ -1,3 +1,4 @@
+import { type AttestationRef, type ExecutionBinding } from "@atcn/schema";
 import { type Correction, type ResponseStatement } from "./documents.js";
 import type { AttestableField, EvidenceRef, ResponseType } from "./types.js";
 export interface StatementInput {
@@ -12,6 +13,11 @@ export interface StatementInput {
     note?: string | null;
     evidence?: EvidenceRef[];
     corrections?: Correction[];
+    /** Schema 1.4 fields. Each is left out of the statement when not given, so older statements keep their bytes. */
+    execution?: ExecutionBinding;
+    issued_at?: string;
+    expires_at?: string;
+    refs?: AttestationRef[];
 }
 /** Builds the statement a provider responds with. Field order is irrelevant: the signature covers canonical JSON. */
 export declare function buildResponseStatement(input: StatementInput): ResponseStatement;

package/dist/response.js

@@ -13,6 +13,10 @@ export function buildResponseStatement(input) {
         note: input.note ?? null,
         evidence: input.evidence ?? [],
         corrections: input.corrections ?? [],
+        ...(input.execution !== undefined ? { execution: input.execution } : {}),
+        ...(input.issued_at !== undefined ? { issued_at: input.issued_at } : {}),
+        ...(input.expires_at !== undefined ? { expires_at: input.expires_at } : {}),
+        ...(input.refs !== undefined ? { refs: input.refs } : {}),
     };
 }
 export function statementDigest(statement) {

package/dist/types.d.ts

@@ -20,7 +20,7 @@ export type ClaimAsserter = (typeof CLAIM_ASSERTERS)[number];
 export declare const EXCEPTION_KINDS: readonly ["budget_overrun", "unmatched_charge", "ambiguous_match", "missing_receipt", "duplicate_event", "amount_mismatch", "currency_mismatch", "stale_quote", "refund_after_close", "allocation_changed_after_close", "incomplete_lineage"];
 export type ExceptionKind = (typeof EXCEPTION_KINDS)[number];
 /** Trust labels kept separate on every screen and export (PRD §16 "Identity assurance"). Never collapsed into "verified". */
-export declare const ASSURANCE_LABELS: readonly ["issuer_signed", "buyer_recorded", "network_recorded", "recipient_viewed", "link_authenticated_response", "provider_identity_bound", "provider_key_signed", "contested", "superseded"];
+export declare const ASSURANCE_LABELS: readonly ["issuer_signed", "buyer_recorded", "network_recorded", "recipient_viewed", "link_authenticated_response", "provider_identity_bound", "provider_key_signed", "contested", "superseded", "expired", "revoked"];
 export type AssuranceLabel = (typeof ASSURANCE_LABELS)[number];
 export declare const RESPONSE_TYPES: readonly ["acknowledge_view", "acknowledge_delivery", "submit_evidence", "propose_correction", "signed_attestation"];
 export type ResponseType = (typeof RESPONSE_TYPES)[number];
@@ -76,6 +76,30 @@ export declare const DelegationInputSchema: z.ZodObject<{
         none: "none";
     }>>;
     retrospective: z.ZodDefault<z.ZodBoolean>;
+    execution: z.ZodOptional<z.ZodObject<{
+        execution_id: z.ZodString;
+        protocol: z.ZodOptional<z.ZodObject<{
+            name: z.ZodLiteral<"a2a">;
+            task_id: z.ZodString;
+            context_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        agent: z.ZodObject<{
+            agent_id: z.ZodString;
+            agent_version: z.ZodString;
+            card_digest: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strip>>;
+            config_digest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        skill: z.ZodOptional<z.ZodObject<{
+            namespace: z.ZodString;
+            skill_id: z.ZodString;
+            agent_card_url: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type DelegationInput = z.infer<typeof DelegationInputSchema>;
 export declare const DelegationEventInputSchema: z.ZodObject<{

package/dist/types.js

@@ -1,3 +1,4 @@
+import { ExecutionDescriptorSchema } from "@atcn/schema";
 import { z } from "zod";
 /** Agent Work Subledger record shapes (PRD v1.2 §6-§7). Amounts are integer minor units; currencies are ISO 4217. */
 export const Currency = z.string().regex(/^[A-Z]{3}$/, "ISO 4217 currency code");
@@ -41,6 +42,10 @@ export const ASSURANCE_LABELS = [
     "provider_key_signed",
     "contested",
     "superseded",
+    /** A response statement past its signed expires_at at the document's time (schema 1.4). */
+    "expired",
+    /** A response statement revoked by a later statement from the same provider (schema 1.4). */
+    "revoked",
 ];
 export const RESPONSE_TYPES = ["acknowledge_view", "acknowledge_delivery", "submit_evidence", "propose_correction", "signed_attestation"];
 export const SHARE_ACTIONS = ["view", "acknowledge_delivery", "submit_evidence", "propose_correction", "signed_attestation"];
@@ -93,6 +98,8 @@ export const DelegationInputSchema = z.object({
     /** Whether the provider disclosed its own subdelegations. Absent data stays "unknown" (acceptance 24). */
     downstream_visibility: z.enum(["unknown", "disclosed", "none"]).default("unknown"),
     retrospective: z.boolean().default(false),
+    /** The provider's run as the buyer recorded it (for A2A, from the task and agent card). Provider statements can cite it. */
+    execution: ExecutionDescriptorSchema.optional(),
 });
 export const DelegationEventInputSchema = z.object({
     type: z.enum(DELIVERY_EVENT_TYPES),

package/dist/verify.d.ts

@@ -23,6 +23,8 @@ export interface SubledgerVerifyOptions {
     requireOperatorSignature?: boolean;
     /** Closure packages (GET /v1/exports/{obligation_id}) of the obligations backing linked delegations, to cross-check them. */
     obligationPackages?: unknown[];
+    /** Time to check a receipt's expires_at against (ISO 8601). Defaults to now. */
+    at?: string;
 }
 /** Detects the document type and verifies it offline: no network calls, no service access (acceptance 9). */
 export declare function verifySubledgerDocument(input: unknown, options: SubledgerVerifyOptions): SubledgerVerificationReport;

package/dist/verify.js

@@ -1,8 +1,8 @@
 import { verifyClosurePackage } from "@atcn/core";
-import { ClosurePackageSchema, digestOf, verifyPayload } from "@atcn/schema";
+import { ClosurePackageSchema, digestOf, executionBinding, resolveAttestations, verifyPayload } from "@atcn/schema";
 import { CLEARING_SOURCE, clearingFacts, settlementEvidence, undoneBatch } from "./bridge.js";
 import { CLOSURE_DOCUMENT_TYPE, RECEIPT_DOCUMENT_TYPE, SignedClosureSchema, SignedReceiptSchema, SIGNED_BY_HOSTED_SERVICE, SUBLEDGER_VERIFIER_VERSION, SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS, } from "./documents.js";
-import { receiptTotals, rollupFor } from "./projection.js";
+import { labelResponses, receiptTotals, responseAttestation, rollupFor } from "./projection.js";
 import { verifyCountersignature, verifyStatementSignature } from "./response.js";
 import { ATTESTABLE_FIELDS } from "./types.js";
 const SERVICE_ACTOR = "svc_atcn";
@@ -65,8 +65,9 @@ function unsupportedVersion(documentType, input) {
     const supported = SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS;
     if (supported.includes(version))
         return null;
+    const versions = [...SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS];
     const detail = `unsupported schema_version ${String(version)}: this verifier (@atcn/subledger ${SUBLEDGER_VERIFIER_VERSION}) supports ` +
-        `${SUPPORTED_SUBLEDGER_SCHEMA_VERSIONS.join(" and ")}. Upgrade @atcn/verify-cli (or @atcn/subledger) to the minimum ` +
+        `${versions.slice(0, -1).join(", ")} and ${versions.at(-1)}. Upgrade @atcn/verify-cli (or @atcn/subledger) to the minimum ` +
         "version listed for this schema in packages/schema/COMPATIBILITY.md.";
     return { valid: false, document_type: documentType, unsupported_schema_version: String(version), checks: [check("schema_version", [detail])] };
 }
@@ -84,6 +85,24 @@ function versionFeatureProblems(version, signedBy, claims, hasObligationLinks) {
         problems.push(`schema 1.2 does not allow signed_by ${signedBy}`);
     return problems;
 }
+const SCHEMA_1_4_STATEMENT_FIELDS = ["execution", "issued_at", "expires_at", "refs"];
+const SCHEMA_1_4_LABELS = ["expired", "revoked"];
+/** A document that declares 1.2 or 1.3 must not carry 1.4 fields, which those verifiers would drop before checking signatures. */
+function schema14Problems(version, delegations, responses, claims) {
+    if (version !== "1.2" && version !== "1.3")
+        return [];
+    const problems = delegations.filter((d) => d.execution !== undefined).map((d) => `schema ${version} does not allow execution on delegation ${d.delegation_id}`);
+    for (const r of responses) {
+        for (const field of SCHEMA_1_4_STATEMENT_FIELDS)
+            if (r.statement[field] !== undefined)
+                problems.push(`schema ${version} does not allow statement ${field} (response ${r.response_id})`);
+    }
+    for (const item of [...responses, ...claims]) {
+        for (const label of item.assurance.filter((l) => SCHEMA_1_4_LABELS.includes(l)))
+            problems.push(`schema ${version} does not allow assurance ${label}`);
+    }
+    return problems;
+}
 function reversalProblems(events) {
     const byId = new Map(events.map((e) => [e.financial_event_id, e]));
     const problems = [];
@@ -105,7 +124,10 @@ export function verifyReceipt(input, options) {
         return schemaFailure(RECEIPT_DOCUMENT_TYPE, parsed.error.issues);
     const doc = parsed.data;
     const r = doc.payload;
-    const schemaProblems = versionFeatureProblems(r.schema_version, r.issuer.signed_by, r.delivery_claims, false);
+    const schemaProblems = [
+        ...versionFeatureProblems(r.schema_version, r.issuer.signed_by, r.delivery_claims, false),
+        ...schema14Problems(r.schema_version, [r.delegation], [], r.delivery_claims),
+    ];
     const checks = [check("schema", schemaProblems), signatureCheck(doc, r.issued_at, options.trustedKeys), operatorSignatureCheck(r, r.issuer.operator_id, doc.operator_signatures, options)];
     const events = r.financial_events.map(({ allocation_version: _version, ...e }) => ({ ...e, liability_owner: null, economic_event_id: null, fx: null }));
     checks.push(check("reversals", reversalProblems(events)));
@@ -120,8 +142,17 @@ export function verifyReceipt(input, options) {
             fieldProblems.push(`field_status is missing ${f}`);
     checks.push(check("field_disclosure", fieldProblems));
     checks.push(receiptChainCheck(r, options));
+    checks.push(receiptExpiryCheck(r, options.at ?? new Date().toISOString()));
     return finish(RECEIPT_DOCUMENT_TYPE, checks);
 }
+/** The issuer signed expires_at, so a receipt past it no longer stands, even though its signature still verifies. */
+function receiptExpiryCheck(r, at) {
+    if (r.expires_at === null)
+        return { name: "expiry", ok: true, details: ["no expiry"] };
+    if (Date.parse(at) >= Date.parse(r.expires_at))
+        return check("expiry", [`receipt expired at ${r.expires_at} (checked at ${at})`]);
+    return { name: "expiry", ok: true, details: [`valid until ${r.expires_at} (checked at ${at})`] };
+}
 function receiptChainCheck(r, options) {
     if (r.revision === 1)
         return check("revision_chain", r.previous_receipt_digest === null && r.previous_receipt_id === null ? [] : ["revision 1 must not reference a previous receipt"]);
@@ -155,7 +186,10 @@ export function verifyClosure(input, options) {
         return schemaFailure(CLOSURE_DOCUMENT_TYPE, parsed.error.issues);
     const doc = parsed.data;
     const c = doc.payload;
-    const schemaProblems = versionFeatureProblems(c.schema_version, c.issuer.signed_by, c.delivery_claims, c.obligation_links !== undefined);
+    const schemaProblems = [
+        ...versionFeatureProblems(c.schema_version, c.issuer.signed_by, c.delivery_claims, c.obligation_links !== undefined),
+        ...schema14Problems(c.schema_version, c.delegations, c.responses, c.delivery_claims),
+    ];
     const checks = [check("schema", schemaProblems), signatureCheck(doc, c.generated_at, options.trustedKeys), operatorSignatureCheck(c, c.issuer.operator_id, doc.operator_signatures, options)];
     const digestProblems = c.financial_events.filter((e) => digestOf(e.record) !== e.event_digest).map((e) => `event ${e.record.financial_event_id} digest mismatch`);
     const ids = c.financial_events.map((e) => e.record.financial_event_id);
@@ -167,7 +201,7 @@ export function verifyClosure(input, options) {
     checks.push(check("allocations", allocationProblems(c)));
     const recomputed = rollupFor(c.task, c.delegations, c.financial_events, c.allocations);
     checks.push(check("totals", digestOf(recomputed) === digestOf(c.rollup) ? [] : ["roll-up does not match events, attribution, and allocations"]));
-    checks.push(check("provider_responses", responseProblems(c)));
+    checks.push(providerResponsesCheck(c));
     checks.push(closureChainCheck(c, options));
     checks.push(obligationLinkCheck(c, options));
     return finish(CLOSURE_DOCUMENT_TYPE, checks);
@@ -309,12 +343,39 @@ function allocationProblems(c) {
     }
     return problems;
 }
+function providerResponsesCheck(c) {
+    const problems = responseProblems(c);
+    const notes = [];
+    const resolution = resolveAttestations(c.responses.map(responseAttestation), c.generated_at);
+    const responseIdOf = new Map(c.responses.map((r) => [r.statement_digest, r.response_id]));
+    for (const p of resolution.problems) {
+        const id = responseIdOf.get(p.digest);
+        if (p.code === "revocation_not_by_signer")
+            problems.push(`response ${id} revokes ${p.target}, which its provider key did not sign`);
+        else
+            notes.push(`response ${id} references ${p.target}, which is not in this closure`);
+    }
+    for (const r of c.responses) {
+        if (resolution.status[r.statement_digest].time === "not_yet_valid")
+            problems.push(`response ${r.response_id} was issued after the closure was generated`);
+    }
+    const expected = new Map(labelResponses(c.responses, c.generated_at).map((r) => [r.response_id, r.assurance]));
+    for (const r of c.responses) {
+        for (const label of SCHEMA_1_4_LABELS) {
+            const shouldHave = expected.get(r.response_id).includes(label);
+            if (shouldHave !== r.assurance.includes(label)) {
+                problems.push(`response ${r.response_id} ${shouldHave ? "lacks" : "carries"} assurance ${label}, which does not match its expiry and revocations at ${c.generated_at}`);
+            }
+        }
+    }
+    return problems.length > 0 ? check("provider_responses", problems) : { name: "provider_responses", ok: true, details: notes };
+}
 function responseProblems(c) {
     const problems = [];
     const receipts = new Map(c.receipts.map((r) => [r.receipt_id, r]));
-    const delegationIds = new Set(c.delegations.map((d) => d.delegation_id));
+    const delegations = new Map(c.delegations.map((d) => [d.delegation_id, d]));
     for (const r of c.receipts)
-        if (!delegationIds.has(r.delegation_id))
+        if (!delegations.has(r.delegation_id))
             problems.push(`receipt ${r.receipt_id} covers a delegation outside the task`);
     for (const response of c.responses) {
         const receipt = receipts.get(response.receipt_id);
@@ -330,6 +391,17 @@ function responseProblems(c) {
         }
         if (s.issuer_operator_id !== c.issuer.operator_id)
             problems.push(`response ${response.response_id} names another issuer`);
+        if (s.issued_at === undefined && (s.expires_at !== undefined || s.refs !== undefined))
+            problems.push(`response ${response.response_id} needs issued_at with expires_at or refs`);
+        if (s.issued_at !== undefined && s.expires_at !== undefined && Date.parse(s.expires_at) <= Date.parse(s.issued_at))
+            problems.push(`response ${response.response_id} expires before it was issued`);
+        if (s.execution) {
+            const declared = delegations.get(receipt.delegation_id)?.execution;
+            if (!declared)
+                problems.push(`response ${response.response_id} cites run ${s.execution.execution_id}, but delegation ${receipt.delegation_id} records none`);
+            else if (digestOf(executionBinding(declared)) !== digestOf(s.execution))
+                problems.push(`response ${response.response_id} cites run ${s.execution.execution_id}, which is not the run recorded on delegation ${receipt.delegation_id}`);
+        }
         const claimsKeySigned = response.assurance.includes("provider_key_signed");
         if (!claimsKeySigned)
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atcn/subledger",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "Agent Work Subledger: deterministic attribution, roll-up, exceptions, signed receipts and closures, and offline verification",
   "license": "Apache-2.0",
   "repository": {
@@ -33,8 +33,8 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@atcn/core": "1.3.2",
-    "@atcn/schema": "1.3.2",
+    "@atcn/core": "1.4.1",
+    "@atcn/schema": "1.4.1",
     "zod": "^4.1.0"
   }
 }

package/test-vectors/vectors.json

@@ -90,6 +90,63 @@
       "canonical": "{\"corrections\":[{\"field\":\"delivery.status\",\"proposed_value\":\"partial_completion\",\"reason\":\"file 3 missing\"}],\"document_type\":\"atcn.subledger.receipt_response\",\"evidence\":[{\"digest\":null,\"evidence_type\":\"delivery_log\",\"uri\":\"https://provider.example/delivery/7\"}],\"fields\":[],\"issuer_operator_id\":\"ten_01J00000000000000000000001\",\"note\":\"café: two of three files\",\"receipt_digest\":\"sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\",\"receipt_id\":\"rcp_01J00000000000000000000002\",\"receipt_revision\":1,\"response_type\":\"propose_correction\"}",
       "digest": "sha256:633530c26ed9133457be0a7d4a1417f24c73dc17fcbd20f58901cfb462390e15",
       "signature": "XKtJa41QABDVCDvyKIGqNejsQAvqHaKqh_yanIrNWPcehrnLCNW28L621ar__eHdqP2-64yvZnwbuJD0efi4Aw"
+    },
+    {
+      "input": {
+        "receipt": {
+          "receipt_id": "rcp_01J00000000000000000000003",
+          "digest": "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+          "revision": 1,
+          "issuer_operator_id": "ten_01J00000000000000000000001"
+        },
+        "response_type": "signed_attestation",
+        "fields": [
+          "delivery.status"
+        ],
+        "execution": {
+          "execution_id": "run_01J00000000000000000000001",
+          "execution_digest": "sha256:9e282402ebfefeb4924e034733742b7cd346b022313e3e7f5b77d93651d11952"
+        },
+        "issued_at": "2026-10-01T00:00:00.000Z",
+        "expires_at": "2026-11-01T00:00:00.000Z",
+        "refs": [
+          {
+            "relation": "revokes",
+            "attestation_digest": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+            "reason": "attested the wrong run"
+          }
+        ]
+      },
+      "statement": {
+        "document_type": "atcn.subledger.receipt_response",
+        "receipt_id": "rcp_01J00000000000000000000003",
+        "receipt_digest": "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        "receipt_revision": 1,
+        "issuer_operator_id": "ten_01J00000000000000000000001",
+        "response_type": "signed_attestation",
+        "fields": [
+          "delivery.status"
+        ],
+        "note": null,
+        "evidence": [],
+        "corrections": [],
+        "execution": {
+          "execution_id": "run_01J00000000000000000000001",
+          "execution_digest": "sha256:9e282402ebfefeb4924e034733742b7cd346b022313e3e7f5b77d93651d11952"
+        },
+        "issued_at": "2026-10-01T00:00:00.000Z",
+        "expires_at": "2026-11-01T00:00:00.000Z",
+        "refs": [
+          {
+            "relation": "revokes",
+            "attestation_digest": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+            "reason": "attested the wrong run"
+          }
+        ]
+      },
+      "canonical": "{\"corrections\":[],\"document_type\":\"atcn.subledger.receipt_response\",\"evidence\":[],\"execution\":{\"execution_digest\":\"sha256:9e282402ebfefeb4924e034733742b7cd346b022313e3e7f5b77d93651d11952\",\"execution_id\":\"run_01J00000000000000000000001\"},\"expires_at\":\"2026-11-01T00:00:00.000Z\",\"fields\":[\"delivery.status\"],\"issued_at\":\"2026-10-01T00:00:00.000Z\",\"issuer_operator_id\":\"ten_01J00000000000000000000001\",\"note\":null,\"receipt_digest\":\"sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\",\"receipt_id\":\"rcp_01J00000000000000000000003\",\"receipt_revision\":1,\"refs\":[{\"attestation_digest\":\"sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\",\"reason\":\"attested the wrong run\",\"relation\":\"revokes\"}],\"response_type\":\"signed_attestation\"}",
+      "digest": "sha256:f4839d189a371531782b945d494462c209b57a9988344b149315d61772b3c81d",
+      "signature": "TgkbCF-2xoTAWDQJqGtiMMvQ26nliShYzU6mJbJhWD6Q-y35FlwNA9L4ijdne9whcouQCTxlI8sZIsR_KpJBCQ"
     }
   ],
   "countersignature": {
@@ -104,5 +161,33 @@
       }
     },
     "signature": "jUnhhTUE28I9wdyO15cFLm1aB9Lo-3r6d1cif7HPFLDIvLr8GngoKNCYtlTftNwxP1b7ARBUkwLga-PywmFtBA"
+  },
+  "execution_binding": {
+    "descriptor": {
+      "execution_id": "run_01J00000000000000000000001",
+      "protocol": {
+        "name": "a2a",
+        "task_id": "task-7",
+        "context_id": "ctx-7"
+      },
+      "agent": {
+        "agent_id": "agt_01J00000000000000000000002",
+        "agent_version": "2.1.0",
+        "card_digest": "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+        "model": {
+          "provider": "example",
+          "name": "coder",
+          "version": "2026-09"
+        }
+      },
+      "skill": {
+        "namespace": "a2a",
+        "skill_id": "code-fix"
+      }
+    },
+    "binding": {
+      "execution_id": "run_01J00000000000000000000001",
+      "execution_digest": "sha256:9e282402ebfefeb4924e034733742b7cd346b022313e3e7f5b77d93651d11952"
+    }
   }
 }