Internet-Draft Sink-Attested Closure Evidence November 2026
Watts Expires 19 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-watts-sink-attested-closure-00
Published:
Intended Status:
Experimental
Expires:
Author:
D. O. Watts
GoodShyt Group Inc.

Sink-Attested Closure Evidence (SACE): Signed Epoch Acknowledgements and Accountable Revocation Closure

Abstract

Revoking delegated authority in an agentic system is complete only when every place that can still act on that authority has stopped. Existing work defines the states of that process but leaves its evidence format open. This document defines Sink-Attested Closure Evidence (SACE): a small set of COSE-signed objects and one deterministic algorithm. An authority root signs a Scope Manifest naming the sinks a closure claim covers, and a Cut Statement raising the minimum admissible authority epoch. Each sink signs an Epoch Acknowledgement with its own key, binding the cut to the sequence number of the last effect it committed before applying it. Each committed effect yields a signed Effect Receipt. From these objects any party can compute one of three verdicts: CLOSED, UNKNOWN, or VIOLATED. A VIOLATED verdict comes with a transferable proof consisting of two signatures by the same sink. A sink that never acknowledges blocks CLOSED until it is removed from scope. An optional binding ties the acknowledging key to remote attestation evidence. This document makes no claim that a sink which signs an acknowledgement actually enforces it; it makes a sink that does not enforce it provably accountable for every effect it receipts.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 19 May 2027.

▲

Table of Contents

1. Introduction

A revocation request, a token invalidation, and the end of delegated authority are three different events. [I-D.watts-oauth-agent-revocation-closure] names that distinction, defines authority epochs and closure states, and leaves the wire encoding of closure receipts to a future profile. It defines no acknowledgement signed by an enforcement point, no manifest format, no sequence mechanism, and no state for a detected breach. This document is such a profile.

A simple two-sink arrangement shows why the gap matters. Sink A commits a cut to epoch 8. Sink B, which has not received the cut, then accepts an epoch-7 request from a delegation descendant that A has never seen. The cut is committed at A, and closure does not hold over {A, B}. Four things are missing in that arrangement:

SACE answers each point with a concrete object.

1.1. Scope

SACE defines evidence objects and their evaluation. It does not define how cuts are transported, how grants are issued, or any new token format. It works with any authorization system that can attach an integer authority epoch to each admitted request.

1.3. Requirements Language

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

2. Design Principles

Seven principles constrain the mechanism. Each is enforced by a specific rule later in this document.

  1. Delivery is not application. Only a statement signed by the sink's own key counts as evidence that the sink applied a cut (Section 8).
  2. Closure is bounded by a signed list. A verdict names exactly one Scope Manifest and says nothing about any system outside it (Section 6, Section 10).
  3. Missing evidence is UNKNOWN. No timeout, quorum, or majority converts an absent acknowledgement into closure (Section 10).
  4. An acknowledgement is a safety claim. By signing, a sink commits to a watermark. Anything it later receipts beyond that watermark under a revoked epoch convicts it (Section 11).
  5. No clock in the safety predicate. Verdicts depend on epochs and sequence numbers. Timestamps are informational (Section 10).
  6. Agreement is not correctness. Two evaluators producing the same verdict shows that they implement the same function, not that the sinks are honest (Section 17).
  7. Attestation describes the signer, not its behaviour. Evidence about the code that signed an acknowledgement does not prove that the code enforces it (Section 15).

3. Terminology and Roles

Authority Root (AR):
The party entitled to revoke. Signs Scope Manifests and Cut Statements.
Sink:
A system where delegated authority becomes a durable effect, such as a database write, a payment, or a message sent. Holds its own signing key.
Authority epoch:
An unsigned integer attached to every grant. Opaque to SACE except for ordering.
Floor:
The lowest authority epoch a sink will admit. Raised by a cut, never lowered.
Effect sequence number (seq):
A per-sink, per-scope counter, starting at 1, incremented by exactly one for each committed effect.
Watermark (w):
The value of a sink's seq at the instant it raised its floor; 0 if it had committed nothing.
Evaluator:
Any party that runs the algorithm in Section 10. An Evaluator needs no secret.
Digest of an object:
SHA-256 over the complete tagged COSE_Sign1 encoding of that object.

All SACE objects are COSE_Sign1 structures [RFC9052] whose payload is a CBOR map with integer keys, encoded using the deterministic encoding requirements of Section 4.2 of [RFC8949]. The protected header MUST carry "alg", "kid", and "typ" [RFC9596]. A receiver MUST reject an object whose payload is not deterministically encoded, has duplicate keys, or has keys that this document does not define.

4. Protocol Overview

One closure round has six steps. Transport between parties is out of scope; any channel works because every object is self-authenticating.

  1. The AR publishes a Scope Manifest listing each sink by identifier and key thumbprint.
  2. To revoke, the AR signs a Cut Statement that names the manifest by digest and sets a new floor epoch e.
  3. Each sink that receives the cut, in one atomic step with its effect commits, raises its floor to e and records its current seq as watermark w.
  4. The sink signs an Epoch Acknowledgement over the cut digest, e, w, and the head of its receipt chain, and returns or publishes it.
  5. For every effect it commits, before and after the cut, the sink emits an Effect Receipt carrying seq and the authority epoch of the grant it admitted.
  6. An Evaluator collects the manifest, the cut, the acknowledgements, and any receipts, and computes CLOSED, UNKNOWN, or VIOLATED.

The admission rule at a sink is one comparison: admit a request only if its authority epoch is greater than or equal to the floor. This is the admission fencing of [I-D.watts-oauth-agent-revocation-closure]; SACE adds the evidence that it happened.

5. Sink State Machine

A sink is in exactly one of four states for each scope. The state, the floor, the sequence counter, and the chain head are a single durable record and change only inside the transaction described for each event.

Table 1: Sink States
State Meaning Requests in the scope
UNENROLLED The sink holds no manifest that lists it. Refused.
ACTIVE(f) The sink is listed and its floor is f. Admitted if the authority epoch is at least f.
HALTED The sink cannot show that its durable record is current. Refused until the sink re-acknowledges the latest cut.
RETIRED A later manifest no longer lists the sink. Refused.
Table 2: Sink Events
Event From To Action in one transaction
Manifest lists the sink UNENROLLED HALTED Store the manifest digest; seq = 0; chain head = zero.
Cut with epoch e > f ACTIVE(f) or HALTED ACTIVE(e) Set floor to e; record w = seq; sign and store the SEA.
Cut with epoch e <= f ACTIVE(f) ACTIVE(f) None; return the stored SEA for f.
Request with epoch >= f ACTIVE(f) ACTIVE(f) seq = seq + 1; write the effect; sign and store the ER; advance the chain head.
Request with epoch < f ACTIVE(f) ACTIVE(f) None; refuse with reason "floor".
Restore, or rollback-resistant counter disagrees with the record ACTIVE(f) HALTED None; refuse all requests.
New manifest omits the sink any RETIRED Store the manifest digest.

A newly listed sink starts in HALTED, not ACTIVE, so that it cannot admit a request before it has acknowledged the latest cut. Its first SEA has watermark 0.

Three invariants follow from the table and are what an implementation needs to preserve:

I1 (monotonic floor):
The floor never decreases.
I2 (dense sequence):
The sequence counter increases by exactly one per committed effect, and each value is used once.
I3 (atomic fence):
The floor raise and the watermark read are one atomic step with respect to every effect commit. No effect commit observes the old floor and receives a sequence number above the watermark.

6. Scope Manifest

A Scope Manifest is the signed, complete list of sinks that one closure claim covers. Its "typ" is "application/sace-manifest+cose". It is signed by the AR.

Table 3: Scope Manifest Payload
Key Name Type Rule
1 scope_id bstr, 16 bytes Random; fixed for the life of the scope.
2 manifest_seq uint Starts at 1. Each new manifest increments it by one.
3 prev_manifest bstr / null Digest of the preceding manifest; null when manifest_seq is 1.
4 members array of member Sorted by sink_id in bytewise order. No duplicates.
5 att_profile tstr OPTIONAL. If present, every acknowledgement carries attestation under this profile (Section 15).

Each member is an array [sink_id, key_thumbprint, class]: a text identifier, the COSE Key Thumbprint [RFC9679] (SHA-256) of the sink's acknowledgement key, and a text label for the sink class.

The following rules apply:

7. Cut Statement

A Cut Statement raises the floor for one scope. Its "typ" is "application/sace-cut+cose". It is signed by the AR.

Table 4: Cut Statement Payload
Key Name Type Rule
1 scope_id bstr As in the manifest.
2 manifest bstr Digest of the Scope Manifest this cut applies to.
3 epoch uint The new floor e. Authority epochs below e are revoked.
4 prev_epoch uint The floor this cut supersedes. Less than epoch.
5 cut_nonce bstr, 16 bytes Random. Makes two cuts to the same epoch distinguishable.
6 issued_at uint Seconds since the Unix epoch. Informational only.

A sink processes a Cut Statement as follows, entirely inside the same serializable transaction that guards effect commits:

  1. Verify the AR signature and that "manifest" matches a manifest that the sink holds and is listed in.
  2. If "epoch" is less than or equal to the current floor, change nothing and return the stored acknowledgement for the current floor.
  3. Otherwise, set the floor to "epoch", set w to the current seq, and durably store both together with the cut digest.

Step 2 makes reordered and replayed cuts harmless: a cut to 9 arriving before a cut to 8 leaves the floor at 9, and a replayed cut to 7 cannot lower it. A sink MUST store the exact bytes of each acknowledgement it signs and return those bytes on any repeat, so that an honest sink never produces two different acknowledgements for one cut.

8. Sink Epoch Acknowledgement

A Sink Epoch Acknowledgement (SEA) is a sink's own signed statement that it raised its floor, and where its effect counter stood when it did. Its "typ" is "application/sace-ack+cose". It MUST be signed by the key whose thumbprint the manifest lists for that sink. An acknowledgement signed by the AR, a proxy, or a coordinator on the sink's behalf is not an SEA.

Table 5: Sink Epoch Acknowledgement Payload
Key Name Type Rule
1 scope_id bstr As in the manifest.
2 manifest bstr Digest of the manifest the sink is listed in.
3 sink_id tstr The sink's identifier in that manifest.
4 cut bstr Digest of the Cut Statement that caused this floor.
5 applied_epoch uint The floor now in force at this sink.
6 prev_epoch uint The floor it replaced at this sink.
7 watermark uint w: the sink's seq at the instant the floor was raised.
8 chain_head bstr Digest of the Effect Receipt with seq = w; 32 zero bytes if w is 0.
9 applied_at uint Sink-local time. Informational only.
10 attestation bstr OPTIONAL. An EAT, per Section 15.

By signing an SEA, a sink asserts two things and nothing else:

The watermark is what makes the second assertion checkable. Without it, an old-epoch receipt could always be explained as having been committed just before the cut. With it, the sink has fixed in advance which side of the line every sequence number falls on.

An SEA satisfies a cut with epoch e if it is validly signed, names the same scope and manifest, and has applied_epoch greater than or equal to e. A sink that moved directly to a later epoch therefore also acknowledges every earlier cut.

9. Effect Receipt

An Effect Receipt (ER) is a sink's signed record of one committed effect. Its "typ" is "application/sace-effect+cose". It is signed by the same key as the sink's SEAs.

Table 6: Effect Receipt Payload
Key Name Type Rule
1 scope_id bstr As in the manifest.
2 sink_id tstr As in the manifest.
3 seq uint Previous seq plus one. No gaps, no reuse.
4 authority_epoch uint The epoch of the grant under which the effect was admitted.
5 effect bstr SHA-256 of the canonical effect description. Never the effect itself.
6 prev bstr Digest of the ER with seq minus one; 32 zero bytes when seq is 1.

The sink MUST assign seq, write the effect, and persist the ER in one atomic transaction. An effect without a receipt, or a receipt without an effect, is a sink fault.

A deployment that already emits per-action receipts in another format, for example a signed statement as in [I-D.noa-scitt-ai-agent-receipt], MAY use that format instead, provided that each receipt is signed by the manifest-listed key and carries sink_id, seq, authority_epoch, and prev under the sink's signature. Registering receipts in a Transparency Service [RFC9943] is RECOMMENDED where a sink might withhold them (Section 23).

10. Closure Evaluation

The verdict is a pure function of its inputs: one Scope Manifest M, one Cut Statement C with epoch e, a set of SEAs, a set of ERs, an optional set of Checkpoints (Section 14), and, when M sets att_profile, the Evaluator's appraisal policy for that profile (Section 15). It uses no clock and no network.

A sink makes a sequence commitment whenever it signs a statement that binds a sequence number n to a receipt digest d. Four statements do so:

For each member s of M, an Evaluator computes a member status:

  1. Discard every SEA, ER, and Checkpoint that is not validly signed by the key M lists for s, that names a different scope, or, for an SEA, that names a different manifest.
  2. If two SEAs from s have the same "cut" but are not byte-identical, s is VIOLATED (equivocation).
  3. If two sequence commitments from s bind the same n to different digests, s is VIOLATED (forked chain).
  4. If any SEA A from s and any ER from s satisfy authority_epoch < A.applied_epoch and seq > A.watermark, s is VIOLATED (stale commit).
  5. If no remaining SEA satisfies C, s is UNACKED.
  6. If M has att_profile and no SEA satisfying C carries attestation that passes Section 15, s is UNACKED.
  7. Otherwise, s is ACKED.

Steps 2 to 4 apply to every SEA from s, not only to those that satisfy C. The reported watermark of s is that of the satisfying SEA with the lowest applied_epoch, or null if there is none. It is reported for UNACKED and VIOLATED members too, when a satisfying SEA exists.

The verdict over M and C is then:

Table 7: Verdicts
Verdict Condition State in the base model
VIOLATED At least one member is VIOLATED. FAILED, with proof attached
CLOSED Every member is ACKED, and the non-vacuity check passes. CLOSED
UNKNOWN Anything else. PROPAGATING, PARTIAL, or UNKNOWN
Non-vacuity:
CLOSED additionally requires a witness: either an ER from a member with a satisfying SEA, with authority_epoch below e and seq at or below that member's watermark; or a Checkpoint from such a member, with seq at or below its watermark, whose "counts" map gives a non-zero count for some epoch below e. This corresponds to the normal-path witness of [I-D.watts-oauth-agent-revocation-closure]: it shows that the revoked authority could reach a sink before the cut, so the result is not closure of an empty graph. Without a witness, the verdict is UNKNOWN.
Monotonicity:
Adding evidence can move a verdict from UNKNOWN to CLOSED, and from anything to VIOLATED. Nothing moves a verdict out of VIOLATED.

10.1. The Silent-Sink Rule

A member that has not signed a satisfying SEA is UNACKED, and a verdict with an UNACKED member is not CLOSED. No other evidence changes this. In particular, an Evaluator MUST NOT report CLOSED on the basis of:

  • elapsed time since the cut, or any timeout;
  • acknowledgements from a majority or any other proportion of members;
  • activity by the member under the new epoch, receipts, or Checkpoints, none of which is an acknowledgement;
  • a statement by the AR, a transport, or another member that the cut was delivered;
  • a verdict record from another Evaluator.

The only way to reach CLOSED without a member's acknowledgement is to remove the member from scope: the AR issues a new manifest that omits it and a new cut over that manifest. The verdict over the old manifest stays UNKNOWN and is retained (Section 20). Removal is therefore always visible as a change of scope and never as a closure.

This rule chooses safety over liveness. A deployment that cannot tolerate one unresponsive sink blocking closure needs smaller scopes, not a weaker rule.

11. Violation Proofs

Every VIOLATED status is backed by exactly two objects signed by the same sink key. Anyone holding the manifest can check the proof offline, and the sink cannot attribute it to the network, the AR, or another sink.

Table 8: Violation Proof Types
Type The two objects What they show
1: Stale commit An SEA with applied_epoch = a and watermark = w; an ER with authority_epoch < a and seq > w The sink committed revoked authority after stating that it had stopped.
2: Equivocation Two SEAs with the same cut and any differing field The sink told two parties different things about one cut.
3: Forked chain Two objects, each an ER, an SEA, or a Checkpoint, that make conflicting sequence commitments (Section 10) The sink keeps two histories, or acknowledged a chain head it did not have.

A violation proof is a CBOR array [proof_type, object_1, object_2]. It needs no signature of its own, because its force comes from the two signatures it contains. Type 3 covers four concrete forms, all detected by one rule: two ERs with the same seq; an ER whose "prev" disagrees with the receipt it names; an SEA whose chain_head disagrees with the receipt at its watermark; and a Checkpoint whose chain_head disagrees with a receipt, an SEA, or another Checkpoint.

To verify a proof, a party holding the manifest checks that both objects are validly signed by the same manifest-listed key, that they are different objects, and that running steps 2 to 4 of Section 10 over those two objects alone yields the stated type. A pair that does not convict on its own is not a proof, even if the member is VIOLATED on other evidence.

The distinction from simpler tests is deliberate. "An old-epoch effect after A's cut" proves nothing about B. "An old-epoch effect at B beyond B's own signed watermark" proves that B broke its word.

A sink restored from a backup taken before a cut will have a lower floor and will produce a stale-commit proof against itself once it commits. Sinks therefore MUST persist the floor in storage that a restore cannot roll back, or refuse all requests in the scope after a restore until they have re-acknowledged the latest cut.

12. Signed Verdict Record

An Evaluator MAY publish its result as a Verdict Record. Its "typ" is "application/sace-verdict+cose". It is signed by the Evaluator's key and is a wire encoding for the closure receipt of [I-D.watts-oauth-agent-revocation-closure].

Table 9: Verdict Record Payload
Key Name Type Rule
1 manifest bstr Digest of the manifest evaluated.
2 cut bstr Digest of the cut evaluated.
3 verdict uint 0 UNKNOWN, 1 CLOSED, 2 VIOLATED.
4 members array [sink_id, status, watermark / null] per member, sorted by sink_id.
5 verdict_digest bstr As defined in Section 17, over keys 1 to 4.
6 proofs array Present if and only if the verdict is VIOLATED. One violation proof per VIOLATED member.

A relying party that receives a Verdict Record MUST check, in order:

  1. The signature, against an Evaluator key it trusts. How Evaluator keys become trusted is out of scope.
  2. That verdict_digest equals the digest recomputed from keys 1 to 4.
  3. That the verdict is VIOLATED if and only if some member has status 2, and that key 6 is present exactly when it is.
  4. That a CLOSED verdict has every member at status 1.
  5. If it holds the manifest: that the manifest digest matches key 1, and that every proof in key 6 verifies under Section 11.

These checks establish less than re-evaluation does, and the difference matters:

13. Properties

This section states what the mechanism guarantees, under which assumptions, and what it does not guarantee. The arguments are informal sketches, not machine-checked proofs.

A sink is called honest if it follows Sections 5 to 9, its signing key is not known to any other party, and its durable record is not rolled back.

13.1. P1: An Honest Sink Is Never Convicted

Claim: no set of objects signed by an honest sink contains a violation proof.

Sketch. Stale commit: let the sink sign an SEA with applied_epoch a and watermark w. By I3, every effect committed after the fence has seq above w and was admitted against a floor of at least a (by I1), so its authority_epoch is at least a. Every effect with authority_epoch below a was therefore committed before the fence and has seq at most w. Equivocation: the sink stores the bytes of each SEA and returns them on repeat, so it signs one SEA per floor value. Forked chain: by I2 each seq value is assigned once, so one ER exists per seq.

This property holds under any message ordering, partition, or clock offset, because none of them is an input to the sink's transaction or to the evaluation.

13.2. P2: Every Receipted Breach Is Detectable

Claim: if a sink signs an SEA with applied_epoch a and watermark w, and also signs an ER with authority_epoch below a and seq above w, then every Evaluator that holds both objects and the manifest reports the member, and the verdict, as VIOLATED.

Sketch. Both objects pass step 1 of Section 10 because they are validly signed by the listed key. Step 4 compares every SEA with every ER from the same member, so the pair is found regardless of which cut is being evaluated.

The claim is conditional on the Evaluator holding both objects. A sink that never emits the ER is outside it; see Section 23.

13.3. P3: Evidence Is Monotone and VIOLATED Is Terminal

Claim: for evidence sets X and Y with X a subset of Y, if the verdict over X is VIOLATED then the verdict over Y is VIOLATED, and if the verdict over Y is UNKNOWN then the verdict over X is not CLOSED.

Sketch. A violation proof contained in X is contained in Y. A member that is ACKED over X has a satisfying SEA in X, which is also in Y, so it is ACKED or VIOLATED over Y; the non-vacuity witness in X is also in Y. Hence CLOSED over X implies CLOSED or VIOLATED over Y.

13.4. P4: The Verdict Is a Function of the Object Set

Claim: the verdict, the member statuses, and the verdict digest depend only on the set of valid objects supplied, not on their order, their arrival time, or the Evaluator's clock.

Sketch. Every step of Section 10 quantifies over sets. The member list is sorted before the digest is taken. Where more than one SEA satisfies the cut, the reported watermark is taken from the one with the lowest applied_epoch, which is unique for an unconvicted member.

13.5. P5: What CLOSED Implies, and Under Which Assumptions

Claim: if the verdict over manifest M and a cut to epoch e is CLOSED, and (A1) every member of M is honest, and (A2) every system able to commit an effect under a grant in the scope is a member of M, then no effect under an authority epoch below e is committed anywhere after the last member's acknowledgement.

Sketch. By A1 and P1's argument, each member commits no such effect after its own fence. By A2 there is no other place where one could be committed.

Neither assumption is established by SACE. A1 is supported, not proven, by attestation (Section 15) and by the accountability of P2. A2 is a statement about the deployment: the manifest is the authority root's signed assertion of it, and the rules of Section 6 make a compliant unlisted sink refuse, but a non-compliant unlisted system is invisible to every object defined here.

13.6. What Is Not Guaranteed

  • Liveness. No bound exists on the time to reach CLOSED. Under a partition that isolates one member, CLOSED is unreachable until the partition heals or a new manifest removes the member. This is a deliberate choice of safety over availability.
  • Prevention. A dishonest sink can commit a stale effect. SACE makes that provable if the effect is receipted.
  • Unreceipted effects. A sink that commits without signing a receipt leaves no proof. Detection then depends on parties that observe the effect requiring a receipt for it.
  • Reversal. Effects at or below a watermark stand.

14. Checkpoints and Retention

Effect Receipts accumulate without bound. A Checkpoint lets a sink commit to its history up to a sequence number so that evidence stores can discard older receipts without losing the ability to detect a fork. Checkpoints are OPTIONAL. Its "typ" is "application/sace-checkpoint+cose". It is signed by the sink key.

Table 10: Checkpoint Payload
Key Name Type Rule
1 scope_id bstr As in the manifest.
2 sink_id tstr As in the manifest.
3 seq uint The sequence number the checkpoint covers up to and including.
4 chain_head bstr Digest of the ER with that seq.
5 floor uint The sink's floor when the checkpoint was signed.
6 counts map For each authority epoch that appears in receipts 1..seq, the number of such receipts.

An evidence store MAY discard the bytes of an ER from a sink once all of the following hold:

  1. The store holds a valid Checkpoint from that sink with seq at or above the ER's seq, and has verified the receipt chain from seq 1, or from the previous retained Checkpoint, up to the Checkpoint's chain_head.
  2. Every SEA held from that sink has been compared with every ER to be discarded, no comparison yields a stale-commit proof, and a valid verdict record (Section 12) covering that sink is retained.
  3. The store retains the pair (seq, digest) for the ER.

Condition 2 preserves stale-commit detection: an ER can convict a sink only against an SEA whose watermark is below its seq, and those comparisons have been made. Condition 3 preserves fork detection: a conflicting ER presented later for the same seq has a different digest. The "counts" map preserves the non-vacuity witness after the receipts that supplied it are gone: a non-zero count for an epoch below e in a Checkpoint with seq at or below the member's watermark is an acceptable witness.

A Checkpoint makes a sequence commitment, so a Checkpoint that disagrees with a receipt, an SEA, or another Checkpoint about the digest at some seq is a forked-chain proof (type 3). After discarding, the retained (seq, digest) pairs keep this detectable: a conflicting ER presented later is checked against them.

A Checkpoint is not an acknowledgement. It never makes a member ACKED, whatever floor it reports (Section 10.1).

A sink MUST NOT discard its own receipts or acknowledgements on the strength of a Checkpoint. Checkpoints permit pruning by evidence stores, not by the party the evidence is about.

15. Attestation Binding

An SEA says that a key signed a promise. Attestation says what software held that key. This section is OPTIONAL unless the manifest sets att_profile.

When present, the "attestation" field of an SEA is an Entity Attestation Token [RFC9711] in CWT form, used as Evidence or as an Attestation Result in the sense of [RFC9334]. The following rules bind it to the acknowledgement:

An Evaluator appraises the token under a policy for the profile that names the attester keys it accepts and the reference values for the measurement claims. The token passes only if it is signed by an accepted attester key, its "eat_nonce" and "cnf" claims match as above, and every measurement claim the profile defines equals a reference value. Any other outcome, including a missing token, an unknown profile, or a policy the Evaluator does not hold, leaves the member UNACKED. It never makes the member VIOLATED: a failed appraisal shows that the evidence is insufficient, not that the sink broke a promise.

This document does not define a concrete profile. A profile document specifies the measurement claims, their encoding, and how attester keys are endorsed. The test vectors in Appendix C use a test-only profile, "urn:example:sace-sim-attester:1", with a software attester key and a single 32-byte measurement claim under the private-use claim key -75000. It demonstrates the binding rules above and has no security value.

Where a sink is an agent runtime built on a layered device identity, in which a device secret is extended through each boot stage and the model weights and runtime configuration are measured before any key is released, a profile SHOULD require the model digest and the configuration digest among the measured components. An acknowledgement is then tied to one exact model and configuration, and stops verifying when either changes.

The limit of this section is as follows. Attestation appraises the signer's software state at signing time. It does not show that the software is correct, that it enforces the floor, or that it stays in that state afterwards. A member with valid attestation that later produces a stale-commit proof is VIOLATED like any other.

16. Use with Attested Fence Receipts

[I-D.watts-rats-attested-fence-receipt] defines an EAT profile in which a sink's Attesting Environment reports, among other claims, the sink-local sequence number at which the fence took effect and the highest sequence number of any effect committed under the previous epoch. Those two claims carry the same information as the SACE watermark.

A deployment can combine the documents in either of two ways:

The division of labour is as follows. The fence receipt carries hardware-rooted evidence of the sink's enforcement state at one moment. SACE carries the signed membership list, the per-effect record after that moment, and the two-signature proof when the record contradicts the acknowledgement. The exact claim-by-claim mapping, including whether the fence sequence number equals the watermark or the watermark plus one, is left to a profile document, because it depends on the numbering convention of the fence-receipt profile.

17. Cross-Implementation Agreement

A verdict that depends on which library computed it is not evidence. Two Evaluators written independently, in different programming languages, given the same input objects, MUST produce the same verdict digest.

The verdict digest is SHA-256 over the deterministic CBOR encoding of:

verdict-input = [
  manifest_digest : bstr,
  cut_digest      : bstr,
  verdict         : 0 / 1 / 2,   ; UNKNOWN / CLOSED / VIOLATED
  members         : [ + [ sink_id   : tstr,
                          status    : 0 / 1 / 2,
                                      ; UNACKED / ACKED / VIOLATED
                          watermark : uint / null ] ]
                    ; sorted by sink_id
]

Conformance requirements:

The verdict digest identifies the outcome: who is convicted, who is acknowledged, at which watermark. It does not identify the evidence. Two evaluations that convict the same member on different proofs, or over different but equivalent sets of objects, produce the same digest. This is intended, because Evaluators holding different copies of the same evidence should agree. Proofs are compared separately, by verifying them.

Matching digests show that two Evaluators compute the same function. They show nothing about whether the sinks told the truth. Agreement is a precondition for trusting a verdict, not a reason to trust it.

18. Implementation Guidance for Database-Backed Sinks

Most sinks are, or sit in front of, a transactional database. This section shows how the three invariants of Section 5 map onto ordinary database features. It is guidance; the normative requirements are in Sections 5 to 9.

18.1. Schema

Three tables hold the SACE state. They live in the same database as the application data they protect, so that one transaction can cover both.

CREATE TABLE sace_state (
  scope_id  BLOB PRIMARY KEY,
  sink_id   TEXT NOT NULL,
  manifest  BLOB NOT NULL,     -- digest of the current manifest
  floor     INTEGER NOT NULL,  -- lowest admissible authority epoch
  seq       INTEGER NOT NULL,  -- last assigned sequence number
  head      BLOB NOT NULL      -- digest of the receipt with that seq
);

CREATE TABLE sace_ack (
  scope_id      BLOB NOT NULL,
  applied_epoch INTEGER NOT NULL,
  cut           BLOB NOT NULL,
  watermark     INTEGER NOT NULL,
  raw           BLOB NOT NULL, -- exact signed bytes
  PRIMARY KEY (scope_id, applied_epoch)
);

CREATE TABLE sace_effect (
  scope_id        BLOB NOT NULL,
  seq             INTEGER NOT NULL,
  authority_epoch INTEGER NOT NULL,
  effect          BLOB NOT NULL,
  raw             BLOB NOT NULL,
  PRIMARY KEY (scope_id, seq)
);

The primary key on sace_effect enforces I2: a second receipt with the same seq cannot be stored. The primary key on sace_ack enforces one acknowledgement per floor value.

18.2. Committing an Effect

Admission, the application write, the receipt, and the counter update are one transaction. The state row is read with a write lock so that no cut can be applied between the admission check and the commit.

BEGIN;  -- with a write lock on sace_state; see below
SELECT floor, seq, head FROM sace_state
 WHERE scope_id = :scope FOR UPDATE;
-- refuse here if :authority_epoch < floor (reason: floor)
-- refuse here if :audience <> this sink   (reason: audience)
-- application write(s) for the effect
INSERT INTO sace_effect
  (scope_id, seq, authority_epoch, effect, raw)
VALUES
  (:scope, :seq_plus_1, :authority_epoch, :effect_digest, :er);
UPDATE sace_state SET seq = :seq_plus_1, head = :er_digest
 WHERE scope_id = :scope;
COMMIT;

The receipt is signed inside the transaction, after seq and head are known and before COMMIT. If signing fails, the transaction is rolled back and no effect is committed.

18.3. Applying a Cut

BEGIN;
SELECT manifest, floor, seq, head FROM sace_state
 WHERE scope_id = :scope FOR UPDATE;
-- if :epoch <= floor:
--   read sace_ack for floor, COMMIT, return its raw
UPDATE sace_state SET floor = :epoch WHERE scope_id = :scope;
INSERT INTO sace_ack
  (scope_id, applied_epoch, cut, watermark, raw)
VALUES
  (:scope, :epoch, :cut_digest, :seq, :sea);
COMMIT;

The watermark written into the SEA is the seq value read under the same lock. This is I3.

18.4. Isolation and Durability

  • The row lock on sace_state serializes effect commits and cut application for a scope. A database without row locks can use a single writer per scope, or serializable isolation with retry. Snapshot isolation without the lock is not sufficient: two transactions could each read the same seq, or an effect could be admitted against a floor that a concurrent cut has already raised.
  • The recipes above use "FOR UPDATE" as found in most relational databases. An embedded database with a single writer, such as SQLite, obtains the same effect by starting the transaction in its immediate (write-locking) mode.
  • The lock makes each scope a single-writer sequence. Throughput for one scope at one sink is therefore bounded by the commit rate of that row. Deployments needing more can partition a workload into several scopes, each with its own counter.
  • An acknowledgement MUST NOT leave the sink before its transaction is durable. With asynchronous commit, a crash could lose the floor raise after the SEA was sent, which produces a stale-commit proof against an otherwise correct sink.
  • Replicas: a read replica MUST NOT admit requests. In a failover, the new primary MUST have applied every transaction for which an SEA was released, or enter HALTED. Synchronous replication of the sace_ tables satisfies this.
  • Queues and deferred work: a request that is admitted now and executed later is checked against the floor at execution time, inside the commit transaction, not at enqueue time.

18.5. Rollback Resistance

A restore from backup returns the floor to an earlier value. Three techniques, in increasing strength, keep a restored sink from admitting revoked authority:

  1. Procedure: after any restore the sink starts in HALTED and obtains the latest Cut Statement before admitting.
  2. External high-water mark: the sink records each floor in a second system that is not part of the backup set, and compares on start.
  3. Hardware counter: the floor is bound to a monotonic counter in a secure element or trusted execution environment, as in [I-D.watts-rats-attested-fence-receipt].

19. Evidence Store and Analysis

An Evaluator that follows many scopes and sinks needs to keep the objects it receives and to ask questions of them. This section describes an evidence store and the analysis queries that correspond to the rules of Section 10. A query result is a lead, not a verdict: every finding is confirmed by running the evaluation algorithm over the signed objects the query points to.

19.1. Store Rules

  • Append-only. Objects are never updated. Deletion happens only under Section 14.
  • Verify before indexing. An object is parsed strictly and its signature checked against the manifest-listed key before any of its fields are written to an index table. Fields from unverified objects are never queryable.
  • Keep the bytes. The index tables are derived data. The signed bytes are the evidence, addressed by their digest.
  • Record receipt time separately. The time an object arrived is useful for latency analysis and is never an input to a verdict.
CREATE TABLE ev_object (
  digest      BLOB PRIMARY KEY,
  typ         TEXT NOT NULL,
  scope_id    BLOB NOT NULL,
  sink_id     TEXT,
  raw         BLOB NOT NULL,
  received_at INTEGER NOT NULL
);
CREATE TABLE ev_ack (
  digest BLOB PRIMARY KEY REFERENCES ev_object(digest),
  scope_id BLOB, manifest BLOB, sink_id TEXT, cut BLOB,
  applied_epoch INTEGER, prev_epoch INTEGER,
  watermark INTEGER, chain_head BLOB
);
CREATE TABLE ev_effect (
  digest BLOB PRIMARY KEY REFERENCES ev_object(digest),
  scope_id BLOB, sink_id TEXT, seq INTEGER,
  authority_epoch INTEGER, effect BLOB, prev BLOB
);
CREATE TABLE manifest_member (
  manifest BLOB, sink_id TEXT, thumbprint BLOB, class TEXT,
  PRIMARY KEY (manifest, sink_id)
);
CREATE INDEX ev_effect_ix ON ev_effect (scope_id, sink_id, seq);
CREATE INDEX ev_ack_ix ON ev_ack (scope_id, sink_id, applied_epoch);

19.2. Analysis Queries

Stale commits: every pair of an acknowledgement and a later receipt under a revoked epoch.

SELECT a.sink_id, a.digest AS sea, e.digest AS er
  FROM ev_ack a JOIN ev_effect e
    ON e.scope_id = a.scope_id AND e.sink_id = a.sink_id
 WHERE e.authority_epoch < a.applied_epoch
   AND e.seq > a.watermark;

Equivocation and forked chains: two different objects where one is allowed.

SELECT a.sink_id, a.digest, b.digest
  FROM ev_ack a JOIN ev_ack b
    ON a.scope_id = b.scope_id AND a.sink_id = b.sink_id
   AND a.cut = b.cut
 WHERE a.digest < b.digest;

SELECT a.sink_id, a.digest, b.digest
  FROM ev_effect a JOIN ev_effect b
    ON a.scope_id = b.scope_id AND a.sink_id = b.sink_id
   AND a.seq = b.seq
 WHERE a.digest < b.digest;

Members that have not acknowledged a cut to epoch e. The member list comes from the manifest.

SELECT m.sink_id FROM manifest_member m
 WHERE m.manifest = :manifest
   AND NOT EXISTS (SELECT 1 FROM ev_ack a
        WHERE a.scope_id = :scope AND a.manifest = :manifest
          AND a.sink_id = m.sink_id AND a.applied_epoch >= :e);

Withheld receipts: gaps in a sink's sequence, and receipts whose "prev" does not match the stored predecessor.

SELECT sink_id, seq + 1 AS missing_from FROM ev_effect e
 WHERE scope_id = :scope
   AND seq < (SELECT MAX(seq) FROM ev_effect
               WHERE scope_id = e.scope_id AND sink_id = e.sink_id)
   AND NOT EXISTS (SELECT 1 FROM ev_effect n
        WHERE n.scope_id = e.scope_id AND n.sink_id = e.sink_id
          AND n.seq = e.seq + 1);

SELECT e.sink_id, e.seq FROM ev_effect e JOIN ev_effect p
    ON p.scope_id = e.scope_id AND p.sink_id = e.sink_id
   AND p.seq = e.seq - 1
 WHERE e.prev <> p.digest;

A gap is not a violation proof. It shows that the store is missing a receipt, which may be the sink's doing or the transport's. A gap that persists after the sink has been asked for the missing sequence numbers is a reason to treat the sink's receipts as incomplete.

19.3. Operational Measures

The following measures are derived from the store. They describe a deployment; none of them is an input to a verdict.

Table 11: Measures
Measure Definition Use
Acknowledgement coverage Members with a satisfying SEA, divided by members in the manifest. Progress of a closure round. Below 1 the verdict cannot be CLOSED.
Acknowledgement latency For each member, received_at of its SEA minus received_at of the cut. Sizing a closure budget. Uses store clocks only.
Exposure window count For each member, the number of receipts under an epoch below e with seq at or below its watermark and received after the cut. How much revoked authority was exercised between the AR's cut and the sink's fence. These effects are permitted and stand.
Receipt completeness Receipts held for a sink divided by its highest seen seq. Detecting withheld receipts.
Refusal breakdown Counts of refusals at each sink by reason: floor, audience, expired, not enrolled. Separating revocation effects from clock and configuration effects. Reported by sinks; not signed evidence.

The exposure window count is the quantity that revocation latency actually costs. It can be read directly from signed objects, which is not true of a timeout-based estimate.

20. Operational Management

Backup and restore:
Back up the sace_ tables together with the application data, in one consistent snapshot. After a restore, the sink is HALTED (Section 5). It fetches the latest Cut Statement, applies it, and resumes. Effects committed between the backup and the failure are lost from the sink but their receipts may exist elsewhere; the restored sink MUST continue its sequence from the highest seq for which any receipt was released, not from the backup's seq, or it will fork its own chain. If that value cannot be established, the sink key is retired and the sink re-enters under a new key and a new manifest.
Sink key rotation:
A new key is a new manifest entry. The AR issues manifest n+1 with the new thumbprint; the sink acknowledges the latest cut under the new key with the watermark it holds. Objects signed by the old key remain valid evidence about the period in which manifest n was current.
AR key rotation:
The new AR key is introduced by a manifest signed by the old key whose successor is signed by the new key. Relying parties that pin the prev_manifest chain follow the change. How relying parties first learn an AR key is out of scope.
Removing a silent sink:
A sink that will not acknowledge blocks CLOSED for its manifest indefinitely. The AR resolves this by issuing a manifest without it and a cut over the new manifest. The verdict record for the old manifest stays UNKNOWN and SHOULD be retained, so that the removal is visible as a change of scope and not as a closure.
Monitoring:
Operators watch acknowledgement coverage per open cut, sequence gaps per sink, and any non-empty result from the stale-commit, equivocation, and fork queries. The last three warrant immediate action; each is one evaluation run away from a transferable proof.
Schema migration:
Changes to the sace_ tables are made without rewriting the "raw" columns. The signed bytes are never re-encoded.

21. Implementation Status

This section records the status of known implementations at the time of posting, per [RFC7942]. It is to be removed before publication as an RFC.

Two implementations exist, both written by the author of this document.

21.1. sace_ref (Python)

Size:
About 670 lines of implementation and 880 lines of tests.
Coverage:
Every object in this document as COSE_Sign1 with EdDSA, with strict deterministic decoding; the evaluation algorithm of Section 10 including sequence commitments, all forms of the three violation proofs, the Checkpoint witness, and the silent-sink rule; attestation appraisal under the test-only profile of Section 15; proof verification; signing and verification of Verdict Records; a sink on SQLite following Section 18, including Checkpoint signing; an evidence store with the queries of Section 19 and pruning under the conditions of Section 14.
Not implemented:
A real attestation profile or hardware attester; the attester is a software key. Sink-side rollback resistance beyond the HALTED-after-restore procedure.
Tests:
92 tests pass. Beyond the cases listed in earlier revisions, they cover attestation (accepted, missing, wrong measurement, unknown attester, replayed from another cut, bound to another key, and an attested sink that is still convicted), Checkpoints (witness after receipts are gone, Checkpoint after the watermark not a witness, and conflicts with receipts, SEAs, and other Checkpoints), broken prev links, Verdict Records (round trip, wrong signer, altered statuses, fabricated proofs), pruning (success, incomplete chain, unreported stale commit, later fork against retained digests), the silent-sink rule, and 40 randomized runs in which the VIOLATED status of each member is compared with a ground-truth record of whether that member committed a stale effect.
Concurrency and crashes:
Five operating-system processes write to one sink database while the cut is applied; the test checks a dense, correctly linked chain and that no epoch-7 effect lies above the watermark. The test fails when the write lock of Section 18.2 is removed. A second test kills three writers with SIGKILL mid-run and checks that the chain is intact and the sink resumes.

21.2. sace-eval (Go)

Size:
About 520 lines, Go standard library only.
Coverage:
The Evaluator only: its own strict CBOR decoder (shortest-form arguments, sorted unique map keys, no indefinite lengths), COSE_Sign1 verification, attestation appraisal, sequence commitments, the three violation types, the Checkpoint witness, and the verdict digest. It does not produce proofs, only verdicts.
Agreement:
It reproduces the verdict and verdict digest of all 13 vectors in Appendix C. Disabling each of eight checks in turn (stale commit, prev link, SEA chain head, Checkpoint chain head, equivocation, measurement comparison, non-vacuity, Checkpoint witness) changes the result of exactly the vector intended to exercise it. It rejects a manifest with a corrupted signature, and ignores an acknowledgement with a corrupted signature, a non-shortest length encoding, or a key that does not match the manifest.

21.3. Limits of This Evidence

Both implementations have the same author and were written against the same text, so they share any misreading of it. Their agreement is evidence that the text is precise enough to implement twice, not the independent agreement that Section 17 asks for. All tests ran on one host. The partition is simulated by not delivering a cut, and the dishonest sink is the honest code with its admission check disabled. The conditions for an independent run in Appendix B are not yet met.

22. Evidence Analysis

Each object supports a narrow statement. Reading more into an object than the table below allows is the most likely way to misuse this document.

Table 12: What Each Object Shows
Object Signed by Shows Does not show
Scope Manifest AR Which sinks and keys the AR asserts are the complete set for the scope. That the set is in fact complete.
Cut Statement AR That the AR ordered the floor raised to e. That any sink received or applied it.
SEA Sink That the holder of the sink key states its floor is a and its counter stood at w. That the sink enforces the floor.
SEA with attestation Sink and its attester Additionally, the measured software that held the key at signing. That the software is correct or unchanged since.
Effect Receipt Sink That the sink states it committed effect number seq under a given epoch. That no other effect was committed.
Violation proof Sink, twice That the key holder made two statements that cannot both be true of an honest sink. Whether the cause was malice, a bug, a rollback, or key theft.
Verdict record Evaluator The result of the algorithm over a stated set of objects. Anything about objects the Evaluator did not hold.

The following table places the acknowledgement defined here beside the nearest existing mechanisms, as this document reads them. It compares only the property at issue: evidence that a specific enforcement point stopped. The rows refer, in order, to [RFC7009], [CAEP], [I-D.noa-scitt-ai-agent-receipt], [I-D.watts-rats-attested-fence-receipt], and this document.

Table 13: Comparison of Revocation Evidence
Mechanism Statement signed or returned by Says the enforcement point applied the revocation Later breach provable from signatures
Revocation endpoint response Authorization server No; the request was processed by the server. No
Session-revoked event with delivery acknowledgement Transmitter; receiver acknowledges delivery No; delivery only. No
Per-action receipt The recording boundary Not its purpose; it records individual actions. Not by itself; it has no acknowledgement to contradict.
Attested fence receipt Sink's Attesting Environment Yes, with hardware-rooted state. Within the receipt itself, when its own sequence claims conflict.
SEA (this document) Sink key Yes, as a signed claim with a watermark. Yes; an SEA and a later ER form the proof.

23. Security Considerations

SACE gives accountability for what sinks sign. It does not give prevention, and it does not see what sinks decline to sign.

Sink acknowledges, then commits stale effects and receipts them:
A stale-commit proof results (Section 11). Detection is after the fact; irreversible effects stay done.
Sink acknowledges, then commits stale effects without receipts:
SACE does not detect this directly. Downstream systems SHOULD refuse effects that arrive without a receipt, and receipts SHOULD be registered in a Transparency Service so that gaps in seq are visible.
Sink never acknowledges:
The verdict stays UNKNOWN. One silent sink blocks CLOSED; this is intended. Removing the sink requires a new manifest.
Sink outside the manifest holds live authority:
Grants name a listed audience and unlisted sinks refuse (Section 6). A sink that ignores both rules is outside SACE's reach, and CLOSED never covers it.
Compromised sink key:
An attacker can sign a false SEA. Recovery is by a new manifest. Attestation with key binding narrows the exposure to compromise of the measured environment.
Compromised AR key:
An attacker can issue cuts and manifests. Because cuts only raise floors, forged cuts cause denial of service rather than restored authority. Forged manifests can shrink the scope; relying parties SHOULD pin the prev_manifest chain.
Replayed or reordered cuts:
The floor is monotonic and repeats return stored bytes (Section 7).
State rollback at a sink:
Rollback produces a stale-commit proof against the sink. Rollback-resistant floor storage is required (Section 11).
Clock skew:
Clocks have no effect on verdicts. Grant expiry still depends on clocks; implementations MUST report expiry rejections separately from floor rejections.
Colluding sink and Evaluator:
The evidence is public and any other Evaluator can recompute the verdict. This holds only as far as the objects remain available.

Closure is prospective. Effects with seq at or below w were committed under authority that was valid at the time. SACE identifies them; it does not reverse them.

A CLOSED verdict means that every listed sink has signed that it stopped, and that no signed evidence contradicts any of them. It does not mean that the sinks stopped.

23.1. Privacy Considerations

Effect Receipts carry digests, not effect contents. Sequence numbers and sink identifiers still reveal activity volume per sink. Deployments that publish receipts need to consider whether that volume is sensitive.

24. IANA Considerations

IANA is requested to register six media types in the "Media Types" registry. The template below is for the first; the other five are identical except for the subtype name and the object named under "Applications that use this media type".

Type name:
application
Subtype name:
sace-manifest+cose
Required parameters:
N/A
Optional parameters:
N/A
Encoding considerations:
binary (CBOR)
Security considerations:
Section 23 of this document
Interoperability considerations:
Payloads use deterministic CBOR encoding; see Section 3.
Published specification:
This document
Applications that use this media type:
Revocation closure evaluation; carries a Scope Manifest.
Fragment identifier considerations:
N/A
Person to contact for further information:
See the Author's Address section.
Intended usage:
COMMON
Restrictions on usage:
None
Change controller:
IETF
Table 14: Media Types
Media type Object
application/sace-manifest+cose Scope Manifest
application/sace-cut+cose Cut Statement
application/sace-ack+cose Sink Epoch Acknowledgement
application/sace-effect+cose Effect Receipt
application/sace-verdict+cose Verdict record
application/sace-checkpoint+cose Checkpoint

Payload map keys are scoped to each object type and need no registry. An EAT profile identifier for Section 15 would be registered by a document defining a concrete profile, not by this one.

25. References

25.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8610]
Birkholz, H., Vigano, C., and C. Bormann, "Concise Data Definition Language (CDDL): A Notational Convention to Express Concise Binary Object Representation (CBOR) and JSON Data Structures", RFC 8610, DOI 10.17487/RFC8610, , <https://www.rfc-editor.org/info/rfc8610>.
[RFC8747]
Jones, M., Seitz, L., Selander, G., Erdtman, S., and H. Tschofenig, "Proof-of-Possession Key Semantics for CBOR Web Tokens (CWTs)", RFC 8747, DOI 10.17487/RFC8747, , <https://www.rfc-editor.org/info/rfc8747>.
[RFC8949]
Bormann, C. and P. Hoffman, "Concise Binary Object Representation (CBOR)", STD 94, RFC 8949, DOI 10.17487/RFC8949, , <https://www.rfc-editor.org/info/rfc8949>.
[RFC9052]
Schaad, J., "CBOR Object Signing and Encryption (COSE): Structures and Process", STD 96, RFC 9052, DOI 10.17487/RFC9052, , <https://www.rfc-editor.org/info/rfc9052>.
[RFC9596]
Jones, M. and O. Steele, "CBOR Object Signing and Encryption (COSE) "typ" (type) Header Parameter", RFC 9596, DOI 10.17487/RFC9596, , <https://www.rfc-editor.org/info/rfc9596>.
[RFC9679]
Isobe, K., Tschofenig, H., and O. Steele, "CBOR Object Signing and Encryption (COSE) Key Thumbprint", RFC 9679, DOI 10.17487/RFC9679, , <https://www.rfc-editor.org/info/rfc9679>.
[RFC9711]
Lundblade, L., Mandyam, G., O'Donoghue, J., and C. Wallace, "The Entity Attestation Token (EAT)", RFC 9711, DOI 10.17487/RFC9711, , <https://www.rfc-editor.org/info/rfc9711>.

25.2. Informative References

[CAEP]
Cappalli, T. and A. Tulshibagwale, "OpenID Continuous Access Evaluation Profile 1.0", OpenID Foundation, , <https://openid.net/specs/openid-caep-1_0.html>.
[I-D.chen-oauth-agent-revocation]
Chen, M. and L. Su, "OAuth 2.0 Agent Authorization Explicit Revocation", Work in Progress, Internet-Draft, draft-chen-oauth-agent-revocation-00, , <https://datatracker.ietf.org/doc/html/draft-chen-oauth-agent-revocation-00>.
[I-D.noa-scitt-ai-agent-receipt]
Toraman, T., "A SCITT Profile for AI-Agent Action Receipts", Work in Progress, Internet-Draft, draft-noa-scitt-ai-agent-receipt-01, , <https://datatracker.ietf.org/doc/html/draft-noa-scitt-ai-agent-receipt-01>.
[I-D.reece-wimse-cross-org-delegation]
Reece, M., "Cross-Organizational Delegation for Workload and Agent Identity: Problem Statement and Requirements", Work in Progress, Internet-Draft, draft-reece-wimse-cross-org-delegation-01, , <https://datatracker.ietf.org/doc/html/draft-reece-wimse-cross-org-delegation-01>.
[I-D.sweeney-wimse-credential-delegation]
Sweeney, K., "Credential Delegation Protocol for AI Agents in Multi-System Environments", Work in Progress, Internet-Draft, draft-sweeney-wimse-credential-delegation-02, , <https://datatracker.ietf.org/doc/html/draft-sweeney-wimse-credential-delegation-02>.
[I-D.watts-oauth-agent-revocation-closure]
Watts, D. O., "Revocation Closure and Authority Epochs for Agent Delegation", Work in Progress, Internet-Draft, draft-watts-oauth-agent-revocation-closure-02, , <https://datatracker.ietf.org/doc/html/draft-watts-oauth-agent-revocation-closure-02>.
[I-D.watts-rats-attested-fence-receipt]
Watts, D. O., "Attested Fence Receipts: Hardware-Rooted Evidence of Authority-Epoch Enforcement at Consequential Sinks", Work in Progress, Internet-Draft, draft-watts-rats-attested-fence-receipt-00, , <https://datatracker.ietf.org/doc/html/draft-watts-rats-attested-fence-receipt-00>.
[LEASES]
Gray, C. and D. Cheriton, "Leases: An Efficient Fault-Tolerant Mechanism for Distributed File Cache Consistency", Proceedings of the Twelfth ACM Symposium on Operating Systems Principles (SOSP), .
[PEERREVIEW]
Haeberlen, A., Kouznetsov, P., and P. Druschel, "PeerReview: Practical Accountability for Distributed Systems", Proceedings of the 21st ACM Symposium on Operating Systems Principles (SOSP), .
[RFC7009]
Lodderstedt, T., Ed., Dronia, S., and M. Scurtescu, "OAuth 2.0 Token Revocation", RFC 7009, DOI 10.17487/RFC7009, , <https://www.rfc-editor.org/info/rfc7009>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.
[RFC9334]
Birkholz, H., Thaler, D., Richardson, M., Smith, N., and W. Pan, "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, , <https://www.rfc-editor.org/info/rfc9334>.
[RFC9942]
Steele, O., Birkholz, H., Delignat-Lavaud, A., and C. Fournet, "CBOR Object Signing and Encryption (COSE) Receipts", RFC 9942, DOI 10.17487/RFC9942, , <https://www.rfc-editor.org/info/rfc9942>.
[RFC9943]
Birkholz, H., Delignat-Lavaud, A., Fournet, C., Deshpande, Y., and S. Lasker, "An Architecture for Trustworthy and Transparent Digital Supply Chains", RFC 9943, DOI 10.17487/RFC9943, , <https://www.rfc-editor.org/info/rfc9943>.
[SNAPSHOTS]
Chandy, K. M. and L. Lamport, "Distributed Snapshots: Determining Global States of Distributed Systems", ACM Transactions on Computer Systems, Vol. 3, No. 1, .

Appendix A. CDDL

This appendix gives payload definitions for the five objects in the notation of [RFC8610]. Each payload is carried in a COSE_Sign1.

digest      = bstr .size 32
scope-id    = bstr .size 16
epoch       = uint
sink-id     = tstr

manifest = {
  1 => scope-id,
  2 => uint,                 ; manifest_seq
  3 => digest / null,        ; prev_manifest
  4 => [ + member ],         ; sorted by sink-id
  ? 5 => tstr                ; att_profile
}
member = [ sink-id, digest, tstr ]
         ; id, key thumbprint, class

cut = {
  1 => scope-id,
  2 => digest,               ; manifest
  3 => epoch,                ; new floor
  4 => epoch,                ; prev_epoch
  5 => bstr .size 16,        ; cut_nonce
  6 => uint                  ; issued_at (informational)
}

ack = {
  1 => scope-id,
  2 => digest,               ; manifest
  3 => sink-id,
  4 => digest,               ; cut
  5 => epoch,                ; applied_epoch
  6 => epoch,                ; prev_epoch
  7 => uint,                 ; watermark
  8 => digest,               ; chain_head
  9 => uint,                 ; applied_at (informational)
  ? 10 => bstr               ; attestation (EAT, CWT)
}

effect = {
  1 => scope-id,
  2 => sink-id,
  3 => uint,                 ; seq
  4 => epoch,                ; authority_epoch
  5 => digest,               ; effect
  6 => digest                ; prev
}

verdict-record = {
  1 => digest,               ; manifest
  2 => digest,               ; cut
  3 => 0 / 1 / 2,            ; UNKNOWN / CLOSED / VIOLATED
  4 => [ + [ sink-id, 0 / 1 / 2, uint / null ] ],
  5 => digest,               ; verdict digest
  ? 6 => [ + violation-proof ]
}

violation-proof = [ 1 / 2 / 3, bstr, bstr ]
  ; 1 stale commit: ack, effect
  ; 2 equivocation: ack, ack
  ; 3 forked chain: any two of ack, effect, checkpoint

checkpoint = {
  1 => scope-id,
  2 => sink-id,
  3 => uint,                 ; seq covered
  4 => digest,               ; chain_head at seq
  5 => epoch,                ; floor
  6 => { * epoch => uint }   ; receipt counts by authority epoch
}

Appendix B. Validation Plan

This appendix describes the experiment that would test this specification, stating first the outcomes that would count against it. The two single-author implementations described in Section 21 exercise these arms in simulation; they do not meet the conditions for an independent run listed at the end of this appendix.

Primary falsifier:
An effect with authority epoch below e commits at a listed sink, with seq above that sink's signed watermark, and an Evaluator reports anything other than VIOLATED. One such run falsifies the evaluation algorithm.
Design falsifier:
An honest sink, following Sections 5 to 9 exactly, is reported VIOLATED under any ordering, partition, or clock offset. One such run means that the protocol convicts the innocent and the watermark rule is wrong.
Usefulness falsifier:
Under partition, an arrangement using only AR-side cut commitment reaches the same correct verdicts as SACE. In that case the acknowledgement adds nothing.
Table 15: Experiment Arms
Arm Link AR to sink B Cut ordering Clock at B Expected verdict
Baseline up in order true CLOSED, no stale commits
Partition down none delivered true UNKNOWN
Repair with reorder up 9 before 8 true CLOSED at 9 and at 8
Replayed old cut up 7 after 8 true CLOSED, floor unchanged
Skew only up in order +5 min CLOSED; expiry rejections counted separately
Unlisted descendant up in order true Refused by audience rule; verdict unaffected
Listed descendant, unseen by A late in order true UNKNOWN until B acknowledges; then CLOSED
Dishonest sink up in order true VIOLATED with stale-commit proof
Rolled-back sink up in order true VIOLATED, or refusal if rollback-resistant
Vacuous scope up in order true UNKNOWN (non-vacuity fails)

The following conditions apply to any run reported as a test of this document:

Appendix C. Test Vectors

13 vectors accompany this document as a JSON file. Each gives the AR public key, the sink public keys, the full bytes of the manifest, cut, acknowledgements, effect receipts, and Checkpoints in hexadecimal, the attester policy where one applies, and the expected result. Signing keys are derived from fixed test labels and are for testing only. Two sinks, sink-a and sink-b, are listed; each commits one epoch-7 effect before a cut to epoch 8, except where noted.

manifest digest, no att_profile (all but two vectors)
  6e57db47d44c041d513e6473e4328588dc92d04c2270de558f9be16538ae8497
cut digest over that manifest (epoch 8, prev_epoch 7)
  40c8147351189afe761875dd5c8adca31e0a8d0c05eab7e20135a47085847c68
manifest digest with att_profile (attested-*, attestation-*)
  3a04fd4cc0477f1508cf88d57daf5f253945c00251d0c16edefa72ad28dbde4f
cut digest over that manifest
  ea22aeca5b7e133c6f66d865ccb591bfb39c1853494b1d64746da2e2380a32bf
Table 16: Expected Results
Vector Members (sink:status/watermark) Verdict Proof types
baseline-closed sink-a:1/1 sink-b:1/1 CLOSED -
partition-unknown sink-a:1/1 sink-b:0/- UNKNOWN -
stale-commit-violated sink-a:1/1 sink-b:2/1 VIOLATED 1
vacuous-unknown sink-a:1/0 sink-b:1/0 UNKNOWN -
attested-closed sink-a:1/1 sink-b:1/1 CLOSED -
attestation-mismatch-unknown sink-a:1/1 sink-b:0/1 UNKNOWN -
checkpoint-witness-closed sink-a:1/1 sink-b:1/1 CLOSED -
equivocation-violated sink-a:1/1 sink-b:2/1 VIOLATED 2
forked-chain-violated sink-a:1/1 sink-b:2/1 VIOLATED 3
ack-head-fork-violated sink-a:1/1 sink-b:2/1 VIOLATED 3
checkpoint-fork-violated sink-a:1/1 sink-b:2/1 VIOLATED 3
broken-prev-link-violated sink-a:1/1 sink-b:2/1 VIOLATED 3
silent-sink-unknown sink-a:1/1 sink-b:0/- UNKNOWN -

Expected verdict digests:

baseline-closed
  ae4bb0ce0590efcb55fcf0effed92139f9b610bf0c99243e0cd35fbfa5b56199
partition-unknown
  f647d8963f1d868b7bdc037fea06a1cf7530b4f75487a2f04897f2d7a474f100
stale-commit-violated
  09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2
vacuous-unknown
  baee56483dc6332bb653481c90c0ffa1d2cfe005c3d75873621d5b2c2b72c723
attested-closed
  b3b28e877b38da9ec86a629ef1db9a90a6bbd3d532b9a43010a0b7e8408eb3ac
attestation-mismatch-unknown
  8fc77f708789b841d6923df3098b29d3adf6a538485a44aa40ce31c996dd7e07
checkpoint-witness-closed
  ae4bb0ce0590efcb55fcf0effed92139f9b610bf0c99243e0cd35fbfa5b56199
equivocation-violated
  09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2
forked-chain-violated
  09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2
ack-head-fork-violated
  09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2
checkpoint-fork-violated
  09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2
broken-prev-link-violated
  09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2
silent-sink-unknown
  f647d8963f1d868b7bdc037fea06a1cf7530b4f75487a2f04897f2d7a474f100

Several vectors are worth reading closely. In vacuous-unknown both members are ACKED and the verdict is UNKNOWN, because no epoch-7 effect exists. In attestation-mismatch-unknown, sink-b's acknowledgement carries a token with the wrong measurement: sink-b is UNACKED, not VIOLATED, and its watermark is still reported. In checkpoint-witness-closed no receipts are supplied and the Checkpoints alone provide the witness. In silent-sink-unknown, sink-a has acknowledged and committed five further effects and signed a Checkpoint, and sink-b has signed nothing; the verdict and its digest are identical to partition-unknown. All five VIOLATED vectors share one verdict digest because they convict the same member (Section 17).

These results were produced by the Python implementation and reproduced by the Go implementation described in Section 21.

Appendix D. Worked Example

Two sinks, sink-a and sink-b, are listed in manifest 1 of a scope. Both have floor 7. Each has committed one effect under epoch 7, so each has seq = 1.

Case 1, both acknowledge. The AR signs a cut to epoch 8. Each sink raises its floor to 8 and signs an SEA with applied_epoch = 8, prev_epoch = 7, watermark = 1. An Evaluator holding the manifest, the cut, both SEAs, and the two ERs finds both members ACKED and the non-vacuity witness present (an epoch-7 ER with seq 1 at or below watermark 1). The verdict is CLOSED.

Case 2, partition. Only sink-a receives the cut. sink-b, still at floor 7, admits a further epoch-7 request and receipts it with seq = 2. The Evaluator finds sink-a ACKED and sink-b UNACKED. The verdict is UNKNOWN. The epoch-7 effect at sink-b is not a violation: sink-b has signed nothing that it contradicts. When the cut reaches sink-b, its SEA carries watermark = 2, and the verdict becomes CLOSED. The watermark records that the second effect fell on the permitted side of sink-b's own line.

Case 3, breach. Both sinks acknowledge as in case 1, with watermark = 1. sink-b then commits an epoch-7 request and receipts it with seq = 2. The Evaluator finds an SEA from sink-b with applied_epoch 8 and watermark 1, and an ER from sink-b with authority_epoch 7 and seq 2. Since 7 is below 8 and 2 is above 1, sink-b is VIOLATED, and the verdict is VIOLATED. The proof is the array [1, SEA, ER].

The only difference between the permitted effect in case 2 and the breach in case 3 is the position of seq 2 relative to the watermark that sink-b itself signed.

Appendix E. Changes

This section is to be removed before publication as an RFC.

E.1. Since -02

  • Generalized the forked-chain rule to sequence commitments, so that broken prev links, false SEA chain heads, and conflicting Checkpoints are all type 3 proofs (Section 10, Section 11).
  • Stated the silent-sink rule normatively, with the list of evidence that cannot substitute for an acknowledgement (Section 10.1).
  • Added Checkpoints as a source of the non-vacuity witness, and stated that a Checkpoint is never an acknowledgement.
  • Specified attestation appraisal and its outcome: failure makes a member UNACKED, never VIOLATED (Section 15).
  • Added the Verdict Record section with its verification procedure and what that procedure does not establish (Section 12).
  • Defined proof verification for a single pair of objects.
  • Noted that the verdict digest identifies the outcome, not the evidence.
  • Second implementation in Go; 13 vectors; concurrency and crash tests (Section 21, Appendix C).

E.2. Since -01

  • Added implementation guidance for database-backed sinks: schema, transaction recipes, isolation, durability, and rollback resistance (Section 18).
  • Added the evidence store, its analysis queries, and operational measures (Section 19).
  • Added operational management: backup and restore, key rotation, removal of a silent sink, monitoring (Section 20).
  • Added the optional Checkpoint object and retention rules (Section 14).
  • Added an implementation status section and test vectors (Section 21, Appendix C).

E.3. Since -00

  • Positioned the document against the attested fence receipt draft and added Section 16 on combined use.
  • Added the sink state machine and its three invariants (Section 5).
  • Added a properties section with five claims, their assumptions, and what is not guaranteed (Section 13).
  • Added an evidence analysis and a comparison with neighbouring mechanisms (Section 22).
  • Newly listed sinks now start in HALTED and acknowledge before admitting.
  • Added a full media type registration template and a worked example (Appendix D).

Author's Address

Deonté O'dell Watts
GoodShyt Group Inc.
San Francisco, CA
United States of America