Skip to content
Reference

Vultron Protocol Specification

This page holds the whole Vultron Protocol Specification in order, for printing or for searching the whole text at once. The parts and annexes publish the same text one part per page, and the site search indexes those pages rather than this one.

Current draft (work in progress): Draft 2

This specification is a draft, not a finished standard.

Property Value
Version draft-2
Status Current draft (work in progress), not yet released
Opened 2026-11-13
Last updated 2026-11-20

The last-updated date is the date of the publish of the site that built this page: each publish stamps it. The opened date is the day the entry for this draft was added to the drafts register. The drafts register, which the Revision Log is generated from, records each draft's dates. Until a release of the Vultron repository carries the draft, its text can still change. To cite this text, name the specification, the version and the date it was last updated, for example: Vultron Protocol Specification, draft-2, 2026-11-20. Until a release carries the draft, also name the publish-YYYY-MM-DD.N tag in the page footer, which identifies the text you read (Vultron Release Versioning). Once a release carries the draft, name the release tag that the Revision Log gives for it instead. The newest released draft is draft-1, which release v2026.11.0 carries; the Revision Log links its frozen copy.

Abstract

The Vultron Protocol coordinates vulnerability disclosure among multiple organizations. Participants exchange asynchronous messages and track the case across four dimensions of shared state, realized as five state machines. Any number of organizations may take part in a single case.

Coordination is scoped to the case rather than to a system: the case-management role is held per case, and different cases may be managed by different actors. No single service holds every case. Within a case, one participant holds write authority over the case's shared state, so that concurrent claims resolve to one answer.


1. Introduction [I]

1.1 Background and Motivation

A vulnerability divides the world into two sets: those who know about it, and those who do not. From the moment of discovery, every party in the knowing set repeatedly answers two questions. What should it do next, and who else needs to know what, and when? Coordinated Vulnerability Disclosure (CVD) continues until the answers are "nothing" and "nobody".

Multi-Party CVD (MPCVD) is CVD involving three or more independent organizations with different interests and roles. The shapes vary. A reporter may go to one vendor, which discovers that other vendors ship the same component. A reporter may go to a coordinator, which finds and notifies the affected vendors. A reporter may go to a vendor and a coordinator at once. What the cases have in common is that the set of participants grows after coordination has begun, each vendor works to its own timeline, and the parties must agree when disclosure happens.

Each of those organizations usually already runs its own vulnerability tracking system. The coordination problem is therefore not only one of people talking to each other; it is one of separate systems needing to stay consistent about a shared case. That is the problem Vultron addresses.

Email carries the content of a CVD case but records none of its state. No participant can see which vendors have received the report, which have agreed to an embargo, or in what order events occurred. Adding a party mid-case means re-sending the history by hand, and nothing detects the gap if that fails. Vultron gives each of these an explicit, machine-checkable representation: report status per participant (§6 Report Management (RM) State Machine), embargo agreement per participant (§9 Participant Embargo Consent (PEC) State Machine), and an ordered case ledger that every active participant replicates (§10.4 Ledger Replication and Case Delivery).

Embargo timing is worth noting early. In practice the first two parties to a case establish the initial embargo, and it carries forward as further participants join and agree to it. Establishing terms early is generally easier than negotiating them once many parties are already involved.

The protocol tracks coordination state across four dimensions: the report lifecycle, Report Management (RM); the embargo, Embargo Management (EM); what is known about the vulnerability, Case State (CS); and each participant's agreement to the embargo, Participant Embargo Consent (PEC). Because CS is a compound of two independent axes, the protocol defines five state machines (§3.3 Tracking Dimensions). Messages are ActivityStreams 2.0 Activities delivered over Hypertext Transfer Protocol (HTTP). Delivery is asynchronous: no exchange requires both parties to be available at the same moment.

Who this specification is for

This specification is written for implementers building software that takes part in Vultron cases, and for reviewers assessing whether an implementation conforms.

It assumes familiarity with coordinated vulnerability disclosure as a practice — reporters, vendors, coordinators, embargoes, Common Vulnerabilities and Exposures (CVE) IDs. It does not assume prior knowledge of Vultron. Where it relies on an external specification, it says so and cites it (§1.3 Relationship to Existing Standards).

1.2 Design Goals

Actor-local state. Each participant keeps its own replica of the case, assembled from the messages it has received. A participant is the authority on its own report and fix status. What the case as a whole asserts — its embargo state and what is publicly known — has a single writer, the participant holding the CASE_MANAGER role, so that concurrent claims resolve to one answer (§10.1 Single-Writer Authority).

Coordination is scoped to a case, not to a system. The CASE_MANAGER role is held per case, and different cases may be managed by different actors. Nothing in the protocol routes every case through one shared service. Within a case, though, shared state has one writer.

Informative: how centralized is this?

Two readings should both be avoided.

Vultron does not require a single central authority holding all cases. Any actor able to satisfy the CASE_MANAGER role can manage a case, and the role is transferable (§12.3 Case Ownership Transfer).

Equally, Vultron as it stands is not a fully decentralized design. Within a case there is one writer, and its availability bounds how fast the case can progress. The current reference implementation runs one Case Actor service per container, which holds the CASE_MANAGER role for all the cases it manages. A Case Owner that does not delegate management holds the role itself.

The protocol leaves more distributed realizations open — a shared ledger among peers, for instance — and this version does not specify one (§10.2 Routing Topology).

Asynchronous, message-driven coordination. Participants announce their own transitions rather than being polled, and no exchange requires two parties to be online at once. A participant that is temporarily unreachable does not block the others from making progress.

Extensible role model. Roles are not exclusive: a participant may hold Reporter, Vendor and Coordinator at the same time (§3.5 Participants and Roles). Roles that confer protocol authority are kept separate from roles that describe what an actor does in the world, so the two can vary independently.

Interoperable wire format. ActivityStreams 2.0 is the normative wire vocabulary. Reusing an established open standard means the message format is already specified and already understood, and it leaves ActivityPub-based delivery available as a path to potentially compatible tooling. Vultron has not yet been integrated with the wider ActivityPub ecosystem.

1.3 Relationship to Existing Standards

ActivityStreams 2.0 and ActivityPub. Vultron uses the ActivityStreams 2.0 vocabulary as its wire format, and ActivityPub HTTP delivery is the anticipated transport.

This version builds on the vocabulary but not on full ActivityPub server behavior. HTTP POST to each actor's inbox endpoint is required (§5.3 Transport). WebFinger discovery, HTTP Signatures, and ActivityPub federation behaviors such as shared inbox, outbox GET, and followers collections are not conformance requirements here. A future version is expected to raise the floor to full ActivityPub for all participants, at which point the vocabulary-only profile may become a compatibility profile. An implementation built against this version can expect to be re-evaluated against that one. This paragraph is the specification's single statement of that roadmap; other sections cite it.

ISO/IEC 29147 and 30111. International Organization for Standardization (ISO) 29147 specifies vulnerability disclosure practices; ISO 30111 specifies vulnerability handling processes. Vultron implements the multi-party coordination layer those standards describe at a high level. The CERT Guide to Coordinated Vulnerability Disclosure provides the practitioner-level complement.

1.4 Document Conventions

This specification uses the key words defined in RFC 2119: MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL.

Sections marked [N] are normative. Sections marked [I] are informative. Sections marked [N/I] contain a mix; normative requirements are explicitly flagged.

State names. This specification writes state names in full, in prose form: Received, Active, Agreed, Fix Ready. Where the name of a specific enumerated value matters, for example when citing an implementation's enumeration, the value is written in code font with its machine as a prefix, as in RM.RECEIVED or EM.ACTIVE. The two forms name the same state. Consent row states and embargo register statuses are written in code font without a prefix (AGREED, PROPOSED); where a word names both an EM state and a register status, the text says which. Some positions the specification names are reads of state rather than states: a participant is a signatory when its consent to the embargo in force is Agreed (§9.3 Signatory and Lapsed).

Case-state notation. The Case State axes use one letter per condition. A lowercase letter means the condition is not met; an uppercase letter means it is. Vfd therefore means the vendor is aware, the fix is not ready, and the fix is not deployed. An arrow names the transition that flips one letter, so f→F is the change from "fix not ready" to "fix ready". An asterisk is a wildcard: pX* matches any state in which p is lowercase and X is uppercase.


2. Terminology [N/I]

Vultron gives several ordinary Coordinated Vulnerability Disclosure (CVD) words a narrower meaning than they carry in general use. The tables in this section state the protocol meaning of each term. Where the protocol meaning differs from common usage, the protocol meaning applies throughout this specification.

This section is the authoritative source for the terms it defines, including the role enumeration in §2.2 Roles. An implementation derives its vocabulary from this specification.

Where a term already has a settled definition in the wider coordinated vulnerability disclosure literature, this specification adopts that definition rather than coining its own, and says where it came from. Vulnerability is such a term.

2.1 Actors, Participants and Cases

These four terms are ordered deliberately: each builds on the one before it.

Term Definition
Vulnerability A set of conditions or behaviors that allows the violation of an explicit or implicit security policy. Vulnerabilities are the subject of every Vultron case.
Report A document describing a specific vulnerability, submitted to initiate coordination.
Case The coordination context around a specific vulnerability: the participants, the shared state, the messages exchanged, and any embargo agreement. The case is the unit of Vultron protocol activity.
Actor An identity in the protocol, named by a Uniform Resource Identifier (URI). An actor may be an organization, a person, or a service. Actors exist independently of any case.
Participant An actor with a CaseParticipant record in a specific case, whether or not it has yet joined. The record associates that actor with the roles it holds and the state it owns. An active participant is one that was seated at case creation or has accepted the case invitation, has not been removed, and, while an embargo is active, has agreed to that embargo. An actor is a participant in a case; the same actor may participate in many.

Source of the vulnerability definition

The definition of vulnerability above is taken unchanged from the CERT Guide to Coordinated Vulnerability Disclosure. It is also consistent with ISO/IEC 29147:2018 §5.4, which defines the term in the same policy-violation terms (ISO crosswalks).

Note what the definition does not require: it says nothing about whether the vulnerability is known, reported, fixed or public. Those are properties a Vultron case tracks about a vulnerability (§8 Case State (CS) Dimensions), not part of what makes something one.

2.2 Roles

A role is a position held within a case. It determines what a participant is obliged to do and which transitions it is authorized to cause. Roles are granted through the case's authority chain (§12.1 Role Assignment), not claimed. A participant may hold several at once.

Roles fall into two categories, which §13.3 Role Taxonomy develops further.

Process roles describe what an actor does in a case:

Role Definition
Reporter A participant that submitted the report. The protocol is concerned with who reported the vulnerability, not who discovered it; a discoverer who reports holds the Reporter role.
Vendor A participant that produces a product containing the vulnerability and is responsible for developing a fix.
Coordinator A participant that facilitates multi-party coordination without being responsible for developing a fix itself.
Deployer A participant that deploys a vendor's fix to systems it operates. Distinct from Vendor: producing a fix and applying it are separate acts.
CVE Numbering Authority (CNA) A participant authorized to assign CVE IDs directly, rather than delegating assignment to an external service. Orthogonal to the other process roles and commonly held alongside Coordinator or Vendor.
Observer A participant with no obligation to drive vendor/fix/deploy transitions. An Observer still tracks case state, is subject to embargo consent, and may report observations about the world.

Protocol authority roles describe what an actor controls in the protocol itself:

Role Definition
Case Owner The party whose disclosure decision the case exists to serve. It decides who is invited, which roles they hold, and whether embargo terms are accepted or torn down. Case ownership is never delegated, though it may be transferred (§12.3 Case Ownership Transfer).
CASE_MANAGER The participant that writes the canonical case ledger and relays case-scoped messages, acting on the Case Owner's behalf. It is the case's single-writer authority (§10.1 Single-Writer Authority). The Case Owner may delegate this role.

The Observer role and the Case Observer capability set

Observer is a process role (defined above). The minimum conformance capability set that every participant provides is the Case Observer capability set (§13.2 Capability Sets) — named to echo the least-privileged role, with a Case prefix that keeps the two distinct. They are not the same kind of thing: a role is a position in a case; a capability set is a property of software (§13.3.3 Roles and Capability Sets Are Independent). The same prefix distinguishes the Case Decision and Case Hosting capability sets from the roles they serve.

Informative: the CASE_MANAGER role and the actor that holds it

Authority over a case follows the CASE_MANAGER role. It does not follow any actor's name, URI, or hosting location. Normative text in this specification therefore names the authority the CASE_MANAGER, meaning whichever participant currently holds the role.

The reference implementation happens to satisfy the role with an automated software actor it labels a case actor, provisioned by a case actor service. Those are implementation labels with no protocol meaning, and they confer no authority: the requirements below tie authority to the role.

Requirements

ID Priority Requirement Related
BT-10-003 MUST The actor holding the CASE_MANAGER role for a case MUST process that case's messages. The authority is that role, not any particular actor that enacts it.

When message processing follows the role and not one specific object, any actor that holds the role can do the work. This includes an actor that the Case Owner delegates the role to, and the Case Owner itself. If an obligation names a separate case actor, implementations create one for each case, which BT-10-002 forbids.
Depends on: BT-10-002
BT-10-004 MUST The actor holding the CASE_MANAGER role for a case MUST enforce that case's authorization decisions.

Each authorization decision of a case needs one enforcer that every participant can name. The CASE_MANAGER processes the messages of the case (BT-10-003), so it is the actor that admits or refuses them.

Informative: Finder is not a protocol role

Earlier CVD models distinguish the finder of a vulnerability from its reporter. Vultron does not: nothing in the protocol depends on who discovered the vulnerability, so an actor that discovers and reports holds the Reporter role. The discoverer's identity may be recorded in the report content or in a case note.

2.3 Protocol Objects and Messages

These terms name the things a case is made of and the messages that move between participants.

Term Definition
Activity The wire form of a Vultron message: an ActivityStreams 2.0 Activity. Every message this specification describes is carried as an Activity (§5 Encoding and Transport).
Message A protocol operation sent from one actor to another. A message states that something has happened; it is not an instruction to the recipient.
Message type One message of the formal message set, the design model of the protocol's messages, each named by a protocol shorthand. RS (Report Submission) and EP (Embargo Proposal) are message types. This version realizes them as occasions (§4 Messages).
Occasion A situation in a case that a sender conveys with a particular wire activity, such as "a Vendor has a fix ready". The occasion is the unit this specification states message rules about (§4 Messages).
Wire activity An Activity of a given shape, written Verb(Object)[field=Value] with the type values a sender puts on the wire, such as Offer(VulnerabilityReport) (Wire Activity Notation).
Protocol shorthand The two-letter code naming a message type by its meaning rather than its wire form — RS, EP, CV, and so on. It is a cross-reference tag for the occasions that realize the message type, and the vocabulary of the transition tables of §6 Report Management (RM) State Machine through §9 Participant Embargo Consent (PEC) State Machine. §4.13 Formal Message Set lists each with its wire activities. A reader meeting a shorthand before §4 Messages may treat it as an opaque label.
Case stub A minimal description of a case, carrying enough for an invited actor to decide whether to join and no vulnerability detail. Sent with an invitation, before the invitee has accepted the invitation (§12.2 Invitation and Acceptance).
Case ledger The case's authoritative, append-only history. The CASE_MANAGER is its only writer, and every participant holds a replica built from what the CASE_MANAGER sends.
CaseLedgerEntry One entry in the case ledger. Each entry records one admitted change, carries a timestamp assigned by the CASE_MANAGER, and is hash-chained to its predecessor so a participant can tell whether it holds the entries in order and without gaps.
ParticipantStatus A participant's report about its own state, or its observation about the world. A ParticipantStatus is a claim: any participant may write one, and writing one does not change the case's state (§11.3 Status Adoption: One Authorization Gate).
CaseStatus The case's shared state — its embargo state and what is publicly known. A CaseStatus is canonical: only the CASE_MANAGER writes it, and it changes only when a claim is adopted (§11.3 Status Adoption: One Authorization Gate).
Channel The path a message travels. In Vultron the delivery path is inbox to inbox, and case-scoped messages route through the CASE_MANAGER (§10.2 Routing Topology).

2.4 State, Embargo and Disclosure

These terms concern what a case knows and what its participants have agreed to. The last two are the pair most often conflated.

Term Definition
State The current value of one state machine. Always qualified in this specification — RM state, embargo state, case state — because the unqualified word is ambiguous.
Transition A change from one state to another.
Track To maintain a local value for a state machine and update it as incoming messages report transitions. Every participant tracks all five machines (§13.2 Capability Sets).
Drive To cause a transition that the participant's roles authorize, and announce it so the other participants learn of it. Which transitions a participant may drive depends on its roles (§13.4 Role-Specific Normative Requirements).
Embargo A time-bounded agreement among the participants of a case not to disclose the vulnerability publicly before an agreed point. Tracked for the case by the embargo state machine (§7 Embargo Management (EM) State Machine) and per participant by embargo consent (§9 Participant Embargo Consent (PEC) State Machine).
Teardown Ending an active embargo. The CASE_MANAGER performs the teardown and records it; a participant may report that it intends to exit, or propose an earlier end, but does not end the case's embargo itself (§11.2 Embargo Revision and Termination Cascades).
Publication A deliberate act by a participant that makes vulnerability information publicly available. Publication is something a participant does, and the embargo constrains when a participant may do it.
Public awareness The condition of the vulnerability being known outside the case, however that came about. Public awareness may arise with no participant publishing anything: an attacker may discover the vulnerability independently, a commit may reveal it, or a non-participant may write about it.

Publication and public awareness are not the same thing

Vultron governs publication — what a participant may deliberately disclose, and when. It cannot govern public awareness, which is a fact about the world that no participant controls.

The distinction is load-bearing because most of the protocol's disclosure logic keys off whether information is public, not off how it became public. An embargo that is overtaken by an independent leak is over as surely as one ended by agreement, and the case state records Public Aware either way (§8.2 PXA — Public Aware, Exploit Public, Attacks Observed).

See also


3. Protocol Overview [I]

This section describes the shape of the protocol before the normative sections specify it. It covers how the protocol is modeled, what state it tracks, how that state is divided between individual participants and the case as a whole, and what roles participants hold. Nothing here is normative; each subsection points to the section that carries the requirements.

3.1 Coordination Model

Vultron models a case as a set of communicating state machines — one set per participant — that coordinate only by exchanging messages. No participant reads another's state directly. Each learns about the others from the messages it receives.

A participant's own view is therefore always a replica: its local copy of what it believes the case state to be, assembled from the messages that have reached it. Two participants can hold different views at the same moment, because a message is still in transit or because a participant has not yet reported something.

State divides into two kinds, and the distinction runs through the whole specification. Participant-specific state belongs to one participant, which is the authority on its own value. Shared case state has one value for the entire case, and only the participant holding the CASE_MANAGER role writes it (§10.1 Single-Writer Authority); it replicates each admitted change to every active participant (§3.4 How the Dimensions Interact) as Add(CaseLedgerEntry).

Machine Ownership Written by
Report Management (RM) Participant-specific The participant is the source, and the CASE_MANAGER records each value on the participant's record. The CASE_MANAGER also writes the invitee's initial Received when it sends the stub Invite, keeps Received when the invitee accepts it, and writes Closed when the invitee rejects it.
Vendor aware, Fix ready, fix Deployed (VFD) Participant-specific The participant is the source, and the CASE_MANAGER records each value on the participant's record. For a vendor invitee, the CASE_MANAGER also writes the initial vfd when it sends the stub Invite, and Vfd when the invitee accepts or rejects it.
Embargo Management (EM) Shared case state The CASE_MANAGER only
Public aware, eXploit public, Attacks observed (PXA) Shared case state The CASE_MANAGER only
Participant Embargo Consent (PEC) Per-participant The CASE_MANAGER only

A participant reports its own state and reports observations about the world. It does not write shared case state, and reporting an observation is not the same as that observation becoming canonical (§11.3 Status Adoption: One Authorization Gate).

3.2 What a Deployment Looks Like

The protocol is abstract, but a deployment is concrete, and the shape is worth stating plainly before the state machines begin.

Each participating organization runs one Vultron service, which exposes an inbox at a URI. For each case, one participant additionally holds the CASE_MANAGER role for that case, and every case-scoped message passes through it: a participant addresses the message to the CASE_MANAGER, which records it in the case ledger and then sends the resulting entry to every active participant, including the sender.

---
title: Message flow within one case
---
flowchart LR
    R["Reporter<br/>(own inbox)"]
    V1["Vendor A<br/>(own inbox)"]
    V2["Vendor B<br/>(own inbox)"]
    CM["Participant holding<br/>CASE_MANAGER for this case<br/>(own inbox + case ledger)"]

    R -- "case-scoped message" --> CM
    V1 -- "case-scoped message" --> CM
    V2 -- "case-scoped message" --> CM
    CM -- "Add(CaseLedgerEntry)" --> R
    CM -- "Add(CaseLedgerEntry)" --> V1
    CM -- "Add(CaseLedgerEntry)" --> V2

Two things this is not:

  • It is not a central clearinghouse. The role is held per case. A different case may route through a different organization entirely, and there is no service that sees every case.
  • It is not a registry. Nothing looks up authority in a directory; authority follows the role recorded on the case (§10.1 Single-Writer Authority).

Participants also talk to each other outside the protocol — by mail, by phone, in a shared channel. That is normal and out of scope. What routes through the CASE_MANAGER is the case's protocol traffic, because that is what changes case state (§10.2 Routing Topology).

Messages describe what has happened

A Vultron message states that something has already occurred. It is not an instruction to the recipient. An RV message means "I received this report and determined it was valid" — it does not ask the recipient to treat the report as valid. This holds throughout §4 Messages through §11 Model Interactions and Cascade Rules and governs how every message description in those sections should be read.

One construct is deliberately request-shaped: a proposal such as an embargo invitation asks for a decision. Even there, the reply reports a decision that has been made; it does not command a transition.

See also

3.3 Tracking Dimensions

The protocol tracks coordination state across four dimensions. Each is a state machine, or a pair of them, with its own states and transitions. The lists below name the states so the rest of this overview can refer to them; the defining sections carry the full definitions.

  • Report Management (RM) — the lifecycle of a report inside one participant, from receipt to closure. Participant-specific. Seven states: Start, Received, Invalid, Valid, Deferred, Accepted, Closed (§6 Report Management (RM) State Machine).
  • Embargo Management (EM) — the negotiated disclosure timing agreed for the case. Shared case state, computed from the case's embargo register of every embargo proposed on it. Five states: None, Proposed, Active, Revised, Exited (§7 Embargo Management (EM) State Machine).
  • Case State (CS) — what is known about the vulnerability. CS is the pair (VFD, PXA) (§8 Case State (CS) Dimensions).
  • Participant Embargo Consent (PEC) — each participant's answer to each embargo in the register, one row per embargo. Per-participant, written by the CASE_MANAGER. Five states: Uninvited, Invited, Agreed, Declined, Timed out. Whether a participant is bound, a signatory, is read from its row for the embargo in force (§9 Participant Embargo Consent (PEC) State Machine).

Four dimensions, five state machines

Case State (CS) is a compound of two independent axes, so the protocol realizes four tracked dimensions as five state machines:

This specification says "four dimensions" when describing what is tracked and "five state machines" when describing what the protocol defines. Both counts are correct; they count different things.

The Vultron implementation splits VFD into two machines, so it has six. A vendor path, CS_vf (vf, Vf, VF), holds Vendor Aware and Fix Ready. A deployer path, CS_d (d, D), holds Fix Deployed. The two paths combine into six pairs. The VFD order of §8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed rules out the two pairs with a deployed fix that was never ready, which leaves the same four VFD states (vfd, Vfd, VFd, VFD) and the same 32 compound CS states.

RM, EM and CS were present in the original protocol design. PEC emerged during implementation and is fully normative; its provenance is recorded at §9 Participant Embargo Consent (PEC) State Machine.

3.4 How the Dimensions Interact

The four dimensions are coupled. A transition in one creates obligations in others. This subsection summarizes the couplings; §11 Model Interactions and Cascade Rules specifies them.

Being on the roster is not receiving the case. An invited actor is a participant from the invitation onward, at RM state Received. The CASE_MANAGER sends case content only to an active participant. A participant is active when it was seated at case creation or has accepted the case invitation, has not been removed, and, while an embargo is active, has agreed to that embargo. Once a participant's closure is recorded (RM state Closed), it receives no case content after the entries that record its own closure (§9.7 Gating Full Case Delivery).

EM gates disclosure. While an embargo is in force, participants defer publication. An embargo ends by teardown: the CASE_MANAGER terminates it and records the termination. A participant may report that it intends to exit, or propose a shorter embargo or an earlier end date, but a participant does not end the case's embargo by itself — EM is shared case state (§7.2 Transitions and Guards, §11.2 Embargo Revision and Termination Cascades).

CS records observation, not decision. A VFD transition is a fact about what one participant has done. A PXA transition is a fact about the world. Any participant may report a PXA observation; whether that report becomes canonical case state is decided separately (§11.3 Status Adoption: One Authorization Gate).

EM and PEC answer different questions. EM says whether the case has an embargo. PEC says whether a given participant is bound by it. The two can disagree: a case at EM Active may hold a participant whose row for the embargo in force is not Agreed, if that participant has been invited but has not yet joined, or declined the terms. Cascade rules keep them consistent (§11.2 Embargo Revision and Termination Cascades).

3.5 Participants and Roles

An actor is an identity in the protocol — an organization, a person, or a service, named by a URI. An actor that is invited to a case, or seated in it when the case is created, becomes a participant in that case, and the case's record of that participant associates it with a set of roles. Roles determine what a participant is obliged to do and which transitions it is authorized to cause.

Roles are not exclusive. A participant may hold Reporter, Vendor and Coordinator at once. A vendor that discovers a vulnerability in its own product is both Reporter and Vendor.

Participant count is not role count. Every participant runs all five state machines regardless of which roles it holds. Roles govern which transitions it may cause, not which machines it maintains.

Two categories of role apply. §13.3 Role Taxonomy gives the full taxonomy.

  • Process roles — what an actor does in a case: Reporter, Vendor, Coordinator, Deployer, CVE Numbering Authority (CNA), Observer.
  • Protocol authority roles — what an actor controls in the protocol itself: Case Owner and CASE_MANAGER. These confer specific rights within a case, independent of what other actors do.

The distinction between the two authority roles matters throughout:

  • The Case Owner is the party whose disclosure decision the case exists to serve. It decides who is invited, which roles they hold, and whether embargo terms are accepted or torn down. Case ownership is never delegated, though it may be transferred (§12.3 Case Ownership Transfer).
  • The CASE_MANAGER is the participant that holds the CVDRole.CASE_MANAGER role. It writes the canonical case ledger, relays case-scoped messages, and acts on the Case Owner's behalf. The role cannot be granted by a role offer (§12.1 Role Assignment); how it is handed to another actor is not yet specified.

Roles are assigned through the case's authority chain, not claimed. An actor does not acquire a case role by asserting that it holds one (§12.1 Role Assignment).


4. Messages [N]

What happened to the formal message type shorthand?

The formal message set, with its two-letter shorthands such as RS, EP and CV, was a design model of the protocol's messages. This version realizes that model as occasions, each conveyed by one wire activity. Formal types that share one wire activity merged, and context tells them apart: the receiver's embargo state separates EV, EJ and EC from EP, ER and EA, and a field value separates CV, CF and CD, and CP, CX and CA. EA and EC are the Case Owner's activation of a proposal, and ER and EJ its rejection, told apart by whether the case embargo is Proposed or Revise. ER is also the CASE_MANAGER's abandonment of a proposal, its own Reject of the Invite. A participant's Accept or Reject of an embargo Invite is its own consent, which the formal set does not model, so it carries no shorthand (MSM-02-010). The formal set remains the vocabulary of the transition tables of §6 Report Management (RM) State Machine through §9 Participant Embargo Consent (PEC) State Machine (ADR-0083).

This section defines what a participant sends in each situation of a case, and what a message it receives means. Its unit is the occasion: a situation in a case that a sender conveys with a particular Wire Activity. A normative statement about a message is a statement about an occasion. A protocol shorthand, such as RS or EP, is a cross-reference tag that names the formal message an occasion realizes.

Wire activities are written in the notation of Wire Activity Notation, Verb(Object)[field=Value], using the type values a sender puts on the wire. §5 Encoding and Transport specifies how each one is encoded and delivered.

4.1 Rules Under Any Coordination Model

These rules hold for every message, however the case is coordinated.

Every message reports something that already happened. A message does not instruct its recipient to make a transition. It tells the recipient that the sender has made one, or that the sender has observed something (§3.1 Coordination Model). A proposal, such as an embargo invitation, asks for a decision, and its answer reports the decision once it is made.

A message that arrives before its case is held, not applied. A message from the CASE_MANAGER may reach a participant before the bootstrap message that establishes the case and its trust (§10.3 Case Bootstrap and the Trust Root). The participant holds such a message for a short, bounded interval, and drops it if the bootstrap message has not been validated by then. Applying it early would create case state from a message whose context was never established.

Requirements

ID Priority Requirement Related
CBT-03-001 SHOULD If a CASE_MANAGER-originated case message arrives before the required bootstrap trust handoff, the receiving actor SHOULD queue it only for a short bounded interval rather than accepting or permanently trusting it immediately.

The transport does not promise delivery order (SYNC-19-003), so a message from the real CASE_MANAGER can arrive before the bootstrap that makes it trusted. If the receiver drops the message at once, the message is lost. If the receiver applies it at once, it trusts a sender it has not checked. A short hold keeps the message until the bootstrap arrives, and the limit stops untrusted messages from staying in storage with no end.
Refines: PCR-06-002
CBT-03-002 MUST NOT A pre-bootstrap CASE_MANAGER message MUST NOT update local case state before the corresponding trust-establishing bootstrap message has been validated.

Before the bootstrap is validated, the receiver cannot know that the sender is the CASE_MANAGER. A state change from that message can come from any actor, and the receiver would then hold case state that no trusted source sent.
Refines: PCR-06-003
CBT-03-003 MUST When the bounded pre-bootstrap queue interval (CBT-03-001) expires, the receiver MUST drop the queued message.

A message the receiver cannot yet trust must not wait without limit for a case copy that may never arrive. Dropping it when the interval ends limits what the receiver stores. ADR-0163 gives the recovery of a dropped Invite to the CASE_MANAGER, which knows which Invites each participant has not answered.
Extends: CBT-03-001

Messages are addressed according to the routing rules of §10 Case Coordination.

4.2 Knowledge Model and Actor Isolation

Each participant knows only what it has been told. This subsection states what follows from that, including why a recipient can obtain every object a message names (§5.2 Serialization).

What a participant knows versus what is true. A participant's replica reflects the messages it has received. Two participants in the same case may hold different views at the same moment, because a message is in transit or because a participant has not yet reported a change. The protocol does not keep every participant in agreement at every instant. Each participant converges on the case's canonical state as ledger entries reach it.

Requirements

ID Priority Requirement Related
VP-01-003 MUST NOT Correct operation of the protocol MUST NOT depend on perfect information across all Participants

Participants in a distributed CVD case never all see the same state at the same moment: messages are delayed, lost, or withheld by embargo scope. A protocol that needed perfect shared information would stall or misbehave in every real case, so each step must be safe on the partial view a participant actually holds.

No participant reads another's state. Actors exchange information only through protocol messages, even when they run in one process. What a participant knows about another comes from the messages it has received, including the entries of the canonical ledger. This is what makes a participant's knowledge independent of any other participant being reachable.

Requirements

ID Priority Requirement Related
AKM-01-002 MUST NOT Co-located actors MUST NOT communicate by reading or writing each other's local state, or by calling into each other directly. Co-located actors share a server or a process.

A direct shortcut between co-located actors bypasses the inbox pipeline, so its exchanges skip validation, the addressee and entitlement gates, and the case ledger, and leave nothing a remote participant would receive.
Derives from: PCR-01-003
AKM-01-003 MUST Co-located actors MUST still exchange protocol messages through each other's inboxes. Co-located actors share a server or a process.

Delivery through inboxes makes co-location invisible to the protocol: the same actors behave the same whether or not they share a process.
Extends: AKM-01-002
PCR-01-003 MUST The protocol MUST work the same whether every Actor runs on one host or on many. Actor co-location is an implementation choice.

Co-location is a deployment choice. Code that reads another Actor's store, or waits for a side channel, works only while two Actors share a host. Per-actor stores (ADR-0073) prevent direct reads and writes, but not code that expects the case to be visible early.
PCR-01-004 MUST Actors MUST exchange information only through protocol messages.

A protocol message is the one channel every deployment shares. Information that passes any other way works only while two Actors share a host, so the protocol would then depend on where the Actors run (PCR-01-003).
Implements: PCR-01-003
PCR-01-005 MUST NOT An Actor MUST NOT read, write, or otherwise reach into another Actor's store.

Each Actor has its own store (ADR-0073). A read or write of another Actor's store works only on a shared host, and it changes that Actor's state without a message that Actor can check.
Derives from: PCR-01-003
PCR-01-006 MUST NOT An Actor MUST NOT rely on out-of-band communication with a co-located Actor.

A side channel between two Actors on one host is not there when they run apart. Code that waits for one then fails, or works only by chance, in a distributed deployment.
Derives from: PCR-01-003
PCR-01-007 MUST An Actor that asked a CASE_MANAGER to create a case MUST treat the case as absent until the CASE_MANAGER's Create(VulnerabilityCase) reaches it. It never assumes that co-location makes the case visible sooner.

The report receiver does not create the case (ADR-0041), so it holds the case only after the CASE_MANAGER's Create(VulnerabilityCase) arrives. A tree that acts on the case sooner has nothing to act on, even when the CASE_MANAGER shares its host.
Refines: PCR-01-003

A recipient can obtain what a message names. A sender does not assume that a recipient holds an object it was never sent. An object the recipient cannot be expected to hold is carried inline, or by a reference the recipient can dereference. Either form satisfies the protocol.

Requirements

ID Priority Requirement Related
AKM-02-001 MUST NOT An Actor MUST NOT assume that a recipient has knowledge of any object that has not been explicitly included in a prior activity sent to that recipient.

A recipient holds only what it has been sent. An activity that relies on an object the recipient never received cannot be processed, or is processed against a guess, so a sender must reason from what it has actually delivered to that recipient.
AKM-02-002 MUST NOT Actors MUST NOT name an object the recipient cannot be expected to hold already by a reference the recipient cannot dereference (AKM-05-003, AKM-05-004). Such an object is carried inline, or by a reference the recipient can fetch.

A reference the recipient can neither match to an object it holds nor fetch leaves it unable to read what the activity acts on, so it must refuse the activity or guess. Carrying such an object inline, or by a reference the recipient can fetch, keeps every activity processable by its addressee.
Uses definition from: AKM-05-003
See also: AKM-05-004 — context for the reader

4.3 Object Types

An activity's meaning depends on what it acts on, so the object types matter as much as the verbs. Vultron extends the ActivityStreams 2.0 (AS2) vocabulary with the object types a vulnerability case needs, and they are not a flat set. A case contains participants, reports, status records, embargoes and an ordered ledger, as the diagram below shows. That containment is the model the rest of this specification assumes.

---
title: Vultron object containment
---
classDiagram
    VulnerabilityCase "1" *-- "1..*" CaseParticipant
    VulnerabilityCase "1" *-- "0..*" VulnerabilityReport
    VulnerabilityCase "1" *-- "1" CaseStatus
    VulnerabilityCase "1" *-- "0..*" CaseLedgerEntry
    VulnerabilityCase "1" *-- "0..*" EmbargoEvent
    VulnerabilityCase "1" *-- "0..*" Note
    CaseParticipant "1" *-- "0..*" ParticipantStatus
    CaseParticipant "1" o-- "0..*" CaseParticipantRole
    CaseParticipant "1" *-- "0..*" EmbargoConsent
    EmbargoConsent ..> EmbargoEvent : consents to
    CaseProposal ..> VulnerabilityCase : requests creation of
Object What it is
VulnerabilityCase The case itself: the container for everything below
CasePreview The case's preview: a minimal description of a case, carrying enough for an invited actor to decide whether to join and no vulnerability detail, sent as the preview of the case reference a stub Invite carries as its object
VulnerabilityReport A report of the vulnerability, such as the one that started the case
CaseParticipant An actor's membership in a case, carrying the roles it holds and the state it owns
CaseParticipantRole A role offered to an actor in the context of a case. It is a distinct type so that offering a role is structurally different from offering ownership of the case
EmbargoEvent An embargo's terms: its start and end times. It is a Vultron extension of the AS2 Event type, which is why embargo messages are invitations to an event rather than an embargo-specific verb
EmbargoConsent One participant's consent to one embargo, held on that participant's record (§9 Participant Embargo Consent (PEC) State Machine)
CaseLedgerEntry One entry in the canonical case ledger (§2.3 Protocol Objects and Messages)
CaseProposal A request that some actor create and manage a case. The requesting actor does not intend to manage the case itself, and the actor that accepts becomes the case's creator
CaseStatus / ParticipantStatus Status records: a ParticipantStatus is one participant's claim, and a CaseStatus is the case's canonical status, which only the CASE_MANAGER writes (§10.5 Claims and Canonical Status)
ProcessingFault A receiver's report that it could not process a message (§4.11 Faults and Acknowledgments)
Note The AS2 Note type, used unchanged for narrative posted to the case

An embargo is sent as type: EmbargoEvent. A sender gives an embargo the type value EmbargoEvent, not the plain AS2 Event it extends, and the occasion tables name it that way (Wire Activity Notation).

4.4 Message Tables

Each message subsection below includes its group of the occasion table, generated from the reference implementation's registry of wire activities (Message Types). Each row is one occasion, and its columns say:

Column Says
When… The sender's situation
Send The wire activity that conveys it
Send to The addressee: the CASE_MANAGER, a participant, or, before a case exists, an actor outside any case
Sent by The standing a receiver requires of the sender
Distinguished by What tells this occasion apart from another occasion that shares its wire activity and addressee
Details The occasion's section in the message reference, named by its protocol shorthand where it has one

"The CASE_MANAGER" in a table is the participant that holds the CASE_MANAGER role for the case, whichever actor that is (§10 Case Coordination). A row whose "Sent by" reads "internal to the CASE_MANAGER" is an act the CASE_MANAGER performs on its own case. No receiver handles such an activity, though the CASE_MANAGER may commit it to the case ledger.

4.5 Report Management Messages

These messages concern one participant's handling of a report. Each reports a change to the sender's report management state (§6 Report Management (RM) State Machine).

When… Send Send to Sent by Distinguished by Details
a Reporter has written up a vulnerability and is about to submit the report Create(VulnerabilityReport) an actor outside any case any actor (usually: reporter) — Create report
a Reporter submits a vulnerability report to a Vendor or Coordinator Offer(VulnerabilityReport) an actor outside any case any actor (usually: reporter) — Report Submission (RS)
a report receiver has received a submitted report Read(Offer(VulnerabilityReport)) an actor outside any case the addressee of the vulnerability report offer (usually: vendor, coordinator) — Report Acknowledgment (RK)
a report receiver judges the report valid Accept(Offer(VulnerabilityReport)) the CASE_MANAGER a participant (usually: vendor, coordinator) — Validate report
a report receiver judges the report invalid TentativeReject(Offer(VulnerabilityReport)) the CASE_MANAGER a participant (usually: vendor, coordinator) — Invalidate report
a report receiver closes a report no case holds Reject(Offer(VulnerabilityReport)) an actor outside any case the addressee of the vulnerability report offer (usually: vendor, coordinator) — Close report
a Participant accepts the case for further action Join(VulnerabilityCase) the CASE_MANAGER a participant — Report/Case Accepted (RA)
a Participant defers further action on the case Ignore(VulnerabilityCase) the CASE_MANAGER a participant — Report/Case Deferred (RD)

Only Report Submission (RS) drives a state change in its receiver: receiving a report moves the receiver to Received. The other messages tell the receiver something about the sender and leave the receiver's own state alone. A participant that joined the case by invitation never saw the report offer, so it reports Report Valid (RV), Report Invalid (RI) or Report Closed (RC) by answering the full-case Invite (§4.7 Case and Participant Messages).

RK acknowledges the submission, not the reading

Report Acknowledgment (RK) reports that the submission arrived. It does not report that the recipient has read the report, assessed it, or agreed to work on it: those are RV, RI, Report/Case Accepted (RA) and Report/Case Deferred (RD).

The protocol defines no message meaning "I have read the report". RK carries no report management state, so it tells the reporter nothing about whether the recipient has examined the content.

Requirements

ID Priority Requirement Related
RMB-08-003 MUST An actor that an Offer(VulnerabilityReport) was addressed to MUST send the RK that acknowledges it to the reporter, the Offer's actor. It may send the RK at any time after it receives the report, whether or not a case exists for it.

The reporter checks who may acknowledge its Offer against its own record of that Offer (RMB-08-004). The store of each addressee also holds a record. RK answers the reporter's Offer and is outside the case, so it is the stated exception to PCR-08-001 and to the routing topology of VP-18-001, VP-18-002 and VP-18-003.

ECA Details

Steps

1. [receiver of the report] Emit RK addressed to the Offer's actor → RK queued for the reporter only

Postconditions

- The reporter holds the RK

Refines: VP-03-009 — RK acknowledging RS
Supersedes: PCR-08-001 — the stated RK exception to CASE_MANAGER-only addressing
Supersedes: VP-18-001 — the stated RK exception to the CASE_MANAGER routing path
Supersedes: VP-18-002 — the stated RK exception to the no-direct-delivery rule
Supersedes: VP-18-003 — the stated RK exception to CASE_MANAGER-mediated delivery
RMB-08-005 MUST NOT An actor MUST NOT send an RK that acknowledges a report submission to the CASE_MANAGER.

The CASE_MANAGER has no record of the addressees of the Offer, so it cannot check an RK that it receives (RMB-08-004). An RK sent to it can also reach parties that did not receive the report.

ECA Details

Postconditions

- The CASE_MANAGER received no RK

Extends: RMB-08-003
RMB-08-006 MUST NOT A receiver of an RK that acknowledges a report submission MUST NOT forward it.

RK answers the reporter's Offer outside the case. A forwarded RK can reach parties that did not receive the report.

ECA Details

Steps

1. [any receiver of RK] Record the RK at intake → No RK forwarded

Extends: RMB-08-003
RMB-08-007 MUST NOT An actor MUST NOT write a case ledger entry for an RK that acknowledges a report submission.

RK is outside the case, so it is not a case event. A ledgered RK would also replicate to parties that did not receive the report.

ECA Details

Steps

1. [any receiver of RK] Record the RK at intake → No ledger entry written

Extends: RMB-08-003
VP-03-009 SHOULD Recipients SHOULD acknowledge the \(R*\) messages they receive, other than \(RK\) itself. \(RK\) acknowledges only \(RS\): an addressee of the report's Offer sends it to the reporter (RMB-08-003). No other \(R*\) message is acknowledged with \(RK\); once a case exists, its acknowledgment is the CASE_MANAGER's ledger entry for it, fanned out to the participants.

Before a case exists there is no ledger, so the reporter learns that its report arrived only from an \(RK\) (RMB-08-003). Once a case exists, every \(R*\) message goes to the CASE_MANAGER (PCR-08-001), and the ledger entry it commits already tells every participant the message was received; a separate \(RK\) would only add traffic and a second acknowledgment that could disagree with the ledger.

4.6 Case Proposal Messages

A report receiver that does not intend to manage a case itself asks a Case Actor Service to open one. This exchange happens before the case exists, so its messages go to an actor outside any case.

When… Send Send to Sent by Distinguished by Details
a report receiver asks a Case Actor Service to open a case for a report Create(CaseProposal) an actor outside any case the case proposal's author (usually: vendor, coordinator) — Create case proposal
a Case Actor Service agrees to open the proposed case Accept(CaseProposal) an actor outside any case the addressee of the case proposal — Accept case proposal
a Case Actor Service declines to open the proposed case Reject(CaseProposal) an actor outside any case the addressee of the case proposal — Reject case proposal

4.7 Case and Participant Messages

These messages create a case and manage who is in it. Most have no protocol shorthand, because they concern the case as an object rather than any state machine's state. The exception is the answer to the full-case Invite, which realizes RV, RI or RC, as described below. How a participant joins, changes role and leaves is specified at §12 Participant Lifecycle Within a Case.

When… Send Send to Sent by Distinguished by Details
the CASE_MANAGER has opened a case for a submitted report Create(VulnerabilityCase) a participant the addressee of the case proposal or vulnerability report offer — Create case
the Case Owner links a further report to an existing case Add(VulnerabilityReport)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner — Add report to case
the CASE_MANAGER records the new Case Owner once a case ownership transfer is accepted Update(VulnerabilityCase) a participant internal to the CASE_MANAGER — Update Case Owner
the CASE_MANAGER brings a vulnerability item into a case, such as one a new case takes from its CSAF report Add(VulnerabilityItem)[target=VulnerabilityCase] a participant internal to the CASE_MANAGER — Add vulnerability item to case
the CASE_MANAGER brings a case reference into a case, such as one a new case takes from its CSAF report Add(CaseReference)[target=VulnerabilityCase] a participant internal to the CASE_MANAGER — Add case reference to case
the Case Owner offers a CVD role on the case to another participant Offer(CaseParticipantRole)[context=VulnerabilityCase] the CASE_MANAGER the Case Owner — Offer case participant role
a participant accepts a role offered to it on the case Accept(Offer(CaseParticipantRole)[context=VulnerabilityCase]) the CASE_MANAGER the addressee of the case participant role offer — Accept case participant role
a participant declines a role offered to it on the case Reject(Offer(CaseParticipantRole)[context=VulnerabilityCase]) the CASE_MANAGER the addressee of the case participant role offer — Reject case participant role
the Case Owner proposes to transfer ownership of the case to another participant Offer(Offer(VulnerabilityCase)) the CASE_MANAGER the Case Owner — Propose case ownership transfer
the CASE_MANAGER offers the case to the actor the Case Owner proposed Offer(VulnerabilityCase) a participant the CASE_MANAGER — Offer case ownership transfer
an actor accepts an offer of case ownership Accept(Offer(VulnerabilityCase)) the CASE_MANAGER the addressee of the vulnerability case offer — Accept case ownership transfer
an actor declines an offer of case ownership Reject(Offer(VulnerabilityCase)) the CASE_MANAGER the addressee of the vulnerability case offer — Reject case ownership transfer
the Case Owner withdraws its proposal while the offer of case ownership is open Undo(Offer(Offer(VulnerabilityCase))) the CASE_MANAGER the Case Owner — Withdraw case ownership transfer
the CASE_MANAGER invites an actor to join the case Invite(VulnerabilityCase preview)[target=Actor] a participant the CASE_MANAGER — Invite actor to case
an invited actor agrees to join the case Accept(Invite(VulnerabilityCase preview)[target=Actor]) the CASE_MANAGER the invitee — Accept invite to case
an invited actor declines to join the case Reject(Invite(VulnerabilityCase preview)[target=Actor]) the CASE_MANAGER the invitee — Reject invite to case
the CASE_MANAGER has replayed the case ledger to a newly joined Participant Invite(whole VulnerabilityCase)[target=Actor] a participant the CASE_MANAGER — Send Full-Case Invite
a Participant asked by a Full-Case Invite judges the case valid Accept(Invite(whole VulnerabilityCase)[target=Actor]) the CASE_MANAGER the invitee — Accept Full-Case Invite
a Participant asked by a Full-Case Invite judges the case invalid TentativeReject(Invite(whole VulnerabilityCase)[target=Actor]) the CASE_MANAGER the invitee — Tentatively reject Full-Case Invite
a Participant asked by a Full-Case Invite closes the case Reject(Invite(whole VulnerabilityCase)[target=Actor]) the CASE_MANAGER the invitee — Reject Full-Case Invite
the CASE_MANAGER has admitted a new Participant to the case Announce(VulnerabilityCase) a participant the CASE_MANAGER — Announce vulnerability case
a Participant ends its participation in the case Leave(VulnerabilityCase) the CASE_MANAGER the Case Owner or a participant — Close case
the Case Owner reinstates a removed Participant Add(CaseParticipant)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner — Add case participant to case
the Case Owner removes a Participant from active participation Remove(CaseParticipant)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner — Remove case participant from case
the CASE_MANAGER creates a participant record, such as the inert record for the invitee of a stub Invite Create(CaseParticipant) a participant internal to the CASE_MANAGER — Create case participant
the CASE_MANAGER changes a participant record, such as moving the CASE_OWNER role on an ownership transfer Update(CaseParticipant) a participant internal to the CASE_MANAGER — Update case participant

The two ways an actor joins a case are different messages. Conflating them loses a round trip in which the Case Owner decides:

  • Invite(VulnerabilityCase preview)[target=Actor] is the CASE_MANAGER inviting an actor to join on the Case Owner's behalf. It is answered with Accept or Reject.
  • Offer(Actor)[target=VulnerabilityCase] is a participant recommending an actor (§4.10 General Messages). It goes to the CASE_MANAGER, which passes it to the Case Owner as an Offer(CaseParticipant). The Case Owner decides on it, and its approval may cause an Invite to be sent. It is not an invitation to the recommended actor.

Both paths end in an Accept of the stub Invite (§12.2 Invitation and Acceptance). That Accept joins the case; it is not RV. The joined participant judges the case by answering the full-case Invite, Invite(whole VulnerabilityCase)[target=Actor], and that answer is RV, RI or RC.

Requirements

ID Priority Requirement Related
CM-16-001 MUST A participant wishing to suggest that another actor be invited to the case MUST send Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER's inbox, not directly to the Case Owner's inbox.

All case-scoped protocol messages MUST route through the CASE_MANAGER so the event can be recorded in the canonical case ledger before any downstream action is taken (ADR-0021, PCR-08-001).
Refines: PCR-08-001
CM-16-004 MUST The CASE_MANAGER MUST transform the received Offer(Actor) into Offer(CaseParticipant)[target=VulnerabilityCase], whose CaseParticipant has attributed_to set to the actor and case_roles set to the roles, and send it to the Case Owner's inbox, with inReplyTo set to the ID of the original recommender's Offer activity and no origin.

The Case Owner makes a membership decision about a CaseParticipant (actor + roles), not about a bare Actor identity. The forward answers the recommender's Offer, and AS2 inReplyTo names the entities an object responds to, so it preserves the causal chain without a side-channel data store. origin names where an object comes from or leaves, so it is not the link to an answered activity.
CM-11-011 MUST The CASE_MANAGER MUST record each full-case Invite reply as a move from RM.RECEIVED: RV Accept to RM.VALID, RI TentativeReject to RM.INVALID, RC Reject to RM.CLOSED.

Each reply is the participant's own judgement of the case (ADR-0121). The three replies map to the three RM triage outcomes, so every replica records the judgement the participant made.
CM-11-034 MUST A reply to the full-case Invite MUST carry the replier's own ledger position: the log_index and entry_hash of its tail when it decided.

The position is the reply's ledgerPosition, the property every case activity carries (VAM-04-012..014, SYNC-18-001, ADR-0156), so the CASE_MANAGER judges it against the Invite's floor (CM-11-012) from the one field it reads on every case activity.
Extends: CM-11-011
CM-11-020 MUST NOT A participant that joined a case through an Invite MUST NOT send Accept, TentativeReject or Reject of the original Offer(VulnerabilityReport).

A reply must answer a message sent to the replier. A joined participant was never offered that report.
CM-11-051 MUST NOT A participant that joined a case through an Invite MUST NOT validate, invalidate or reject the case's report. It judges the case by replying to the full-case Invite (CM-11-011).

A joined participant — a late joiner especially — judges the case as it stands, with its history, not the original submission, which may have been far sparser (ADR-0121).
Extends: CM-11-020
See also: CM-11-011 — context for the reader

4.8 Embargo Management Messages

These messages negotiate the case's embargo (§7 Embargo Management (EM) State Machine). A participant proposes or answers terms by writing to the CASE_MANAGER, which asks each other participant about a proposal, and the Case Owner decides whether a proposal takes effect.

When… Send Send to Sent by Distinguished by Details
the Case Owner terminates the active embargo Remove(EmbargoEvent) the CASE_MANAGER the CASE_MANAGER or the Case Owner — Embargo Termination (ET)
the CASE_MANAGER ends the active embargo, on its own decision or on the Case Owner's Remove(EmbargoEvent) a participant the CASE_MANAGER — Tell a participant the embargo has ended
the CASE_MANAGER states the terms of the embargo in force Announce(EmbargoEvent)[context=VulnerabilityCase] a participant the CASE_MANAGER register status of the named embargo ACTIVE Announce embargo
the CASE_MANAGER has applied an Embargo Termination a Case Owner sent before the end time Announce(EmbargoEvent)[context=VulnerabilityCase] a participant the CASE_MANAGER register status of the named embargo TERMINATED Announce embargo termination
a Participant proposes embargo terms for a case with no active embargo Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or an active participant EM state NONE or PROPOSED Embargo Proposal (EP)
a Participant proposes revised terms for the active embargo Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or an active participant EM state ACTIVE or REVISE Embargo Revision Proposal (EV)
the CASE_MANAGER asks a Participant to answer embargo terms another Participant proposed Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase] a participant the CASE_MANAGER — Ask a participant about proposed embargo terms
a Participant agrees to proposed embargo terms Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) the CASE_MANAGER the invitee EM state PROPOSED Agree to proposed embargo terms
a Participant agrees to a proposed embargo revision Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) the CASE_MANAGER the invitee EM state REVISE Agree to an embargo revision
a Participant refuses proposed embargo terms Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) the CASE_MANAGER the invitee EM state PROPOSED Refuse proposed embargo terms
a Participant refuses a proposed embargo revision Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) the CASE_MANAGER the invitee EM state REVISE Refuse an embargo revision
the CASE_MANAGER abandons an open embargo proposal it received once the case is public, an exploit is public or attacks are observed Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) a participant the CASE_MANAGER — Abandon embargo proposal
the CASE_MANAGER abandons an open embargo proposal once the case is public, an exploit is public or attacks are observed Undo(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) a participant internal to the CASE_MANAGER — Withdraw an embargo invitation
the Case Owner decides to activate a proposed embargo for a case with no active embargo Add(EmbargoEvent)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner EM state PROPOSED Embargo Proposal Acceptance (EA)
the Case Owner decides to replace the active embargo with a proposed revision Add(EmbargoEvent)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner EM state REVISE Embargo Revision Acceptance (EC)
the Case Owner decides to reject a proposed embargo for a case with no active embargo Reject(EmbargoEvent)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner EM state PROPOSED Reject embargo proposal
the Case Owner decides to reject a proposed revision Reject(EmbargoEvent)[target=VulnerabilityCase] the CASE_MANAGER the Case Owner EM state REVISE Embargo Revision Rejection (EJ)
a Participant bound by the active embargo stops complying with it Leave(EmbargoEvent)[context=VulnerabilityCase] the CASE_MANAGER a participant — Withdraw from embargo
the CASE_MANAGER has created a case and, with it, an embargo such as the default embargo Create(EmbargoEvent) a participant internal to the CASE_MANAGER — Create embargo event
the CASE_MANAGER creates a participant's consent row for an embargo, such as the UNINVITED row a proposal writes Create(EmbargoConsent) a participant internal to the CASE_MANAGER — Create embargo consent
the CASE_MANAGER changes a participant's consent row, such as an invitation timing out, the rows carried over at activation or a change of its own consent Update(EmbargoConsent) a participant internal to the CASE_MANAGER — Update embargo consent

A revision proposal and an initial proposal are the same activity

Embargo Revision Proposal (EV), Embargo Revision Rejection (EJ) and Embargo Revision Acceptance (EC) share their wire activities with Embargo Proposal (EP), Embargo Proposal Rejection (ER) and Embargo Proposal Acceptance (EA). The activity does not encode the difference. EA and EC are both the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase], which adds the embargo to the case, and ER and EJ are both its Reject(EmbargoEvent)[target=VulnerabilityCase]. Each of the four names the Invite(EmbargoEvent) that proposed the embargo in inReplyTo. ER is also the CASE_MANAGER's Reject(Invite(EmbargoEvent)) that abandons a proposal. A participant's Accept or Reject of the Invite it was sent is its own consent, carries no shorthand, and moves no embargo state (MSM-02-010).

A receiver tells which it has received from its own embargo state, as the "Distinguished by" column states. If the case embargo is Active or Revise, an arriving proposal is a revision. If it is None or Proposed, the same message is an initial proposal.

The outcome of a rejection differs between the two: rejecting an initial proposal leaves the case with no embargo, while rejecting a revision leaves the agreed terms in force (§7.2 Transitions and Guards). An implementation that treats the activity as self-describing will mishandle every revision. Because a mishandled revision rejection returns the case to None, it silently drops embargoes that every participant still believes are in force.

Requirements

ID Priority Requirement Related
EMB-01-001 MUST A Participant in EM None (q^em ∈ N) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EP MUST transition their EM state to Proposed (q^em N → P). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009).

EP is the EM message that initiates embargo negotiation. When no embargo exists and the case is still pre-public, the receiver transitions to Proposed to signal they are evaluating the proposal.

ECA Details

Preconditions

- EM state is None; CS matches pattern ...pxa
- EM state: NONE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from NONE to PROPOSED → Receiver EM state is PROPOSED
2. [receiver] CASE_MANAGER commits the received EP and adds the entry to the ledger (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is PROPOSED; EK discharged by the ledger commit

Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
Uses definition from: EP-09-009
EMB-03-001 MUST A Participant in EM Active (q^em ∈ A) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EV MUST transition their EM state to Revise (q^em A → R). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

A participant must know that a change to the embargo is open while the current terms still bind it. Revise records both facts: an embargo is in force, and a revision of it waits for an answer. If the receiver stayed in Active, it could not tell that a later EC or EJ decides a revision. The revision does not change any participant's consent to the embargo in force until the Case Owner activates it (EP-05-002).

ECA Details

Preconditions

- EM state is Active; CS matches pattern ...pxa
- EM state: ACTIVE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from ACTIVE to REVISE → Receiver EM state is REVISE
2. [receiver] CASE_MANAGER commits the received EV and fans out its entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is REVISE; original embargo remains in force; EK discharged by the ledger commit

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader

Choosing between EV and ET. Embargo Termination (ET) takes effect immediately. A sender that wants the embargo to end at some future point proposes that end date with EV instead.

Requirements

ID Priority Requirement Related
VP-11-008 SHOULD If early embargo termination is desired but the termination date/time is in the future, this SHOULD be achieved through an Embargo Revision Proposal and additional communication

Participants must keep the existing terms until the new end time arrives. A revision proposal changes the end time through the usual agreement process, rather than leaving participants unsure whether the embargo still holds.

Tacit acceptance of a default embargo. Submitting a report without proposing terms accepts the receiver's default embargo policy (§7.2 Transitions and Guards). Where the receiver has published no default, the same section specifies a short protocol default, so an embargo-eligible case never begins without an embargo.

4.9 Case State Messages

These messages report facts about the vulnerability (§8 Case State (CS) Dimensions). A participant reports them as a claim in a ParticipantStatus, and the CASE_MANAGER records the facts it adopts about the world in a CaseStatus.

When… Send Send to Sent by Distinguished by Details
the CASE_MANAGER records that the public knows of the vulnerability Add(CaseStatus)[target=OrderedCollection, context=VulnerabilityCase] a participant the CASE_MANAGER pxaState = Pxa Public awareness in a case status
the CASE_MANAGER records that an exploit for the vulnerability is public Add(CaseStatus)[target=OrderedCollection, context=VulnerabilityCase] a participant the CASE_MANAGER pxaState = PXa Exploit public in a case status
the CASE_MANAGER records that attackers are exploiting the vulnerability Add(CaseStatus)[target=OrderedCollection, context=VulnerabilityCase] a participant the CASE_MANAGER pxaState = pxA Attacks observed in a case status
a Vendor becomes aware of the vulnerability Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or the Case Owner or the participant status's author (usually: vendor) vfState = Vf Vendor Awareness (CV)
a Vendor has a fix ready Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or the Case Owner or the participant status's author (usually: vendor) vfState = VF Fix Readiness (CF)
a Deployer has deployed the fix Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or the Case Owner or the participant status's author (usually: deployer) dState = D Fix Deployed (CD)
a Participant learns that the public knows of the vulnerability Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or the Case Owner or the participant status's author caseStatus.pxaState = Pxa Public awareness in a participant status
a Participant learns that an exploit for the vulnerability is public Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or the Case Owner or the participant status's author caseStatus.pxaState = PXa Exploit public in a participant status
a Participant observes attacks that exploit the vulnerability Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase] the CASE_MANAGER the CASE_MANAGER or the Case Owner or the participant status's author caseStatus.pxaState = pxA Attacks observed in a participant status

Several case state occasions share one activity

Every claim a participant makes, whichever fact it reports, is Add(ParticipantStatus, target=<participant>/statuses). Every fact the CASE_MANAGER records about the world is Add(CaseStatus, target=<case>/statuses). The fact travels in the status record's fields, as the "Distinguished by" column states, so an implementation that dispatches on the activity alone cannot tell Fix Readiness (CF) from Attacks Observed (CA).

The two activities differ by the sender's authority, not by the fact. Only the CASE_MANAGER sends Add(CaseStatus) (§10.5 Claims and Canonical Status).

Requirements

ID Priority Requirement Related
RSH-04-001 MUST NOT An actor that is not the CASE_MANAGER MUST NOT emit Add(CaseStatus).

CaseStatus encodes shared EM and PXA state for the entire case. The CASE_MANAGER is the authoritative writer of canonical case state (ADR-0210, CLP-09). Allowing participants to emit Add(CaseStatus) directly would bypass the adoption authorization model.
RSH-04-007 MUST A participant that is not the CASE_MANAGER MUST report the CaseStatus it suggests by embedding it in its own Add(ParticipantStatus).

A participant cannot send Add(CaseStatus) (RSH-04-001), but its view of P, X or A still needs to reach the case. Embedding it in the participant's own status puts it through the adoption gate (RSH-01-003).
Extends: RSH-04-001
RSH-04-005 MUST A receiver MUST refuse a received Add(CaseStatus) unless the case's CASE_MANAGER sent it to a participant.

RSH-04-001 reserves Add(CaseStatus) for the CASE_MANAGER, which sends it to participants inside a case ledger entry. add_case_status_tree has no StatusAdoptionGate, so admitting it from another sender would adopt that participant's P, X or A report without the Case Owner approval RSH-07-001 requires. A participant embeds the P, X or A it reports in its own Add(ParticipantStatus) instead (RSH-04-007), which the CASE_MANAGER adopts through the gate (RSH-01-003).
Derives from: RSH-04-001
Refines: HP-01-006
RSH-04-012 MUST When a receiver refuses an Add(CaseStatus) under RSH-04-005, it MUST write nothing past intake and send nothing.

A refused status is one the receiver must not act on. A write past intake would change case state on the refused claim, and a reply would answer a sender that had no right to send it.
Extends: RSH-04-005

The Vendor aware, Fix ready, fix Deployed (VFD) occasions report the sender's own progress, so receiving one updates the receiver's model of the sender rather than the receiver's own state (§8.4 Receiving CS Messages: Own State vs. Model of Others). The Public aware, eXploit public, Attacks observed (PXA) occasions in a ParticipantStatus report a claim about the world. That claim becomes canonical case state only if the CASE_MANAGER adopts it (§11.3 Status Adoption: One Authorization Gate).

4.10 General Messages

These messages carry narrative and actor suggestions. Together they realize the formal General Inquiry (GI), which spans two exchanges:

  • the note lifecycle, Add(Note)[target=VulnerabilityCase] and Remove(Note)[origin=VulnerabilityCase];
  • the actor-suggestion exchange, in which a participant suggests an actor, the CASE_MANAGER presents the suggestion to the Case Owner, and the CASE_MANAGER tells the recommender the Case Owner's decision.
When… Send Send to Sent by Distinguished by Details
a Participant suggests an actor that the case should include Offer(Actor)[target=VulnerabilityCase] the CASE_MANAGER a participant sender is not the Case Owner Suggest actor to case
the Case Owner decides to invite an actor to the case Offer(Actor)[target=VulnerabilityCase] the CASE_MANAGER a participant sender is the Case Owner Ask the CASE_MANAGER to invite an actor
the CASE_MANAGER presents a suggested actor to the Case Owner Offer(CaseParticipant)[target=VulnerabilityCase] a participant the CASE_MANAGER — Offer case participant
the Case Owner approves a suggested actor Accept(Offer(CaseParticipant)[target=VulnerabilityCase]) the CASE_MANAGER the Case Owner — Accept case participant offer
the Case Owner declines a suggested actor Reject(Offer(CaseParticipant)[target=VulnerabilityCase]) the CASE_MANAGER the Case Owner — Reject case participant offer
the CASE_MANAGER tells a recommender that the actor it suggested will be invited Accept(Offer(Actor)[target=VulnerabilityCase]) a participant the CASE_MANAGER — Accept actor recommendation
the CASE_MANAGER tells a recommender that the Case Owner declined the actor it suggested Reject(Offer(Actor)[target=VulnerabilityCase]) a participant the CASE_MANAGER — Reject actor recommendation
a Participant posts a note to the case Add(Note)[target=VulnerabilityCase] the CASE_MANAGER an active participant — Add note to case
a note's author or the Case Owner withdraws a note from the case Remove(Note)[origin=VulnerabilityCase] the CASE_MANAGER the Case Owner or the note's author — Remove note from case

A received Create(Note) is not a protocol message, and its receiver does not change the case because of it. General Acknowledgment (GK) and General Error (GE) have no wire activity of their own; the mechanisms of §4.11 Faults and Acknowledgments serve their purposes.

Requirements

ID Priority Requirement Related
VAM-01-011 MUST Each of these case records MUST enter a case only by its one attaching message, which carries it inline or by reference. A CaseStatus enters by the Add(CaseStatus) that attaches it (VAM-08-002). A ParticipantStatus enters by the Add(ParticipantStatus) that attaches it (VAM-08-004). A proposed EmbargoEvent enters by the Invite that proposes it (VAM-05-005). A Note enters by the Add(Note) that attaches it (VAM-07-002).

These records mean nothing apart from their case, so a separate Create would add a "created but not attached" state needing its own ledger entry and replica step (CLP-07-013, RSH-08-004) for no gain (ADR-0137). A Create(Note), with or without a case context, is a deferred form recorded as an open question (MS-18-001). These records get one attaching message each. The Create a CASE_MANAGER ledger entry carries as its payload snapshot records a change; it is not a received message.
Constrains: VAM-08-002 — the Add(CaseStatus) is the only way a case status enters a case
Constrains: VAM-08-004 — the Add(ParticipantStatus) is the only way a participant status enters a case
Constrains: VAM-05-005 — the Invite is the only way a proposed embargo event enters a case
Constrains: VAM-07-002 — the Add(Note) is the only way a note enters a case
VAM-01-019 MUST NOT A received Create whose object is a CaseStatus, a ParticipantStatus, an EmbargoEvent, a CaseParticipant or a Note is not a protocol message. Its receiver MUST NOT change the case file because of it.

Each of these records enters a case only by its attaching message (VAM-01-011) or as the CASE_MANAGER's consequence of an act it records (VAM-01-020). A separate Create would add a "created but not attached" state needing its own ledger entry and replica step (CLP-07-013, RSH-08-004) for no gain (ADR-0137).
Derives from: VAM-01-011
VAM-01-020 MUST A CaseParticipant MUST come into existence only as the CASE_MANAGER's consequence of an act that it records.

A participant record means nothing apart from its case, and the CASE_MANAGER records each act that changes the case. A participant made any other way would be a case-file change outside the ledger (CLP-07-013, ADR-0137).

4.11 Faults and Acknowledgments

The formal message set defines an acknowledgment and an error message for each of its four groups: RK, EK, CK and GK, and RE, EE, CE and GE. Their status here is not uniform: the groups are not symmetric.

Of the eight, only RK has a wire activity, Read(Offer(VulnerabilityReport)) (§4.5 Report Management Messages). The other seven have none. None of the seven arrives as a message of its own, so a participant that waits for one waits forever.

The absences have two different reasons.

EK, CK and GK are redundant. Changes to a case are replicated through the case ledger, and a participant shows that it received them by holding an unbroken hash chain (§4.12 Ledger Replication Messages). A per-message acknowledgment would restate what the chain already shows. RK survives because report submission happens before the case exists, so there is no ledger to carry it.

Requirements

ID Priority Requirement Related
EP-09-009 MUST NOT The CASE_MANAGER's commit of a received embargo activity, fanned out as Add(CaseLedgerEntry), is the acknowledgement the EMB behavioural requirements express as "emit EK". Implementations MUST NOT define or emit an EK message to acknowledge an embargo activity.

No EK exists in the production stack and MSM-02-009 records that its purpose is served by ledger hash-chain continuity. Under the relay every accepted embargo activity is committed and announced, so the record the specs want the receiver to produce already exists; a second acknowledgement would be a message with no reader (#3918).
Refines: MSM-02-009

RE, EE, CE and GE are deliberately unmodeled, not merely unimplemented. The protocol does not type an error message by the state machine that produced it, because that grouping tells a receiver nothing it can act on. Knowing which machine was confused does not indicate what to do about it. Errors are grouped by failure mode instead, which is actionable:

Failure mode When it applies Wire activity What the sender can do
Not understood The message could not be parsed, or its meaning is unrecognized Create(ProcessingFault) Re-send, or send a simpler equivalent
Understood but declined The message was well-formed and meaningful, but the receiver will not act on it given the case's state Reject of the message being declined Reconsider; the state, not the message, is the obstacle
Needs explanation The condition cannot be expressed as a structured message and requires prose Add(Note)[target=VulnerabilityCase] Read the explanation; there is no automatic recovery

Requirements

ID Priority Requirement Related
MSM-05-001 MUST Fault reporting MUST be partitioned by failure mode rather than by state machine, using exactly three mechanisms: Create(ProcessingFault) when a message was received but not understood; as:Reject when a message was received and understood but declined; and Add(Note)[target=VulnerabilityCase] when the condition requires narrative explanation. A declined message gets a Reject when its addressee decides against it, and a Refuse, the vultron:Refuse subtype of as:Reject, when the CASE_MANAGER refuses it because a precondition did not hold.

Failure mode is actionable to a receiver in a way that originating state machine is not. Not-understood calls for a format or version fix, declined calls for a protocol-level decision, and needs-explanation calls for a human. A partition by state machine (RE, EE, CE and GE) carries no such signal, so it would tell the sender only where the fault arose, not what to do about it. A Refuse is a Reject, so it adds no fourth mechanism.
When… Send Send to Sent by Distinguished by Details
a Participant has received a message it cannot process Create(ProcessingFault) the CASE_MANAGER an active participant — Create processing fault
the CASE_MANAGER has refused a participant's assertion because a precondition did not hold Refuse(Activity) a participant the CASE_MANAGER — Refusal notice

An actor that cannot process an inbound activity from an authenticated sender notifies that sender with Create(ProcessingFault). It sends no fault to a sender that is not authenticated.

Requirements

ID Priority Requirement Related
ASK-07-001 MUST An actor that cannot process an inbound activity from an authenticated sender MUST notify that sender by emitting Create(ProcessingFault). The exception is an inbound Create(ProcessingFault), which ASK-07-019 leaves unanswered.

Without a notice, a failure that took milliseconds costs the sender its full ask deadline in silence.
ASK-07-002 MUST NOT An actor MUST NOT emit a processing fault in response to an inbound activity whose sender is not authenticated, or whose failure occurred before authentication.

Explaining a parse or validation failure to an unauthenticated sender is a parser oracle, and an unauthenticated sender identity cannot be trusted as a reply address.

Reject does not mean error

The Reject verb alone does not signal an error. Reject also carries legitimate protocol answers, including closing a report and declining an embargo invitation, a case invitation, a case proposal or a case ownership transfer.

Requirements

ID Priority Requirement Related
MSM-05-003 MUST NOT Implementations MUST NOT infer error semantics from the as:Reject verb alone, because as:Reject also carries legitimate protocol rejections, including closing a report and declining an embargo invitation, a case invitation, a case proposal or a case-ownership transfer.

as:Reject is overloaded across error reporting and ordinary protocol refusal. A receiver that treats every as:Reject as a fault will misclassify routine protocol traffic as errors.

Open question: what a sender does after a processing fault

Error message types (RE, EE, CE) are deliberately unmodeled (ADR-0049). An actor that cannot process an inbound activity from an authenticated sender reports it with Create(ProcessingFault) (ASK-07-001). The fault names the failed activity and a failure class, and its receiver rules are specified (§4.11 Faults and Acknowledgments, ASK-07). On the sending side, a fault about an outstanding ask closes that ask (ASK-07-007). A fault about an embargo message calls for an inquiry (VP-11-005), and so does a fault about a report-management or case-status message that does not say what went wrong (RMB-07-001, CSB-07-001).

Open: whether the sender resends the failed activity, drops it, or escalates to a person, and whether that choice depends on the failure class. Until this is settled, that choice belongs to each implementation.

4.12 Ledger Replication Messages

These messages keep every active participant's replica of the case ledger in step with the CASE_MANAGER's (§10.4 Ledger Replication and Case Delivery).

When… Send Send to Sent by Distinguished by Details
the CASE_MANAGER has committed a case event to the case ledger Add(CaseLedgerEntry) a participant the CASE_MANAGER — Add case ledger entry
a received ledger entry does not chain onto the Participant's own ledger Reject(CaseLedgerEntry) the CASE_MANAGER an active participant, including one that has left the case — Reject case ledger entry
a Participant checks that its ledger is current, such as after a restart, or holds a case but none of its entries Read(OrderedCollection)[context=VulnerabilityCase] the CASE_MANAGER a participant — Read case ledger

Acknowledgment of the ledger is cumulative and implicit. A participant whose local tail matches a received entry's previous-entry hash sends nothing, because the match is the acknowledgment. On a mismatch it sends Reject(CaseLedgerEntry), and the CASE_MANAGER replays every entry after the last one the participant accepted. A participant that wants to check its replica is current, after a restart for example, states its position with Read(<case>/ledger), a Read of the case's ledger stating the last entry it applied, and the CASE_MANAGER answers a lag the same way. Whenever a participant states a position, the CASE_MANAGER also resends each Invite that participant still owes an answer to, as first sent, so an Invite lost before the participant could answer it reaches it again.

Requirements

ID Priority Requirement Related
MSM-05-002 MUST Acknowledgement of replicated case-ledger state MUST be cumulative and implicit, through hash-chain continuity.

A matching prev_log_hash already proves receipt of every prior entry, so per-message positive acknowledgement would be redundant. This is negative acknowledgement with gap-fill replay, structurally closer to a cumulative ACK or SACK scheme than to the formal per-message EK, CK and GK design. RK remains a real wire activity (MSM-01-008) because report submission is not ledger-replicated.
MSM-05-007 MUST NOT A receiver whose prev_log_hash matches its local tail MUST NOT emit an acknowledgement.

The match already acknowledges every prior entry (MSM-05-002), so a positive acknowledgement would only add traffic.
Refines: MSM-05-002
MSM-05-008 MUST A receiver MUST emit Reject(CaseLedgerEntry) when an entry's prev_log_hash does not match its local tail. Its object is that entry and its inReplyTo the Add(CaseLedgerEntry) that carried it. The CASE_MANAGER then replays all entries after the last accepted hash.

The mismatch is the one event the sender cannot see for itself. The Reject names where the receiver's chain ends, so the replay fills the gap.
Extends: MSM-05-002
SYNC-17-001 MAY A participant MAY send the case's CASE_MANAGER Read(<case>/ledger), whose object is the case's ledger <case>/ledger, an OrderedCollection named by its id and type, whose context is the case and whose ledgerPosition is the participant's tail in that ledger. A participant that holds no entry for the case states the empty ledger's position, index -1 with the case's genesis hash.

ActivityStreams defines Read as the actor having read the object, so the activity states how far the sender has read the ledger. The CASE_MANAGER replays what follows, so a position behind its tail, or at -1, asks for a replay; one at its tail asks for nothing. A Reject(CaseLedgerEntry) would claim a refusal that did not happen, and naming the ledger rather than an entry gives every position, -1 included, one form with no bare object id (SE-01-006, ADR-0204).
SYNC-17-004 MUST When the stated position the CASE_MANAGER acts on (SYNC-17-002) is behind its tail, it MUST send the sender each later canonical entry, in log order. It sends them as Add(CaseLedgerEntry), under the replay rate bound (SYNC-15-003, SYNC-15-013) and outbox de-duplication (SYNC-15-012) of a Reject-triggered replay.

This is the retry that SYNC-00-008 requires. It runs whenever the participant reads, so a lost last entry is recovered without waiting for a new commit. A Read can predate entries already on their way to the sender, so a stated lag can be transient; the replay rate bound, not the outbox de-duplication, is what limits the replays such a race causes.
Implements: SYNC-00-008
Uses definition from: SYNC-15-003
Uses definition from: SYNC-15-012
Uses definition from: SYNC-15-013
See also: SYNC-17-002 — context for the reader
SYNC-17-010 MUST When the stated position the CASE_MANAGER acts on (SYNC-17-002) is its ledger tail, it MUST send nothing in answer.

A participant at the tail is missing nothing, so any entry sent would be a duplicate.
See also: SYNC-17-002 — context for the reader
SYNC-20-001 MUST When a participant on the case's roster that is not removed (CM-31-001) and whose closure is not recorded states a ledger position that names an entry in the CASE_MANAGER's ledger, in Read(<case>/ledger) (SYNC-17-001) or as an activity's ledgerPosition (SYNC-18-001), the CASE_MANAGER MUST resend each Invite that participant owes an answer to (SYNC-20-002), whether or not the participant is active (CM-10-004).

A position statement is the first sign that the replica holds the case, so a resent Invite can now be answered (ADR-0163). The resend is not an answer to the position, so it runs apart from SYNC-17-002 and SYNC-18-007: a joiner that lost its Invite to the embargo in force has not consented, so it is inert, and is the one to ask again. A resent Invite was already sent and is not case content (CM-10-007), so nothing withheld leaks.
Uses definition from: CM-10-004
Uses definition from: CM-31-001
Uses definition from: SYNC-17-001
Uses definition from: SYNC-18-001
Uses definition from: SYNC-20-002

4.13 Formal Message Set

The table below lists all 28 messages of the formal message set, each with the wire activities whose occasions carry it. It is generated from the same registry as the occasion tables above. A shorthand with no wire activity links to the section of the message reference that says why (§4.11 Faults and Acknowledgments).

Type Name Model Wire activity
RS Report Submission RM Offer(VulnerabilityReport)
RI Report Invalid RM TentativeReject(Offer(VulnerabilityReport)), TentativeReject(Invite(whole VulnerabilityCase)[target=Actor])
RV Report Valid RM Accept(Offer(VulnerabilityReport)), Accept(Invite(whole VulnerabilityCase)[target=Actor])
RD Report/Case Deferred RM Ignore(VulnerabilityCase)
RA Report/Case Accepted RM Join(VulnerabilityCase)
RC Report Closed RM Reject(Offer(VulnerabilityReport)), Reject(Invite(whole VulnerabilityCase)[target=Actor])
RK Report Acknowledgment RM Read(Offer(VulnerabilityReport))
RE Report Error RM none
EP Embargo Proposal EM Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]
ER Embargo Proposal Rejection EM Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]), Reject(EmbargoEvent)[target=VulnerabilityCase]
EA Embargo Proposal Acceptance EM Add(EmbargoEvent)[target=VulnerabilityCase]
EV Embargo Revision Proposal EM Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]
EJ Embargo Revision Rejection EM Reject(EmbargoEvent)[target=VulnerabilityCase]
EC Embargo Revision Acceptance EM Add(EmbargoEvent)[target=VulnerabilityCase]
ET Embargo Termination EM Remove(EmbargoEvent)
EK Embargo Acknowledgment EM none
EE Embargo Error EM none
CV Vendor Awareness CS Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase]
CF Fix Readiness CS Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase]
CD Fix Deployed CS Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase]
CP Public Awareness CS Add(CaseStatus)[target=OrderedCollection, context=VulnerabilityCase], Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase]
CX Exploit Public CS Add(CaseStatus)[target=OrderedCollection, context=VulnerabilityCase], Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase]
CA Attacks Observed CS Add(CaseStatus)[target=OrderedCollection, context=VulnerabilityCase], Add(ParticipantStatus)[target=OrderedCollection, context=VulnerabilityCase]
CK CS Acknowledgment CS none
CE CS Error CS none
GI General Inquiry General Offer(Actor)[target=VulnerabilityCase], Offer(CaseParticipant)[target=VulnerabilityCase], Accept(Offer(CaseParticipant)[target=VulnerabilityCase]), Reject(Offer(CaseParticipant)[target=VulnerabilityCase]), Accept(Offer(Actor)[target=VulnerabilityCase]), Reject(Offer(Actor)[target=VulnerabilityCase]), Add(Note)[target=VulnerabilityCase], Remove(Note)[origin=VulnerabilityCase]
GK General Acknowledgment General none
GE General Error General none

5. Encoding and Transport [N]

This section specifies how a Vultron message is encoded and delivered. Where §4 Messages says what to send in each situation and what a received message means, this section says what a message looks like on the wire and how it reaches its addressee.

Vultron does not define its own message syntax. It uses ActivityStreams 2.0 (AS2), a published World Wide Web Consortium (W3C) vocabulary for describing things that actors do, and extends it with the object types of §4.3 Object Types. Reusing an existing vocabulary means the outer envelope is already specified, already tooled, and already understood by readers who have met it elsewhere.

The consequence is that Vultron messages look generic. There is no ProposeEmbargo verb; there is an Invite whose object is an EmbargoEvent. Meaning comes from the combination of verb, object and the fields that tell occasions apart, which is what the occasion tables of §4 Messages record.

5.1 Base Vocabulary

Every Vultron message is an AS2 Activity: an object describing an action, with the actor who performed it and the thing it was performed on.

Every Activity carries these fields:

Field Contains
type The Activity type: the verb, such as Offer or Announce
actor The Uniform Resource Identifier (URI) of the actor that performed the action
object The thing acted on, inline or by reference (§5.2 Serialization)
id A URI uniquely identifying this Activity, used for deduplication (§16.3 Replay and Idempotency)
published The timestamp its sender stamps on the Activity

The fields that tell occasions apart, such as target and context, are the bracketed fields of the Wire Activity Notation. Vultron's own types are declared in the vocabulary namespace https://certcc.github.io/Vultron/ns. A Vultron type that refines an AS2 type is sent with that AS2 type too, as the list ["<Vultron type>", "<AS2 type>"], so an AS2 receiver that does not know the Vultron type still reads the AS2 type. A receiver reads a type list, in any order, as the most specific type it knows, and ignores a type name it does not know. It refuses a list that names two known types when neither is a subtype of the other, because it cannot tell which one the sender meant.

Requirements

ID Priority Requirement Related
VM-03-005 MUST A Vultron extension type can refine an ActivityStreams core type. A sender MUST write the type of such an extension as the list [extension type, core type], such as ["Refuse", "Reject"]. Inside the sender, the object still has only the extension type.

The ActivityStreams Core extensibility guidance asks an extension type that overlaps a core type to carry the core type too. A plain ActivityStreams receiver that does not know the extension then still reads the message as the core type. Code that handles the message needs only one type: a list in code would change every type check for no gain (ADR-0196).
VM-03-006 MUST A receiver MUST read a type list, in any order, as the most specific type it knows, and ignore each term it does not know.

ActivityStreams allows type to be a list, and VM-03-005 sends one. The most specific known type is the one the sender meant, and a term the receiver does not know is an extension it cannot read, so ["Foo", "Reject"] is a Reject (ADR-0196).
Extends: VM-03-005
Refines: MV-01-001
VM-03-007 MUST A receiver MUST refuse, as an unknown type, a received type list that names two known types when neither is a subtype of the other.

When two known types are unrelated, the receiver cannot tell which one the sender meant, so it must not choose one (ADR-0196).
Extends: VM-03-006

Every object an Activity embeds carries its own id too, at any depth, and a receiver refuses a message that embeds one without it. An object inside a case preview is the exception: the preview shows what its sender chose, so the receiver reads such an object as sent, with or without its id or published (MV-12-006). A Link, such as a Mention in tag, is not an object: it needs no id and names its resource by href.

Every whole object an Activity embeds, at any depth, also carries the published timestamp its author stamped on it, except an actor profile, a collection or an embargo consent row; a typed reference is not a whole object, and the case preview it may carry is a projection of the object it names. A receiver refuses a message that embeds one without it, and names where the object sits. An actor profile describes an actor and a collection is a container, so neither is an act made at a moment. A case preview is a projection of the case, and a consent row is copied without a time, so neither needs one. A typed reference, a URI and a Link are not whole objects, so they carry no time. updated stays optional, and a receiver carries it as sent.

Requirements

ID Priority Requirement Related
MV-01-001 MUST Incoming payloads MUST conform to ActivityStreams 2.0 structure

Vultron messages are ActivityStreams 2.0 activities. Thus a payload that is not a correct AS2 activity has no defined meaning for the receiver. When the parser refuses the payload, the malformed input does not get to semantic extraction or to the handlers. These stages can then rely on the AS2 structure.
OX-02-002 MUST Each outbox activity MUST conform to ActivityStreams 2.0 structure

Recipients are ActivityStreams 2.0 (AS2) and ActivityPub peers. A peer routes a body by its AS2 type, and it reads the terms of the body through @context. A body without that structure does not mean anything to the recipient.
OID-01-001 MUST All ActivityStreams object IDs MUST use full URI form

ActivityPub requires every object it distributes to carry a publicly dereferenceable URI as its identifier, which a relative or bare identifier is not. ActivityStreams 2.0 alone only says relative references SHOULD NOT be used. Vultron inherits the ActivityPub rule.
OID-01-013 MUST A receiver MUST refuse a received message that embeds an ActivityStreams Object without an id, at any depth. A Link carries no such requirement, and neither does an object inside a preview (MV-12-006).

ActivityPub requires every object it distributes to carry a unique global identifier. Its one exception, an intentionally transient object, does not fit case data that participants replicate and cite. OID-01-001 states the sender's side of that rule, and this states the receiver's. A Link is not an Object: AS2 names its resource by href.
Refines: OID-01-001
OID-01-014 MUST NOT A receiver MUST NOT mint an id for a received object or Link.

A minted id would present the receiver's own invention as the sender's object, and it would differ on every receiver of the same message. A received Link that omits its id keeps none. An object or Link this process builds is still given a minted id (OID-01-004).
Refines: OID-01-013
CLP-15-006 MUST A participant MUST include a published timestamp on every protocol activity it emits.

ActivityStreams makes published optional. Each check that reads the claimed time needs the sender's value (CLP-14-007, CLP-14-008), so a sender that omits it makes those checks impossible.
CLP-15-008 MUST A receiver MUST refuse at message validation, as malformed, an inbound activity that carries no published, never substituting its own clock for the missing value.

A receiver that fills in the field cannot later tell a time the sender claimed from one it made. Each check that reads the claimed time then compares the receiver's clock with itself and never fires (CLP-14-007, CLP-14-008). A receiver that creates its own outbound activity stamps its own clock, which is correct.
Extends: CLP-15-006
CLP-15-011 MUST A receiver MUST refuse at message validation an inbound activity that carries, at any depth, a whole object with no published, naming the object's position. An actor profile, a collection and an EmbargoConsent row are exempt. A typed reference (MV-10-011), a URI and a Link are not whole objects, and a preview a typed reference carries is a projection of the object it names (ADR-0205), so the rule reaches none of them, nor any object inside such a preview (MV-12-006).

A conformant sender states the time of every object it authors, so the rule refuses only malformed input. Refusing at the edge spares every reader of a received object's time a check of whether its type is one a decision needs, and lets core declare the time required (ADR-0032). An actor profile or a collection is not an act made at a moment, and many servers serve profiles without one. A case preview, a projection of the case it names, and a consent row are kept without a time by CM-17-010 and CM-23-044.
Extends: CLP-15-007
See also: MV-10-011 — defines the typed reference the rule excludes; a scope boundary, not a dependency

Vultron uses AS2 verbs rather than defining its own: Create, Offer, Accept, Reject, TentativeReject, Announce, Update, Add, Remove, Invite, Read, Join, Leave, Ignore and Undo.

Because the verbs are generic, meaning often comes from nesting: an Activity whose object is itself an Activity. Accepting an embargo is Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]), an Accept whose object is the Invite being accepted, which in turn carries the embargo. The nesting is what distinguishes accepting an embargo from accepting a report, Accept(Offer(VulnerabilityReport)).

This version uses the AS2 vocabulary, not full ActivityPub server behavior. Its conformance requirements do not include ActivityPub's inbox and outbox Hypertext Transfer Protocol (HTTP) delivery, WebFinger discovery or HTTP Signatures.

Informative: ActivityPub conformance is not required by this version

A future version is expected to raise the floor to ActivityPub; §1.3 Relationship to Existing Standards states the roadmap.

5.2 Serialization

Vultron messages are serialized as JavaScript Object Notation for Linked Data (JSON-LD). JSON-LD is JavaScript Object Notation (JSON) with a context that maps short names to full URIs. A message is therefore readable as ordinary JSON while remaining unambiguous about which vocabulary each term comes from.

An outbound message sets its top-level @context to a list of two URIs, in this order: the AS2 namespace, https://www.w3.org/ns/activitystreams, then the Vultron JSON-LD context document, https://certcc.github.io/Vultron/ns/context.jsonld. The AS2 URI comes first so that an AS2 receiver that does not process JSON-LD still finds it, as AS2 requires producers to provide. The Vultron context document declares every Vultron type name and the Vultron properties, each typed by its value kind as the AS2 context types its own: a link as "@type": "@id", a received document kept verbatim as "@type": "@json", and an ordered array, unordered array or IRI-keyed map with "@container" set to "@list", "@set" or "@index". It also imports the AS2 namespace, but a receiver is not required to fetch it, so citing it alone would hide the AS2 reference from such a receiver. An object nested in an activity does not restate the @context, because a JSON-LD context applies to every object inside the document that declares it. An object a sender received from a peer and embeds as received keeps the @context it arrived with. A receiver accepts a @context that is a single URI or a list of URIs.

Requirements

ID Priority Requirement Related
VM-10-001 MUST Outbound Vultron wire messages MUST set the top-level @context to exactly the list ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld"], AS2 first, or, for a signed message (SIG-01-001), to exactly ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld", "https://w3id.org/security/data-integrity/v2"]: the data-integrity context is the third and final entry, and no other context is added.

Derived from ADR-0069 (docs/adr/0069-vultron-namespace-uri.md). AS2 Core §2.1 asks every producer to reference the ActivityStreams namespace in @context, and an AS2 receiver that does not process JSON-LD, as most ActivityPub software does not, recognizes a message by finding that exact string. The Vultron context declares the CVD-specific types (VulnerabilityCase, EmbargoEvent, etc.) that the ActivityStreams namespace does not. The Vultron context document also imports AS2, but a receiver need not dereference it (VM-10-003), so citing the Vultron URI alone hides the AS2 reference from a plain-JSON receiver.
Uses definition from: SIG-01-001

Timestamps have one written form. Every timestamp is an RFC 3339 date-time with an explicit offset, as AS2 requires. A Vultron node writes exactly six fractional-second digits, even when they are all zero, so one instant at one offset always has one string. The case ledger hashes and compares that text, so a second spelling would read as a different record. The fixed form is what a Vultron node writes, not what it requires to receive: a timestamp written with fewer digits still parses, and a peer may send one. A timestamp it carries from a peer keeps the offset that peer sent, so the same instant at another offset stays another string.

Requirements

ID Priority Requirement Related
CS-13-006 MUST Wire-format datetime fields MUST serialize as RFC 3339 date-times with an explicit offset, so no naive or offset-free value reaches the wire.

ActivityStreams 2.0 requires every date-time value to follow the RFC 3339 date-time form, in which the offset is mandatory. A peer cannot read a value without an offset as one instant, so it cannot compare it with other times. CS-13-005 holds Vultron's rules on which offset a timestamp carries.
CS-13-007 MUST Every datetime this node serializes MUST be written as an RFC 3339 date-time with exactly six fractional-second digits, whether or not its microseconds are zero.

The case ledger hashes and compares timestamp text, so one instant at one offset needs one string. Whole seconds gave one string but made two acts one actor sends in the same second carry equal times; the fixed six-digit form keeps that one string and keeps the order. It fixes the fraction only: a carried timestamp keeps its own offset (CS-13-005, CLP-15-007), so the same instant at another offset is still another string. The form is what this node writes, not what it requires to receive: a peer may send whole seconds (ADR-0167).
Refines: CS-13-006 — fixes the fractional-second digits of the RFC 3339 form
Constrains: CLP-15-007 — A receiver carries a nested inbound timestamp as received, including at rendering, but writes its fractional digits in this node's one form. The instant and the offset are the peer's; the number of digits is not.
CS-13-005 MUST A wire timestamp this node generates MUST serialize with a UTC offset (Z or +00:00). A timestamp carried from a peer MUST serialize with the explicit offset it arrived with, which need not be UTC (CLP-15-007).

UTC is the form every node can write without configuration. A carried timestamp is part of an activity that the case ledger records verbatim (CLP-07-011). A change from +05:00 to +00:00 keeps the instant but changes the offset, so replicas then hold different records. What this rule keeps is the offset value, not the spelling a peer chose for it: Z and +00:00 are one offset, and a carried Z serializes as +00:00 because that is the only form format_timestamp writes. This rule picks the offset only; CS-13-006 holds the separate rule that every wire timestamp has an explicit offset, and CS-13-007 fixes its fractional-second digits, which a carried timestamp takes like any other.
Depends on: CLP-15-007
Refines: CS-13-006 — picks which explicit offset a wire timestamp carries

A ledger entry hash covers one canonical form. A case ledger entry's hash is computed over the RFC 8785 JSON Canonicalization Scheme (JCS) serialization of the content it covers, its payload snapshot included. JCS fixes the key order, the form of each number and the escaping of each string, so a peer in any language hashes the same bytes for the same content. Every receiver recomputes the hash and refuses an entry whose content does not reproduce it (§10.4 Ledger Replication and Case Delivery).

Requirements

ID Priority Requirement Related
SYNC-01-008 MUST Not yet in the reference implementation (tracked by #3659)

A CaseLedgerEntry's hash MUST be computed over the RFC 8785 (JCS) serialization of the content it covers, payload snapshot included.

Every receiver recomputes an entry's hash and refuses a mismatch (SYNC-03-006, SYNC-03-012). A peer built in another language reproduces the hash only if the bytes it hashes are fixed by a published rule, not by one serializer's behavior. JCS is that rule: it fixes key order, number form and string escaping, and the signing cryptosuite already uses it (SIG-01-002).
Extends: SYNC-01-003

The reference implementation does not hash the JCS form yet

The reference implementation hashes a sorted-key, compact JSON form that escapes non-ASCII text and writes numbers in Python's form, so it is not yet JCS. The requirement is listed in Known Gaps.

Objects travel inline or by reference. As AS2 allows, an Activity carries an object inline or names it by URI, and a receiver copes with either form. An object slot holds one of three forms, told apart by their keys alone (ADR-0198):

  • A whole object carries any key beyond id, type and preview, and the receiver validates it in full against its class. A whole object missing a field its class requires is refused, never read as a reference.
  • A typed reference is an inline object with exactly an id and a type, and optionally a preview. It names an object of that type and claims nothing else about it.
  • A URI, or a Link that carries one, names the object with no type.

A receiver routes an activity by a typed reference's type as it routes by a whole object's, but never reads the reference as the object. A handler uses the object the receiver holds, or the receiver fetches the object first. Only the case defines a preview: a case reference may carry the case stub, inline, as its preview (ADR-0205). A typed reference that carries any other preview is refused, and the refusal names its position. Inside a case preview, an object with only an id and a type, in a field that holds a case's objects, is read as that object shown by its id, not as a reference (MV-10-011). A receiver reads a reference that carries a preview as received. It never puts the object it holds in the reference's place, never fetches that object, and never seeds or updates a replica from it.

Requirements

ID Priority Requirement Related
MV-10-011 MUST A receiver MUST read an inline object with exactly an id, a type and an optional preview as a typed reference of that type, unless the object sits inside a preview in a field that declares a loose form, which reads it as that form (MV-12-006). It routes the activity by the reference's type. It never reads the reference as the object: a handler uses the object the receiver holds, or fetches it (AKM-05-007), unless the reference carries a preview, which the receiver reads as received (MV-10-013).

A bare URI carries no type, so a receiver must fetch the object before it can classify the activity. A typed reference lets it classify first and fetch only when a handler needs the content. The shape alone tells a reference from a whole object: any other key makes the object a whole object, which is refused when it fails its class (MV-04-003), so a broken object is never read as a reference (ADR-0198).
Extends: MV-10-009
See also: AKM-05-007 — the fetch a handler relies on when the receiver lacks the object
MV-10-012 MUST A receiver MUST refuse a typed reference (MV-10-011) that carries a preview, naming its position, unless the protocol defines a preview for the reference's type and the preview is that preview, carried inline. The case is the one type with a defined preview: a case reference's preview is a CasePreview (CM-17-010).

A preview is a limited view of an object for a recipient that may not hold it (ADR-0193), and what it may carry depends on the type. A preview of a type with no defined preview would be read by no rule, so it is refused rather than carried unchecked (ADR-0198). The case's preview is what an invitee decides on before it may see the case, so the stub Invite carries it (ADR-0205). Its recipient may not hold the case nor be entitled to fetch it, so a preview given by URI tells it nothing.
Extends: MV-10-011
See also: CM-17-010 — the stub's contents, which are the case's preview
MV-10-013 MUST NOT A receiver MUST NOT read a typed reference that carries a preview (MV-10-012) as the object it names. It does not put the object it holds in the reference's place, does not fetch that object (AKM-05-007), and seeds or updates no replica from the reference (PCR-02-003).

A preview is a limited view for a recipient not yet entitled to the object. The stub Invite and the full-case Invite both name the case and differ only in this form (ADR-0205). A CASE_MANAGER that expanded the reference into the case it holds would read an Accept of the stub Invite as an Accept of the full-case Invite. An invitee that fetched the case would ask for what it may not yet see. A replica built from a preview would be a hollow case.
Extends: MV-10-011
See also: MV-10-012 — the previews a receiver accepts, which this rule reads as received
See also: AKM-05-007 — the fetch this rule withholds for a previewed reference
See also: PCR-02-003 — the replica a full case seeds and a preview never does

An object the recipient cannot be expected to hold is carried inline, or named by a reference the recipient can dereference (§4.2 Knowledge Model and Actor Isolation). A production implementation can fetch an object named by a URI it holds no record of. The case-creation message that bootstraps a case is an exception: it carries the case and its participant records inline, and its receiver fetches none of them (§10.3 Case Bootstrap and the Trust Root).

Requirements

ID Priority Requirement Related
SE-01-002 MUST A receiver MUST cope with an object given either inline or as a URI reference, as ActivityStreams 2.0 allows.

ActivityStreams 2.0 lets a sender give an object inline or by its URI, and conforming peers use both forms. If a receiver accepts only one form, it refuses or misreads correct messages from those peers.
AKM-05-004 MUST A production implementation MUST support object dereference (AKM-05-003). Given a URI it has not seen, it then fetches the object through an API call.

A production deployment exchanges cases with independently built implementations, which may name objects by reference instead of inline. Without dereference it cannot process such an activity, and the refusals that stand in for dereference (AKM-05-003) would block legitimate traffic.
Refines: AKM-05-003

How a case ledger entry records the objects of the activity it records is specified at §10.4 Ledger Replication and Case Delivery.

The reference implementation inlines every object

The reference implementation dereferences only a few references, so it carries every object inline and refuses a bare URI it cannot fetch where it needs the object. The one exception is the case that a participant's Join, Ignore or Leave acts on, and the case of an ownership-transfer Offer: every receiver of these holds the case, so the activity names it by a typed reference, an inline object with only its id and type (ADR-0165). That is a shortcut of the prototype, not a Vultron rule.

Provisional namespace URI

The namespace is currently hosted on GitHub Pages. A permanent URI may be registered in a future version (§15 IANA and Namespace Considerations).

5.3 Transport [N/I]

The transport moves a serialized message from one actor to another. The message schema of §5.1 Base Vocabulary and §5.2 Serialization is transport-agnostic: the same JSON payload is deliverable over any conformant transport.

An actor is identified by a URI, and that URI is also where it receives messages. Each actor exposes an inbox to receive Activities and an outbox from which it sends them. An actor's URI is its identity for every purpose in the protocol: there is no separate registry, and no name or hosting location carries authority (§2.2 Roles). Delivery is therefore inbox to inbox.

This version recognizes one required transport profile and describes a second that is anticipated.

REST (HTTP) profile [N]

This Representational State Transfer (REST) profile is the transport this version requires.

  • Each actor exposes an inbox endpoint, named in its actor profile, that accepts inbound Activities.
  • An outbound Activity is delivered by HTTP POST to the recipient's inbox.
  • The POST names one of the two ActivityStreams media types as its Content-Type: application/activity+json, or application/ld+json with the ActivityStreams profile. An inbox accepts both and refuses any other media type, plain application/json included.
  • Authentication and authorization requirements are at §16 Security Considerations.

Requirements

ID Priority Requirement Related
IE-02-001 MUST The endpoint URL MUST be discoverable from actor profile

ActivityPub requires every actor object to carry its inbox property, so a peer finds the endpoint from the profile rather than by a URL convention, which also leaves each deployment free to place it.
IE-02-002 MUST The endpoint MUST accept activities delivered to it by HTTP POST.

ActivityPub delivers an activity to an inbox by HTTP POST. Vultron inherits the rule. That POST is the only method the inbox serves is this codebase's choice (IE-02-005).
HTTP-01-004 MUST A sender MUST deliver an activity to an inbox with Content-Type: application/activity+json or Content-Type: application/ld+json; profile="https://www.w3.org/ns/activitystreams".

ActivityPub requires a POST to an inbox to use the ld+json ActivityStreams profile. Every Vultron inbox also accepts application/activity+json (HTTP-01-001, HTTP-01-002), so Vultron lets a sender use either form. That is looser than ActivityPub, so the rule is Vultron's own. A receiver that refuses other media types (HTTP-01-003) refuses plain application/json.
Extends: HTTP-01-001
HTTP-01-001 MUST Inbox endpoint MUST accept application/activity+json Content-Type

ActivityPub only says a server SHOULD treat application/activity+json as equivalent to the JSON-LD media type it names for delivery (HTTP-01-002). Vultron makes that SHOULD a MUST, so the rule is Vultron's own, not inherited.
HTTP-01-002 MUST Inbox endpoint MUST accept application/ld+json; profile="https://www.w3.org/ns/activitystreams" Content-Type

This is the media type ActivityPub names for delivery to an inbox. Vultron inherits the rule rather than defining it.
HTTP-01-003 MUST Not yet in the reference implementation (tracked by #4666)

Inbox endpoint MUST reject requests with invalid Content-Type using HTTP 415

HTTP defines 415 Unsupported Media Type as the answer to a request whose content is in a format the target resource does not support.
Implements: IE-03-001

The reference implementation's inbox accepts any media type

The reference implementation delivers with Content-Type: application/activity+json, but its inbox does not yet refuse other media types. HTTP-01-003 is listed in Known Gaps.

Open question: which HTTP responses a receiving actor returns

This version does not say which HTTP status code a receiving actor returns when it refuses a message. For example, it does not say whether an invalid activity gets 422, an activity addressed only to other actors gets 400, or a message that cannot be decrypted gets 400.

One option is for the protocol to specify these responses, so that a sending actor can rely on them and act on them. The other is to leave them to each server implementation. A Vultron actor built on a stock ActivityPub server returns whatever that server returns, so a protocol rule could conflict with the server it runs on.

Until this is settled, these codes are recorded as the reference implementation's choices, not as protocol requirements. The codes that HTTP itself defines, such as 405 for an unsupported method and 413 for a body that is too large, are not part of this question.

ActivityPub federation profile [I]

Full ActivityPub conformance is not required by this version. The roadmap is at §1.3 Relationship to Existing Standards. Annex E Relationship to ActivityPub describes where Vultron follows ActivityPub conventions and where it diverges.

Participant discovery [I]

Before two actors can exchange messages, each needs to locate the other. WebFinger is the anticipated mechanism, consistent with its use alongside ActivityPub in federated systems. This version does not specify how an actor is found. Once an actor's profile is known, its inbox is the endpoint the profile names.

Transport is not routing

Which inbox a message may go to is a protocol rule, specified at §10.2 Routing Topology, and it applies whichever transport carries the message. The transport is responsible for getting a message to an inbox. The protocol is responsible for which inbox it may go to.

5.4 Worked Exchanges [I]

The exchanges below show occasions of §4 Messages as they appear on the wire. Each one is given first in Wire Activity notation and then as the JSON a sender delivers. The identifiers, timestamps and hashes are illustrative, and optional fields such as name and updated are left out. Every activity carries the published timestamp its sender stamps on it (CLP-15-006), and so does every whole object it embeds other than the exempt kinds (CLP-15-011).

Submitting a report

A Finder submits a report to a Vendor, which acknowledges the submission with Report Acknowledgment (RK). No case exists yet, so both messages go directly between the two actors.

Step Sender Send to Wire activity Shorthand
1 Finder Vendor Offer(VulnerabilityReport) RS
2 Vendor Finder Read(Offer(VulnerabilityReport)) RK
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Offer",
  "id": "https://vultron.example/users/finndervul/activities/offer-1",
  "published": "2026-05-30T10:00:00.000000+00:00",
  "actor": "https://vultron.example/users/finndervul",
  "to": ["https://vultron.example/organizations/vendorco"],
  "object": {
    "type": "VulnerabilityReport",
    "id": "https://vultron.example/reports/FDR-8675309",
    "published": "2026-05-30T09:30:00.000000+00:00",
    "content": "I found a vulnerability!",
    "attributedTo": "https://vultron.example/users/finndervul"
  }
}
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Read",
  "id": "https://vultron.example/organizations/vendorco/activities/read-1",
  "published": "2026-05-30T11:00:00.000000+00:00",
  "actor": "https://vultron.example/organizations/vendorco",
  "to": ["https://vultron.example/users/finndervul"],
  "content": "We have received the report. We will get back to you soon.",
  "object": {
    "type": "Offer",
    "id": "https://vultron.example/users/finndervul/activities/offer-1",
    "published": "2026-05-30T10:00:00.000000+00:00",
    "actor": "https://vultron.example/users/finndervul",
    "to": ["https://vultron.example/organizations/vendorco"],
    "object": {
      "type": "VulnerabilityReport",
      "id": "https://vultron.example/reports/FDR-8675309",
      "published": "2026-05-30T09:30:00.000000+00:00",
      "content": "I found a vulnerability!",
      "attributedTo": "https://vultron.example/users/finndervul"
    }
  }
}

Proposing and accepting an embargo

A Vendor proposes embargo terms for a case with no active embargo, Embargo Proposal (EP). The CASE_MANAGER asks each other participant about the proposal, naming the proposer in attributedTo, the proposal in inReplyTo and the deadline for an answer in endTime. A Coordinator agrees by accepting the Invite it received. That answer is the Coordinator's own consent, so it carries no shorthand: Embargo Proposal Acceptance (EA) is the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase].

Step Sender Send to Wire activity Shorthand
1 Vendor the CASE_MANAGER Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase] EP
2 the CASE_MANAGER Coordinator Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase] —
3 Coordinator the CASE_MANAGER Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) —
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Invite",
  "id": "https://vultron.example/cases/1/embargo_proposals/1",
  "published": "2026-06-01T18:00:00.000000+00:00",
  "actor": "https://vultron.example/organizations/vendorco",
  "to": ["https://vultron.example/case-actors/vendorco-case-actor"],
  "context": "https://vultron.example/cases/1",
  "summary": "We propose to embargo case 1 for 90 days.",
  "object": {
    "type": "EmbargoEvent",
    "id": "https://vultron.example/cases/1/embargo_events/2026-08-30T00:00:00+00:00",
    "published": "2026-06-01T18:00:00.000000+00:00",
    "context": "https://vultron.example/cases/1",
    "startTime": "2026-06-01T19:12:00.000000+00:00",
    "endTime": "2026-08-30T00:00:00.000000+00:00"
  }
}
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Invite",
  "id": "https://vultron.example/cases/1/embargo_proposals/1/invites/coordinator",
  "actor": "https://vultron.example/case-actors/vendorco-case-actor",
  "attributedTo": "https://vultron.example/organizations/vendorco",
  "inReplyTo": "https://vultron.example/cases/1/embargo_proposals/1",
  "to": ["https://vultron.example/organizations/coordinator"],
  "context": "https://vultron.example/cases/1",
  "published": "2026-06-01T19:12:00.000000+00:00",
  "endTime": "2026-06-08T19:12:00.000000+00:00",
  "summary": "The vendor proposes to embargo case 1 for 90 days.",
  "object": {
    "type": "EmbargoEvent",
    "id": "https://vultron.example/cases/1/embargo_events/2026-08-30T00:00:00+00:00",
    "published": "2026-06-01T18:00:00.000000+00:00",
    "context": "https://vultron.example/cases/1",
    "startTime": "2026-06-01T19:12:00.000000+00:00",
    "endTime": "2026-08-30T00:00:00.000000+00:00"
  }
}
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Accept",
  "id": "https://vultron.example/organizations/coordinator/activities/accept-1",
  "published": "2026-06-02T09:00:00.000000+00:00",
  "actor": "https://vultron.example/organizations/coordinator",
  "to": ["https://vultron.example/case-actors/vendorco-case-actor"],
  "context": "https://vultron.example/cases/1",
  "object": {
    "type": "Invite",
    "id": "https://vultron.example/cases/1/embargo_proposals/1/invites/coordinator",
    "actor": "https://vultron.example/case-actors/vendorco-case-actor",
    "attributedTo": "https://vultron.example/organizations/vendorco",
    "inReplyTo": "https://vultron.example/cases/1/embargo_proposals/1",
    "to": ["https://vultron.example/organizations/coordinator"],
    "context": "https://vultron.example/cases/1",
    "published": "2026-06-01T19:12:00.000000+00:00",
    "endTime": "2026-06-08T19:12:00.000000+00:00",
    "object": {
      "type": "EmbargoEvent",
      "id": "https://vultron.example/cases/1/embargo_events/2026-08-30T00:00:00+00:00",
      "published": "2026-06-01T18:00:00.000000+00:00",
      "context": "https://vultron.example/cases/1",
      "startTime": "2026-06-01T19:12:00.000000+00:00",
      "endTime": "2026-08-30T00:00:00.000000+00:00"
    }
  }
}

Reporting a fix is ready

A Vendor reports that it has a fix ready, Fix Readiness (CF), as a claim in a new ParticipantStatus on its own participant record. The vfState value VF is what distinguishes this occasion from the other claims that share the activity.

Step Sender Send to Wire activity Shorthand
1 Vendor the CASE_MANAGER Add(ParticipantStatus, target=<participant>/statuses), with vfState VF CF
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Add",
  "id": "https://vultron.example/organizations/vendorco/activities/add-status-3",
  "published": "2026-07-15T14:00:00.000000+00:00",
  "actor": "https://vultron.example/organizations/vendorco",
  "to": ["https://vultron.example/case-actors/vendorco-case-actor"],
  "target": "https://vultron.example/cases/1/participants/vendorco",
  "object": {
    "type": "ParticipantStatus",
    "id": "https://vultron.example/cases/1/participants/vendorco/status/3",
    "published": "2026-07-15T14:00:00.000000+00:00",
    "context": "https://vultron.example/cases/1",
    "attributedTo": "https://vultron.example/organizations/vendorco",
    "rmState": "ACCEPTED",
    "vfState": "VF",
    "caseEngagement": true,
    "cvdRole": ["VENDOR"]
  }
}

Replicating a ledger entry

The CASE_MANAGER has committed a case event to the case ledger and sends the entry to every active participant (§3.4 How the Dimensions Interact). Each participant checks that the entry's prevLogHash matches the entryHash of the last entry it holds (§4.12 Ledger Replication Messages). The entry shown is the first in its case's ledger, so its prevLogHash is the case's own genesis hash (CLP-08-001). Its published is the CASE_MANAGER's commit stamp (CLP-14-002). The two digests below are illustrative: they show the fields' shape and are not computed over the example's own values, so recomputing them from what is shown will not reproduce them.

Step Sender Send to Wire activity Shorthand
1 the CASE_MANAGER each participant Add(CaseLedgerEntry) —
{
  "@context": [
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Announce",
  "id": "https://vultron.example/case-actors/vendorco-case-actor/activities/announce-0",
  "published": "2026-05-31T12:00:01.000000+00:00",
  "actor": "https://vultron.example/case-actors/vendorco-case-actor",
  "to": ["https://vultron.example/organizations/coordinator"],
  "object": {
    "type": "CaseLedgerEntry",
    "id": "https://vultron.example/cases/1/log/0",
    "published": "2026-05-31T12:00:00.000000+00:00",
    "caseId": "https://vultron.example/cases/1",
    "logIndex": 0,
    "logObjectId": "https://vultron.example/activities/00000000-0000-0000-0000-000000000001",
    "semanticType": "create_case",
    "payloadSnapshot": {},
    "prevLogHash": "17334082900cbfad3b45787a0ef507390580bdf1508d78e3597435d79339ab3d",
    "entryHash": "0dabc4e69c51c1fa7e30595ff3357fdcb1fbe4581aed3534bec1e92c30e84549",
    "receivedAt": "2026-05-31T12:00:00.000000+00:00"
  }
}

6. Report Management (RM) State Machine [N]

Report Management is the first of the five state machines, and every case starts with it. Before there is an embargo to negotiate or a fix to track, a participant receives a report and decides what to do with it. This section specifies the states of that decision and the transitions between them.

Behavioral Layer — §6 through §12

§6 Report Management (RM) State Machine through §12 Participant Lifecycle Within a Case together specify the five state machines of the Vultron protocol: RM (§6 Report Management (RM) State Machine), EM (§7 Embargo Management (EM) State Machine), VFD and PXA (§8 Case State (CS) Dimensions, together the CS dimension), and PEC (§9 Participant Embargo Consent (PEC) State Machine). How the CASE_MANAGER coordinates a case is in §10 Case Coordination. Model interactions and cascade rules are in §11 Model Interactions and Cascade Rules. The participant lifecycle is in §12 Participant Lifecycle Within a Case.

On scope: PEC. The Participant Embargo Consent machine was not part of the original four-machine design. It is fully normative here. Its definition site records its provenance (§9 Participant Embargo Consent (PEC) State Machine).

Two conventions apply throughout §6 Report Management (RM) State Machine through §12 Participant Lifecycle Within a Case:

6.1 States

Report Management tracks one report inside one participant, from the moment the report arrives until that participant is finished with it. Every participant runs its own RM machine and is the authority on its own value. Two participants that work on the same case are often at different RM states. This difference is expected, and it is not a disagreement to reconcile.

State Meaning
Start No report has been received
Received A report has arrived; triage is not yet complete
Invalid This participant assessed the report as invalid
Valid This participant assessed the report as valid
Deferred This participant is deferring further action
Accepted This participant accepted the report for active work
Closed This participant closed the report

The states divide into three groups. Start and Received come before any assessment. Invalid and Valid record the outcome of triage. Deferred, Accepted and Closed record what the participant decided to do about a report that it considers valid. The exception is that a participant can also close a report directly from Received or Invalid.

6.2 Transitions and Guards

A participant drives its own RM transitions. Each transition below is a participant-level state change. It records an action of that participant, and it does not change the RM state of any other participant.

---
title: Report Management State Diagram
---
stateDiagram-v2
    direction LR
    S: Start
    R: Received
    I: Invalid
    V: Valid
    D: Deferred
    A: Accepted
    C: Closed

    [*] --> S
    S --> R : receive
    R --> I: invalidate
    R --> V : validate
    I --> V : validate
    V --> A : accept
    V --> D : defer
    A --> D : defer
    D --> A : accept
    R --> C : close
    A --> C : close
    D --> C : close
    I --> C : close
    C --> [*]
From Trigger Message To
Start receive receipt of RS Received
Received validate RV Valid
Received invalidate RI Invalid
Received close RC Closed
Invalid validate RV Valid
Valid accept RA Accepted
Valid defer RD Deferred
Deferred accept RA Accepted
Accepted defer RD Deferred
Invalid close RC Closed
Deferred close RC Closed
Accepted close RC Closed

These twelve transitions are the complete set. Three consequences follow. Each one corrects a plausible assumption that is not true:

  • A report cannot be closed from every state. Only Received, Invalid, Deferred and Accepted are closable. A participant at Start or Valid has to reach one of those states before it can close. A Reject sent from Received is the Received → Closed transition, and a participant at Valid that leaves a case is recorded as Valid → Deferred → Closed.

  • Valid does not return to Invalid. Invalidation is available only from Received. When a participant has assessed a report as valid, it does not invalidate it again. If the participant decides to stop work, it defers or closes.

  • Accepted and Deferred are mutually reachable. A participant can defer work it had accepted and accept work it had deferred, without passing through Valid again.

Closed has no transition out of it. A participant that expects to resume work on a report defers it instead of closing it.

Requirements

ID Priority Requirement Related
RMB-14-004 MUST The RM transition function MUST permit closing from Received (q^rm R → C), as well as I → C, A → C and D → C. A Reject sent from RM Received, of a report Offer, a stub Invite (CM-11-007) or a full-case Invite (CM-11-011), is the R → C transition.

Reject means close and TentativeReject means invalid, so a hard no from Received needs its own edge rather than a bypass of the transition table.
Uses definition from: CM-11-007
Uses definition from: CM-11-011
RMB-14-008 MUST NOT The RM transition function MUST NOT permit closing from Valid (VP-02-004).

Valid keeps no close edge: a participant that found a report valid decides to engage or defer before it leaves (ADR-0114).
Refines: VP-02-004
RMB-14-005 MUST Every RM closure MUST be written as transitions the RM transition function permits, with no closure path that overrides the transition table.

An override that skips the RM transition table lets a closure write a state that no permitted sequence reaches. The write-boundary check (RMB-15-001) and every replica then disagree with that state. R to C is in the table (RMB-14-004), and Valid goes through Deferred (RMB-14-009). Thus every closure is an ordinary transition, and no closure path needs the override (ADR-0114).
RMB-14-009 MUST An actor MUST record a participant at RM Valid that leaves the case (Leave(VulnerabilityCase), CM-23-038) as V → D → C.

V → C is not in the RM transition table (RMB-14-008), so a closure from Valid that keeps to the table (RMB-14-005) goes through Deferred.
Refines: RMB-14-005
Refines: CM-23-038
RMB-14-006 MUST NOT The RM state machine MUST NOT define any transition out of RM.CLOSED to a different RM state. RM.CLOSED is terminal: once a participant's RM state reaches CLOSED, no further RM progression is possible for that participant on that case.

RM.CLOSED being terminal is what gives the closure act finality. A participant that anticipates returning to the case SHOULD instead move to RM.DEFERRED (resumable via DEFERRED → ACCEPTED) rather than close; once closed, the participant has no path back in, because a re-invite to a participant at RM.CLOSED is refused (CM-11-043, ADR-0085). Rejoin mechanics are deferred to a future design; the interim workaround is defer-not-close (RMB-14-007).
RMB-14-007 SHOULD A participant that anticipates returning to active coordination on a case SHOULD move to RM.DEFERRED (the resumable parking state) rather than RM.CLOSED. RM.DEFERRED supports both DEFERRED → ACCEPTED (resume) and DEFERRED → CLOSED (abandon) transitions; RM.CLOSED supports neither.

Because RM.CLOSED is terminal (RMB-14-006), a participant that closes and later wants back in has no protocol path. RM.DEFERRED preserves optionality: the participant can accept the case later or close it once it confirms there is nothing more to do (ADR-0085). Full rejoin mechanics (reactivation via re-invitation, multiple lifecycle arcs per actor) are deferred to a future design Idea.
VP-02-004 MUST NOT Participants MUST NOT close cases or reports from the Valid state

Valid means the report is real and in scope but no engage-or-defer decision has been made. Closing straight from Valid would let a confirmed vul be dropped without that prioritization decision ever being taken or announced, so the report must pass through Accepted or Deferred first.

6.3 Per-Participant RM Tracking

Each participant tracks its own RM state independently. A participant is the authority on its own RM state (§10.1 Single-Writer Authority). A receiver that processes an RM transition records it on the sender's participant record, never on its own.

Requirements

ID Priority Requirement Related
CM-01-002 MUST Each actor's RM state MUST be maintained independently per case

RM is a process for each participant. Each participant receives, validates, accepts, defers and closes a report on its own schedule (CM-03-002). One RM state for each actor in each case lets an actor be at different RM stages in different cases. It also stops the progress of one actor from counting as the progress of another actor.
CM-03-002 MUST RM state MUST be participant-specific

Each participant moves through report handling on its own. One participant can accept a report that another has not yet validated. A single shared RM state cannot show this, and one participant's transition would overwrite the state of another (CM-01-002).
CM-04-001 MUST A receiver of a participant-status message MUST record the declared RM state on the sending actor's CaseParticipant, as its model of the sender (SM-10-001).

RM state is self-declared: each participant reports its own report-handling progress (CM-03-002). A participant-status message updates the receiver's model of its sender. A record on any other participant would give one participant the progress of another. Other messages move the receiver's own state instead (SM-10-001). RSH-08-003 says which receiver writes the record directly.
Refines: SM-10-001
Implements: VP-01-002

Received is the entry state for a participant in a case. A participant reaches it by several paths:

  • Invited participant — the CASE_MANAGER creates an inert participant record at RM Received when it sends the stub Invite.
  • Direct report recipient — on receiving a report.
  • Case proposal recipient — on receiving a CaseProposal.

An invited participant answers the stub Invite before it has seen more than a case stub. Accept(Invite) activates the inert record, recording willingness to join and, where an embargo is active, consent to it, unless the participant has already declined that embargo. RM stays at Received. Reject(Invite) closes the record (RM Received → Closed) and retains it as history. Neither answer is a validation of the report.

Requirements

ID Priority Requirement Related
CM-11-006 MUST When the CASE_MANAGER sends a stub Invite (Invite(VulnerabilityCase preview)[target=Actor]), it MUST create the invitee's CaseParticipant in the same step. The participant is inert (CM-10-004).

The CASE_MANAGER needs to track every invitee from the moment it is invited — whether it has been told and how it answered — including the invitees that decline (ADR-0114).
Uses definition from: CM-10-004
CM-11-026 MUST The CaseParticipant a stub Invite creates MUST hold the Invite's roles, RM RECEIVED, VF v (VENDOR), and an INVITED row for an active embargo.

The invitee has been told of the case and has decided nothing. RM RECEIVED and VF v record exactly that. The INVITED row records that it was asked about the embargo in force and has not answered (CM-18-001).
Extends: CM-11-006
CM-11-023 MUST When it sends a stub Invite, the CASE_MANAGER MUST commit its own add_case_participant_to_case entry, Add(CaseParticipant) with the case as its target and context (CLP-07-021), separate from the Invite's invite_actor_to_case entry.

The ledger holds the wire messages that the actors exchanged, and every state change has a message. The Invite is one message. Creating the invitee's record is the CASE_MANAGER's own act, so it is a second message with its own entry (ADR-0114, ADR-0124).
Extends: CM-11-006
Refines: CLP-07-021
CM-11-024 MUST The add_case_participant_to_case entry MUST carry the whole participant record as stored: its statuses and consent rows, with their ids and times.

A replica copies the record from the entry and derives nothing (CM-11-025, ADR-0124). The entry must therefore carry every field the CASE_MANAGER holds, or the replica's record differs from the CASE_MANAGER's.
Extends: CM-11-023
CM-11-025 MUST A replica MUST store an invitee's record exactly as the add_case_participant_to_case entry carries it, in the case its target names, and derive none of it from the Invite's entry.

Replicas copy; they never mint ids, read clocks or run lifecycle logic (ADR-0124). A record a replica derived could differ from the CASE_MANAGER's in an id or a time, and the copies of the case would then disagree.
Depends on: CM-11-024
CM-11-001 MUST When a participant accepts the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.

The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this.
Uses definition from: CM-10-001
Extends: BT-10-005
CM-11-007 MUST A stub Invite has exactly two valid replies, Accept (CM-11-001) and Reject. On Reject(Invite(VulnerabilityCase preview)[target=Actor]), the CASE_MANAGER MUST close the participant and keep its record, which stays inert. Closing it moves its RM state to RM.CLOSED, sets VF V for a VENDOR, and records consent DECLINED when an embargo is active.

A stub reject is a hard no to joining. Keeping the record keeps the history that the actor was told and declined, which is what the early record exists for.
See also: CM-11-001 — context for the reader
CM-11-027 MUST A replica MUST apply a stub Reject from two entries: the invitee's reject_invite_actor_to_case, which carries the DECLINED row, and the CASE_MANAGER's add_participant_status_to_participant closing status.

The invitee's Reject is a message, so it is its own ledger entry, and it is the entry for the DECLINED row. A replica applies that row through the same write the CASE_MANAGER uses. The closing status is the CASE_MANAGER's own act, with an entry of its own that a replica stores. Each replica then holds the record the CASE_MANAGER holds (ADR-0114, ADR-0124).
Extends: CM-11-007
CM-11-028 MUST The CASE_MANAGER MUST refuse TentativeReject(Invite(VulnerabilityCase preview)[target=Actor]).

Accepting the stub is not a judgement of the case, so there is nothing for a tentative reject to say. Only the full-case Invite asks for a judgement (CM-11-011).
Derives from: CM-11-007

After the participant joins, the CASE_MANAGER sends the case and the ledger. It then sends a second Invite, the full-case Invite, which carries the ledger position of the CASE_MANAGER as a floor. The participant judges the case when it answers this Invite with its own ledger position. The answer is Accept (RV, Received → Valid), TentativeReject (RI, Received → Invalid) or Reject (RC, Received → Closed). A reply behind the floor, or naming a ledger entry the CASE_MANAGER does not hold, is refused.

Requirements

ID Priority Requirement Related
CM-11-010 MUST After CM-11-008, the CASE_MANAGER MUST send the participant the full-case Invite, Invite(whole VulnerabilityCase)[target=Actor], queued after the last replayed ledger entry.

AS2 puts what one is invited to in object, so the Invite carries the whole case it asks the participant to judge (ADR-0205); the participant is active, so it is entitled to it (CM-10-004), and reads the case from its own replica. Delivery to each recipient is ordered (ADR-0112), so queuing the Invite after the replay means it usually arrives once the participant can answer it. The protocol does not rely on that order (ADR-0161): CM-11-033 covers an Invite that arrives first.
Depends on: CM-11-008
CM-11-031 MUST The full-case Invite MUST name the case by ID and carry the log_index and entry_hash of the CASE_MANAGER's ledger tail when it issued the Invite.

The Invite's ledger position is the floor the participant must reach before answering (ADR-0121). It travels as the Invite's ledgerPosition, the property every case activity carries (VAM-04-011, SYNC-18-001, ADR-0156).
Extends: CM-11-010
CM-11-032 MUST A receiver MUST refuse a full-case Invite whose sender is not the CASE_MANAGER on its replica of the case.

Only the case's CASE_MANAGER may ask a participant to judge the case. The receiver judges the Invite only when it holds the replica (CM-11-033), so the replica's CASE_MANAGER is the only record the sender check needs. The stub-Invite trust anchor decides an earlier question: whether the Announce may create that replica (PCR-03-004).
CM-11-033 MUST A receiver MUST NOT judge a full-case Invite for a case it holds no replica of.

The protocol does not rely on delivery order (ADR-0161), so the Invite can arrive before the Announce (CM-11-010). It is case-scoped: the inbox's defer check holds it until the Announce creates the replica, then replays it (HP-01-041). With no trust anchor, no Announce can create the replica (PCR-03-004), so the held Invite expires unprocessed (CBT-03-003) and the receiver fails closed.
Extends: CM-11-032
Depends on: HP-01-041
CM-11-011 MUST The CASE_MANAGER MUST record each full-case Invite reply as a move from RM.RECEIVED: RV Accept to RM.VALID, RI TentativeReject to RM.INVALID, RC Reject to RM.CLOSED.

Each reply is the participant's own judgement of the case (ADR-0121). The three replies map to the three RM triage outcomes, so every replica records the judgement the participant made.
CM-11-034 MUST A reply to the full-case Invite MUST carry the replier's own ledger position: the log_index and entry_hash of its tail when it decided.

The position is the reply's ledgerPosition, the property every case activity carries (VAM-04-012..014, SYNC-18-001, ADR-0156), so the CASE_MANAGER judges it against the Invite's floor (CM-11-012) from the one field it reads on every case activity.
Extends: CM-11-011
CM-11-012 MUST The CASE_MANAGER MUST refuse a full-case Invite reply whose position is behind the Invite's, or names an entry missing from its ledger at that index.

The Invite's position is a floor. A reply behind it was made without seeing what the participant was asked to judge. A reply that names an entry the CASE_MANAGER's ledger does not hold was not made on its ledger.
Supersedes: SYNC-18-004
CM-11-035 MUST The CASE_MANAGER MUST accept a full-case Invite reply whose position is at or beyond the Invite's.

The Invite's position is a floor, not a pin. A reply beyond it is better informed. Pinning the reply to the Invite's position would make every reply on a busy case stale (ADR-0121).
Extends: CM-11-012
CM-11-036 MUST The CASE_MANAGER MUST refuse a full-case Invite reply from a participant that has not joined the case (an inert participant), writing nothing.

Only a joined participant judges the case. An inert participant has not received the case or its history, so it has nothing to judge (CM-10-004).
Extends: CM-11-012

The triage cycle (RECEIVED → VALID | INVALID → ACCEPTED | DEFERRED) is a different, later step. The participant runs it after it receives the full case replica.

Two Invites, two different acts

Joining a case and judging a case are different protocol acts, and each has its own Invite. The stub Invite asks whether the actor will join. Accept(Invite) joins the case and consents to the embargo, and leaves RM at Received.

The full-case Invite asks whether the case is valid. Its Accept is RV (Received → Valid), and only a later Join(VulnerabilityCase) reaches RM Accepted. A participant cannot accept what it has not seen, so the CASE_MANAGER does not treat a participant as having committed to the case until that participant sends Join(VulnerabilityCase).

See §9.7 Gating Full Case Delivery for why this matters to case delivery.

Requirements

ID Priority Requirement Related
CM-11-002 SHOULD After joining a case, a participant SHOULD judge the case by replying to the full-case Invite (CM-11-010, CM-11-011).

The CASE_MANAGER cannot count a joined participant as engaged until the participant says so (CM-11-004). The other participants plan their work from the list of engaged participants. The participant receives the full-case Invite, examines the case and its history, and then engages or defers. Every replica then records the RM decision of the participant itself, not a decision that the CASE_MANAGER infers from silence.
Uses definition from: CM-11-001
Uses definition from: CM-11-010
See also: CM-11-011 — context for the reader
CM-11-022 SHOULD After it replies to the full-case Invite, a participant SHOULD engage with Join(VulnerabilityCase) (RM.ACCEPTED) or defer with Ignore(VulnerabilityCase) (RM.DEFERRED).

Judging the case says whether the report is valid. It does not say whether the participant will work on the case. Only the participant can make that choice, and Join or Ignore records it, so no replica has to infer it from silence (CM-11-004).
Extends: CM-11-002
CM-11-004 MUST The CASE_MANAGER MUST NOT treat a joined participant as having committed to the case (RM.ACCEPTED) until it receives Join(VulnerabilityCase) from that participant.

Only the participant can say it has chosen to engage. Neither accepting the stub Invite (joining) nor accepting the full-case Invite (RM.VALID) is an engagement decision.
Uses definition from: CM-11-001

7. Embargo Management (EM) State Machine [N]

An embargo is an agreement among the participants of a case not to disclose the vulnerability publicly before an agreed point. Embargo Management tracks the progress of that agreement for the case as a whole. It records whether an embargo has been proposed, is in force, is under renegotiation, or has ended.

There is exactly one embargo state per case. It is shared case state, so only the CASE_MANAGER writes it (§10.1 Single-Writer Authority). The CASE_MANAGER does not set the EM state directly either. The CASE_MANAGER changes the case's embargo register, and the EM state is computed from the register (§7.1.2 Deriving EM from the Register). Embargo consent tracks a separate question, per participant and per embargo: whether each participant has agreed to the current terms (§9 Participant Embargo Consent (PEC) State Machine).

7.1 States

The five states below describe the case's collective position, not any one participant's, and not any one embargo's.

State Meaning Embargo register entries
None No embargo is in effect for this case, and none is proposed none ACTIVE, PROPOSED or TERMINATED
Proposed At least one embargo is proposed, and none is in force one or more PROPOSED, none ACTIVE
Active An embargo is in force, and no revision is open one ACTIVE, none PROPOSED
Revised An embargo is in force, and at least one revision of it is open one ACTIVE, one or more PROPOSED
Exited The embargo has been torn down one TERMINATED

None here means no embargo is in effect for the case. A participant's consent row for an embargo has a separate start state, UNINVITED, meaning the participant has not been asked about that embargo (§9.1 States). The case state and a consent row can legitimately disagree. A case at Active can hold a participant whose row for the embargo in force is INVITED or DECLINED. In that example, the row is INVITED because the participant has been invited to the case and has not yet accepted.

7.1.1 The Embargo Register

A case keeps one embargo register entry for every embargo ever proposed on it. An entry names the embargo, holds its status, and, for an activated revision, names the embargo it replaced. Entries are appended and never removed, so the register is the whole embargo history of the case, including rejected and canceled proposals.

Status Meaning
PROPOSED An open proposal, awaiting the Case Owner's decision
ACTIVE In force
REJECTED The Case Owner declined the proposal
SUPERSEDED Was in force, then a revision replaced it
CANCELLED Closed with no owner decision, because the embargo question became moot
TERMINATED Was in force when the case's embargo ended

REJECTED, SUPERSEDED, CANCELLED and TERMINATED are final. Six triggers move an entry:

Trigger Change
PROPOSE new entry → PROPOSED
ACTIVATE PROPOSED → ACTIVE
REJECT PROPOSED → REJECTED
SUPERSEDE ACTIVE → SUPERSEDED, in the step that activates another entry
TERMINATE ACTIVE → TERMINATED, recording what ended the embargo and, when known, why
CANCEL PROPOSED → CANCELLED, in the step that terminates the embargo in force, or on a threat signal while no entry is ACTIVE

A register step is the whole change that one act causes. A termination and the cancellation of every open proposal therefore happen in one step and are checked together. Every step keeps these invariants:

  1. At most one entry is ACTIVE and at most one is TERMINATED, and never one of each.
  2. A SUPERSEDED entry exists only alongside exactly one ACTIVE or TERMINATED entry.
  3. No entry is PROPOSED while an entry is TERMINATED.
  4. Once a step has left an entry TERMINATED, no later step adds or changes an entry.

Requirements

ID Priority Requirement Related
EP-08-004 MUST When an embargo terminates (EM ACTIVE or REVISE → EXITED), the implementation MUST close every open proposal, cancelling it in the same embargo register step that terminates the embargo (ADR-0122), not only the entry for the terminated embargo itself. Every proposal open while EM is ACTIVE or REVISE is a revision of the active embargo, and a revision of an embargo that no longer exists cannot be accepted.

A case has at most one active embargo (VP-04-002), so while EM is ACTIVE or REVISE every open proposal is by construction a revision of that embargo; no field linking a revision to the embargo it revises is needed to know which proposals a termination decides. EP-08-003's text reaches the terminated embargo; this entry reaches the proposals about it.
Refines: EP-08-003

A termination records two things. What ended the embargo is END_TIME_REACHED or EARLY. Why it ended, when known, is a structured cause. The kind of the cause is one of these values:

  • THREAT_SIGNAL, with the signals P, X or A
  • FIX_READY, with the vendors whose readiness made the quorum
  • FIX_DEPLOYED
  • OTHER

Every cause is EARLY, and an END_TIME_REACHED termination has none. The termination message carries the what as content and the why as terminationCause.

Requirements

ID Priority Requirement Related
EMB-13-004 MUST A termination Remove(EmbargoEvent) MUST carry what ended the embargo in content, exactly END_TIME_REACHED or EARLY. Its summary carries a human-readable account the protocol does not read.

The what is all a receiver needs to apply a termination and to check it against the end time; the why records the decision. A cause is a kind with its own details, so a new cause (adversary awareness, exploit code held by adversaries, a participant's leak) is a new kind rather than a change to a closed list (ADR-0122).
EMB-13-009 MUST A receiver MUST refuse, at the parse edge, a termination Remove(EmbargoEvent) whose content is anything other than END_TIME_REACHED or EARLY (EMB-13-004).

The what is all a receiver needs to apply a termination and to check it against the end time, so a termination without a valid what cannot be applied.
Extends: EMB-13-004
EMB-13-010 MUST The TERMINATED register entry MUST record the termination's reason (the what) and, when known, a structured cause (the why). The cause is an object discriminated on kind, whose details depend on the kind. One kind is THREAT_SIGNAL, with the signals (P, X, A) that ended the embargo, distinct and in that order. Another, FIX_READY, has the vendor participants whose readiness made the quorum (VP-09-007). The other kinds are FIX_DEPLOYED, and OTHER, whose account is the summary.

The why records the decision. A cause is a kind with its own details, so a new cause (adversary awareness, exploit code held by adversaries, a participant's leak) is a new kind rather than a change to a closed list (ADR-0122).
Extends: EMB-13-004
See also: VP-09-007 — context for the reader
EMB-13-011 MUST NOT An END_TIME_REACHED termination MUST NOT record a cause (EMB-13-010). Every cause kind is EARLY, and an EARLY termination with no cause is valid and records the what alone.

A cause explains why an embargo ended before its end time. An embargo that ran to its end time has no such cause.
Extends: EMB-13-010
EMB-13-005 MUST A termination Remove(EmbargoEvent) whose termination has a cause (EMB-13-010) MUST carry it as terminationCause.

One ledger entry is one activity, and the termination's entry is the whole TERMINATE register step (ADR-0124), so the why reaches a replica replaying the ledger only if the Remove carries it. A threat signal is a fact about the case that every participant learns from a status entry; naming it on a Remove while the case status does not show it would leave the register and the status disagreeing, and reading the Remove as a status change would commit one no participant sent (ADR-0122).
Uses definition from: EMB-13-010 — Carries the recorded cause on the wire so replicas can copy it
EMB-13-012 MUST At the parse edge, a receiver MUST refuse a bad terminationCause (EMB-13-005). A cause is bad when its kind is unknown, when a detail is missing or malformed, or when the termination is END_TIME_REACHED.

A cause the receiver cannot read, or one on a termination that can have none (EMB-13-011), would put a TERMINATED entry in the register that no other node can reproduce.
Extends: EMB-13-005
EMB-13-013 MUST A FIX_READY, FIX_DEPLOYED or OTHER cause on the Case Owner's Remove to the CASE_MANAGER is the owner's claim. The CASE_MANAGER MUST record it as given.

These causes are the owner's account of its own decision, which the CASE_MANAGER has no grounds to check against its own view of the case.
Extends: EMB-13-005
EMB-13-014 MUST The CASE_MANAGER MUST refuse a THREAT_SIGNAL cause on the Case Owner's Remove before it is committed. The refusal's reason directs the sender to a case status update that sets P, X or A, the way a threat signal ends an embargo.

A threat signal is a fact about the case that every participant learns from a status entry. Naming it on a Remove while the case status does not show it would leave the register and the status disagreeing, and reading the Remove as a status change would commit one no participant sent (ADR-0122).
Extends: EMB-13-005
EMB-13-015 MAY A Remove that the CASE_MANAGER sends MAY name THREAT_SIGNAL as its cause. No other Remove names it (EMB-13-014).

The CASE_MANAGER ends an embargo on a threat signal it has adopted into the case status, so its Remove and the status agree.
See also: EMB-13-014 — context for the reader
EMB-13-016 MUST A replica MUST record, on its TERMINATED entry, the cause that the termination's ledger entry carries.

One ledger entry is one activity, and the termination's entry is the whole TERMINATE register step (ADR-0124), so the why reaches a replica replaying the ledger only if the Remove carries it.
Extends: EMB-13-005
EMB-13-017 MUST NOT A replica MUST NOT work a termination cause out from its own case state.

A replica's own view can differ from the CASE_MANAGER's, such as threat signals its PXA does not carry. A cause it worked out would then disagree with the CASE_MANAGER's TERMINATED entry (CM-23-016).
Extends: EMB-13-016

Register status is not EM state

The register statuses and the EM states share the words proposed and active, but they name different things. Register status ACTIVE is one embargo in force. EM ACTIVE is the case with an embargo in force and no revision open. A case whose register holds one ACTIVE entry and one PROPOSED entry is at EM Revised, not EM Active.

7.1.2 Deriving EM from the Register

The case's EM state is a read of its register's statuses, never set directly:

ACTIVE entries PROPOSED entries TERMINATED entries EM
0 0 0 None
0 ≥1 0 Proposed
1 0 0 Active
1 ≥1 0 Revised
0 0 1 Exited

REJECTED, SUPERSEDED and CANCELLED entries do not move EM. A register that breaks an invariant matches no row, and the derivation refuses it. The case's status carries a copy of the derived EM, stamped from the register. A received status can report EM, but only a register step moves it.

Because EM aggregates over every entry, the case moves from Proposed or Revised to None or Active only when no proposal remains open. Rejecting one of several open proposals leaves the others open, so EM stays where it was. Activating one of several open proposals leaves the rest open as revisions of the embargo now in force, so EM moves to Revised rather than Active. An ACTIVE entry leaves that status only when another entry supersedes it or when it is terminated. A case that has had an embargo in force therefore never returns to None or Proposed.

7.2 Transitions and Guards

Four triggers drive the machine: propose, accept, reject and terminate. The register computes EM, and the table below constrains how EM moves. Every register step names its EM trigger, and a step whose EM move is not in the table writes nothing. Register steps map to EM triggers as follows:

  • A proposal is propose. A proposal of terms the case already holds is not propose, and changes nothing (EP-09-032). Its end time repeats that of a pending proposal, or, with no revision pending, that of the embargo in force.
  • An activation is accept.
  • A rejection is reject. The cancellation of open proposals with no embargo in force is also reject.
  • A termination is terminate.

Every transition is a change to shared case state, so the CASE_MANAGER applies it. Every replica applies the same check when it copies the step from the case ledger. A participant causes a transition by sending the corresponding message, not by writing the state itself.

---
title: Embargo Management State Diagram
---
stateDiagram-v2
    direction LR
    [*] --> None
    state Pre-Embargo {
        None --> Proposed : propose
        Proposed --> Proposed : propose
        Proposed --> Proposed : reject
        Proposed --> None : reject
    }
    state Active_Embargo {
        Active --> Revise : propose
        Revise --> Active : accept
        Revise --> Active : reject
        Revise --> Revise : propose
        Revise --> Revise : accept
        Revise --> Revise : reject
        Revise --> eXited : terminate
        Active --> eXited : terminate
    }
    state Post-Embargo {
        eXited
    }
    Proposed --> Active : accept
    Proposed --> Revise : accept
    eXited --> [*]

The diagram shows every move of the EM transition table. A self-loop on reject or accept is the move made while another proposal is still open, and accept from Proposed reaches Revise when the other open proposals become revisions of the embargo now in force.

From Trigger To Notes
None propose Proposed
Proposed propose Proposed A further proposal is added beside the open ones
Proposed reject None The last open proposal is rejected, and no terms were ever in force
Proposed reject Proposed Another proposal is still open
Proposed accept Active No other proposal is open
Proposed accept Revised The other open proposals become revisions of the embargo now in force
Active propose Revised Proposing against an active embargo opens a revision
Revised propose Revised
Revised reject Active The last open revision is rejected, and the prior terms stand
Revised reject Revised Another revision is still open
Revised accept Active The revised terms replace the prior ones, and no other revision is open
Revised accept Revised The revised terms replace the prior ones, and another revision is still open
Active terminate Exited
Revised terminate Exited Every open revision is canceled in the same step

Requirements

ID Priority Requirement Related
EMB-18-005 MUST Every change to a case's embargo register MUST move the case's EM state only along an EM transition for the change's EM trigger: a proposal is propose, an activation is accept, a rejection, or the cancellation of open proposals with no embargo in force, is reject, and a termination is terminate. The EM transitions are propose: N→P, P→P, A→R, R→R; reject: P→N, P→P, R→A, R→R; accept: P→A, P→R, R→A, R→R; and terminate: A→X, R→X. A rejection leaves Proposed, and a rejection or an acceptance leaves Revise, only when no proposal remains open; an acceptance from Proposed moves to Active, or to Revise while another proposal stays open.

EM is computed from the embargo register (ADR-0122), not replaced by it: the EM state machine remains the protocol's model, and the register is a layer beneath it. With several proposals open, rejecting or activating one leaves the others open: a rejection keeps EM in Proposed or Revise until the last one is off the table, and an activation from Proposed puts the embargo in force with the others pending as revisions, in Revise (ADR-0130).
Extends: EMB-18-001

Each participant's replica of the case moves along the same table when it copies a step from the case ledger. The requirements below state each move from the side of a participant that receives the message, with the CASE_MANAGER's ledger commit as the acknowledgment.

Requirements

ID Priority Requirement Related
EMB-01-001 MUST A Participant in EM None (q^em ∈ N) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EP MUST transition their EM state to Proposed (q^em N → P). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009).

EP is the EM message that initiates embargo negotiation. When no embargo exists and the case is still pre-public, the receiver transitions to Proposed to signal they are evaluating the proposal.

ECA Details

Preconditions

- EM state is None; CS matches pattern ...pxa
- EM state: NONE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from NONE to PROPOSED → Receiver EM state is PROPOSED
2. [receiver] CASE_MANAGER commits the received EP and adds the entry to the ledger (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is PROPOSED; EK discharged by the ledger commit

Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
Uses definition from: EP-09-009
EMB-01-003 MUST A Participant already in EM Proposed (q^em ∈ P) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving a second or counter EP MUST stay in Proposed with no additional state transition. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Multiple EP messages can arrive during negotiation. When already in Proposed, no additional state transition is needed. The receiver evaluates the counter-proposal: it may answer the Invite with an Accept or a Reject of it, or counter, and the Case Owner decides the proposal for the case with EA or ER.

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...pxa
- EM state: PROPOSED
- CS pattern: ...pxa

Steps

1. [receiver] CASE_MANAGER commits the counter EP and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists; EM state remains PROPOSED

Postconditions

- EM state remains PROPOSED; counter-proposal terms available for evaluation; EK discharged by the ledger commit

Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-02-001 MUST A Participant in EM Proposed (q^em ∈ P) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EA MUST move their EM state along the accept transition of EMB-18-005: to Active (q^em P → A) when the accepted proposal was the last one open, and to Revise (q^em P → R) while another proposal stays open. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Every participant must agree on whether an embargo is in force. If the receiver kept EM at Proposed after the EA, it would act as if no embargo binds the case, and it could disclose while the other participants keep the vulnerability private. Another open proposal stays open as a revision of the embargo now in force, because the consent already given to its terms stays valid (ADR-0130). Revise records both facts. The ledger commit of the EA acknowledges it.

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...pxa
- EM state: PROPOSED
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from PROPOSED to ACTIVE → Receiver EM state is ACTIVE
2. [receiver] CASE_MANAGER commits the received EA and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is ACTIVE, or REVISE while another proposal is open; EK discharged by the ledger commit

Implements: VP-05-003 — An embargo SHALL begin at the moment it is accepted
Uses definition from: MSM-02-002 — EA shorthand wire-type mapping
Uses definition from: EP-09-009
Refines: EMB-18-005
See also: MSM-02-009 — context for the reader
EMB-06-001 MUST A Participant in EM Proposed (q^em ∈ P) receiving ER MUST move their EM state along the reject transition of EMB-18-005: back to None (q^em P → N) when the rejected proposal was the last one open, and staying in Proposed (q^em P → P) while another proposal is open. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

If the receiver stayed in Proposed after the last open proposal is rejected, it would wait for an answer that does not come, and it would show an embargo negotiation that has ended. None tells every participant that no embargo binds the case. While another proposal is open, EM stays in Proposed, because that proposal still waits for an answer (ADR-0130). The ledger commit of the ER acknowledges it.

ECA Details

Preconditions

- EM state is Proposed
- EM state: PROPOSED

Steps

1. [receiver] Transition EM state from PROPOSED to NONE → Receiver EM state is NONE
2. [receiver] CASE_MANAGER commits the received ER and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is NONE (proposal rejected), or PROPOSED while another proposal is open; EK discharged by the ledger commit

Uses definition from: MSM-02-006 — ER shorthand wire-type mapping
Uses definition from: EP-09-009
Refines: EMB-18-005
See also: MSM-02-009 — context for the reader
EMB-03-001 MUST A Participant in EM Active (q^em ∈ A) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EV MUST transition their EM state to Revise (q^em A → R). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

A participant must know that a change to the embargo is open while the current terms still bind it. Revise records both facts: an embargo is in force, and a revision of it waits for an answer. If the receiver stayed in Active, it could not tell that a later EC or EJ decides a revision. The revision does not change any participant's consent to the embargo in force until the Case Owner activates it (EP-05-002).

ECA Details

Preconditions

- EM state is Active; CS matches pattern ...pxa
- EM state: ACTIVE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from ACTIVE to REVISE → Receiver EM state is REVISE
2. [receiver] CASE_MANAGER commits the received EV and fans out its entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is REVISE; original embargo remains in force; EK discharged by the ledger commit

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-03-002 MUST A Participant already in EM Revise (q^em ∈ R) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving a counter EV (counter-revision) MUST stay in Revise with no additional state transition. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Multiple revision proposals can arrive. When already in Revise, no further state transition is needed; the receiver evaluates the counter-revision and answers its Invite with an Accept or a Reject of it, and the Case Owner decides the revision for the case with EC or EJ.

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa
- EM state: REVISE
- CS pattern: ...pxa

Steps

1. [receiver] CASE_MANAGER commits the counter EV and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists; EM state remains REVISE

Postconditions

- EM state remains REVISE; EK discharged by the ledger commit

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-04-001 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EJ for the last open proposal, it MUST move its EM state back to Active (q^em R → A). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), discharges "Emit EK". No EK message is emitted (EP-09-009, MSM-02-009).

EJ says that a revision proposal is rejected. A rejected revision leaves the embargo in force and the consent to it unchanged (EP-05-002), so when no other proposal is open, EM returns to Active under the terms it had. The CASE_MANAGER's commit and fan-out of the received activity tell every participant of the change, so no separate EK message is necessary (ADR-0113).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa
- EM state: REVISE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from REVISE back to ACTIVE → Receiver EM state is ACTIVE
2. [receiver] CASE_MANAGER commits the received EJ and fans out its entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is ACTIVE (revision rejected); EK discharged by the ledger commit

Uses definition from: MSM-02-004 — EJ shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-04-003 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EJ while another proposal is open, it MUST remain in Revise (q^em R → R) (EMB-18-005).

While another proposal stays open, EM stays in Revise, because the register still holds an open proposal (ADR-0130).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa; another proposal is open
- EM state: REVISE
- CS pattern: ...pxa

Postconditions

- Receiver EM state is REVISE

Refines: EMB-18-005
EMB-05-001 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EC for the last open proposal, it MUST move its EM state back to Active (q^em R → A) with the revised terms. The CASE_MANAGER's commit of the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase], fanned out as Add(CaseLedgerEntry), discharges "Emit EK". No EK message is emitted (EP-09-009, MSM-02-009).

EC says that the Case Owner activates a revision. The revised terms replace the terms in force, so when no other proposal is open, EM returns to Active under the revised terms. The CASE_MANAGER's commit and fan-out of the owner's Add tell every participant of the change, so no separate EK message is necessary (ADR-0113).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa
- EM state: REVISE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from REVISE to ACTIVE with revised embargo terms → Receiver EM state is ACTIVE; revised terms recorded
2. [receiver] CASE_MANAGER commits the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] and adds the entry to the ledger (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is ACTIVE with new terms; EK discharged by the ledger commit

Uses definition from: MSM-02-005 — EC shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-05-003 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EC while another proposal is open, it MUST remain in Revise (q^em R → R) under the revised terms (EMB-18-005).

The revised terms replace the terms in force at once. While another proposal stays open, EM stays in Revise, because the register still holds an open proposal (ADR-0130).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa; another proposal is open
- EM state: REVISE
- CS pattern: ...pxa

Postconditions

- Receiver EM state is REVISE with the revised terms

Refines: EMB-18-005
EMB-07-001 MUST A Participant in EM Active (q^em ∈ A) receiving ET MUST transition their EM state to Exited (q^em A → X). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

ET is the message that terminates an active embargo. The receiver records that the embargo has ended. ET has immediate effect regardless of other pending messages.

ECA Details

Preconditions

- EM state is Active
- EM state: ACTIVE

Steps

1. [receiver] Transition EM state from ACTIVE to EXITED → Receiver EM state is EXITED
2. [receiver] CASE_MANAGER commits the received ET and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is EXITED; EK discharged by the ledger commit

Uses definition from: MSM-02-007 — ET shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-07-002 MUST A Participant in EM Revise (q^em ∈ R) receiving ET MUST transition their EM state to Exited (q^em R → X). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

ET terminates the embargo regardless of whether a revision is pending. The revision proposal is abandoned upon termination.

ECA Details

Preconditions

- EM state is Revise
- EM state: REVISE

Steps

1. [receiver] Transition EM state from REVISE to EXITED → Receiver EM state is EXITED
2. [receiver] CASE_MANAGER commits the received ET and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is EXITED; pending revision abandoned; EK discharged by the ledger commit

Uses definition from: MSM-02-007 — ET shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-07-003 MUST A Participant already in EM Exited (q^em ∈ X) receiving ET MUST remain in Exited with no state transition. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Exited is already the terminal state, so a duplicate termination message needs no additional transition and no acknowledgment of its own.

ECA Details

Preconditions

- EM state is Exited
- EM state: EXITED

Steps

1. [receiver] Make no state change for the duplicate ET → EM state remains EXITED; no EK message exists

Postconditions

- EM state remains EXITED; no EK message emitted

Uses definition from: MSM-02-007 — ET shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader

Rejecting a revision does not end the embargo

Reject behaves differently depending on where it arrives. The difference is easy to get backwards.

From Proposed, rejecting the last open proposal returns the case to None. No terms were ever in force, so refusing them leaves the case with no embargo.

From Revised, rejecting the last open revision returns the case to Active, not to None. The Case Owner is refusing the proposed change, not the embargo. The previously agreed terms remain in force. An implementation that returns to None here silently drops an embargo that everyone still expects to hold.

Reaching Exited. Exited means that the embargo has ended at the case level. A participant does not put the case into Exited by deciding to stop observing the embargo. A participant can instead withdraw its own consent, report that it intends to exit, propose a shorter embargo, or propose an earlier end date. The CASE_MANAGER then terminates the embargo and records the termination (§11.2 Embargo Revision and Termination Cascades). An early termination takes Case Owner authorization by default, on the same terms as any other change to canonical case state (§11.3 Status Adoption: One Authorization Gate). The one exception is an embargo whose end time has passed: the CASE_MANAGER itself terminates it, with the reason END_TIME_REACHED.

Requirements

ID Priority Requirement Related
CM-02-005 MUST CASE_MANAGER MUST restrict the following activities to the Case Owner: case closure, approving an embargo proposal to become active on the case and terminating an active embargo, approving or rejecting participant invitations, case ownership transfer, and offering a participant an additional role (CM-33-002) (see CM-02-006 for the authorisation mechanism).

These actions decide who learns about the vulnerability, under what embargo, and who is responsible for the case. In CVD, the Case Owner makes these decisions. If any participant can start them through the CASE_MANAGER, a participant can close the case, change the embargo, admit a party that nobody checked, or take the case.
See also: CM-02-006 — context for the reader
EMB-13-003 MUST When the end time of the embargo in force has passed, the CASE_MANAGER MUST end it with the reason END_TIME_REACHED, through one idempotent termination path. Two ways reach that path. One is the CASE_MANAGER's own lazy check when it next handles the case, for an inbound activity or one of its own triggers. The other is an outside request to end the embargo at its end time, such as from a Sentinel that monitors embargo timers. A request to end the embargo early, made after its end time, takes the same path. Each way commits the CASE_MANAGER's Remove(EmbargoEvent) with content END_TIME_REACHED and runs the full termination cascade. The outside request is made to the CASE_MANAGER itself. A Remove from the Case Owner is the owner's own message, ledgered on receipt like any other.

VP-04-001 requires every accepted embargo to have an end time, so every embargo reaches one; recording the end as a termination keeps EM derived from the register, and lets the content gate stop withholding content under an embargo that has expired. The lazy check needs no scheduler; the outside request lets a deployment end an embargo on time without waiting for the next activity on the case. One path keeps the two from both committing: a register with a TERMINATED entry accepts no further change (ADR-0122).

ECA Details

Preconditions

- An embargo is in force and its end time has passed
- EM state: ACTIVE, REVISE

Postconditions

- The register's ACTIVE entry is TERMINATED with reason END_TIME_REACHED, every open proposal CANCELLED, EM EXITED, and the teardown announced

EMB-13-006 MUST Whichever of the lazy check and the outside request (EMB-13-003) arrives after the embargo has ended MUST commit nothing.

One path keeps the two from both committing: a register with a TERMINATED entry accepts no further change (ADR-0122).
Extends: EMB-13-003
EMB-13-007 MUST The CASE_MANAGER MUST answer an end-time request (EMB-13-003) that arrives after the embargo has ended as already done.

The requester asked for an outcome the case already holds, so the answer tells it the embargo is ended rather than refusing it.
Extends: EMB-13-003
EMB-13-008 MUST An END_TIME_REACHED termination claimed before the embargo's end time MUST be refused, by the CASE_MANAGER before it commits and by a replica that replays it.

An END_TIME_REACHED reason claims the end time has passed. A claim made before then is false, and the content gate would stop withholding content under an embargo that is still in force.
Extends: EMB-13-003
EMB-14-001 MUST An actor that ends an active embargo early of its own accord MUST name its reason: a deployed fix, a ready fix, or another reason.

Voluntary termination requires an auditable reason.

ECA Details

Preconditions

- EM state is Active or Revise
- EM state: ACTIVE, REVISE

Steps

1. [actor] Choose the termination reason (fix deployed, fix ready, or other) → Reason chosen

Postconditions

- A termination reason is chosen

EMB-14-005 MUST NOT An actor that names no reason MUST NOT end an active embargo early of its own accord.

A termination with no reason gives the other participants nothing to audit (EMB-14-001).

ECA Details

Postconditions

- EM state is unchanged

Derives from: EMB-14-001
EMB-14-006 MUST An actor that ends an active embargo early of its own accord MUST record its reason as the termination's cause (EMB-13-010). The cause is FIX_DEPLOYED, FIX_READY or OTHER respectively, never an EARLY termination with no cause.

Recording the chosen reason as the cause carries it to every participant through the termination's ledger entry, where a cause-less EARLY termination would tell them only that the embargo ended.

ECA Details

Steps

1. [actor] Terminate the embargo, recording the chosen reason as its cause → ET emitted carrying the cause; EM transitions to EXITED

Postconditions

- EM state is EXITED; ET queued; termination cause recorded

Extends: EMB-14-001
Uses definition from: EMB-13-010

Termination once P, X or A is canonical. The Case Owner uses its authority over this termination when the reported value is adopted, not after. Adopting a P, X or A value is the one authorization, and the CASE_MANAGER act that adopts the value also ends the embargo (§11.3 Status Adoption: One Authorization Gate, ADR-0210). So the Case Owner cannot keep an embargo once one of these values is canonical, and there is no decision to keep the embargo to record. A policy that must delay the termination decides at adoption, by not adopting the value yet. Attacks Observed differs from Public Aware and Exploit Public only at adoption: the CASE_MANAGER is recommended, not required, to adopt an A value and end the embargo.

Requirements

ID Priority Requirement Related
RSH-03-001 MUST The CASE_MANAGER MUST trigger embargo teardown when the canonical CaseStatus carries CS.P (public awareness), CS.X (exploit public), or CS.A (attacks observed).

All three flags signal a breach of the conditions that justify an active embargo. Covering only CS.P (as the prior PublicDisclosureBranchNode did) leaves exploit and attack signals without a teardown trigger.
CSB-12-001 MUST This rule covers the CASE_MANAGER when it adopts a P value (q^cs → ···P··) while an embargo is active (q^em ∈ {A, R}). Acting for the Case Owner, it MUST end the embargo immediately, by emitting ET in the act that adopts the value.

VP-09-001 requires immediate embargo termination upon public disclosure. Ending an embargo is the Case Owner's decision, and only the CASE_MANAGER writes shared EM state; it can be the Case Owner itself (EMB-03-003, ADR-0118). Adopting P also authorizes the termination (ADR-0210). A non-manager Participant reports P instead (CSB-12-005), and CSB-04-007 covers a received CP. CSB-12-004 orders the CS transition before the teardown.

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...P..
- EM state: ACTIVE, REVISE
- CS pattern: ...P..

Steps

1. [CASE_MANAGER] Adopt the P value into the canonical case status → Case CS public bit set to P
2. [CASE_MANAGER] Emit ET to terminate the embargo, in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- CS public bit is P; the CASE_MANAGER has emitted ET; EM is EXITED

Refines: VP-09-001 — Embargoes SHALL terminate immediately when information becomes public
CSB-13-002 MUST This rule covers the CASE_MANAGER when it adopts an X value (q^cs → ···PX·) while an embargo is active (q^em ∈ {A, R}). Acting for the Case Owner, it MUST end the embargo immediately, by emitting ET in the act that adopts the value.

VP-09-001 requires immediate embargo termination upon exploit publication. Ending an embargo is the Case Owner's decision, and only the CASE_MANAGER writes shared EM state; it can be the Case Owner itself (EMB-03-003, ADR-0118). Adopting X also authorizes the termination (ADR-0210). A non-manager Participant reports X instead (CSB-13-005), and CSB-05-008 covers a received CX. CSB-13-004 orders the CS transition before the teardown.

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...PX.
- EM state: ACTIVE, REVISE
- CS pattern: ...PX.

Steps

1. [CASE_MANAGER] Adopt the X value into the canonical case status → Case CS exploit bit set to X
2. [CASE_MANAGER] Emit ET to terminate the embargo, in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- CS exploit bit is X; the CASE_MANAGER has emitted ET; EM is EXITED

Refines: VP-09-001 — Embargoes SHALL terminate immediately when exploit becomes public
CSB-14-001 SHOULD This rule covers the CASE_MANAGER when it learns of an A value (q^cs → ·····A) while an embargo is active (q^em ∈ {A, R}). Acting for the Case Owner, it SHOULD end the embargo by adopting the value, in an act that emits ET.

VP-09-003 recommends ending the embargo when attacks are observed. It is SHOULD, not SHALL, to leave room for judgment. Under ADR-0166 that judgment is whether to adopt A: an adopted A ends the embargo in the same act (CSB-06-008, RSH-03-001). The Case Owner may delegate that decision in advance (RSH-07-003) and keeps the authority (VP-11-006). A non-manager Participant reports A instead (CSB-14-006).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern .....A
- EM state: ACTIVE, REVISE
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Adopt the A value into the canonical case status → Case CS attacks bit set to A
2. [CASE_MANAGER] Emit ET to terminate the embargo, in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- CS attacks bit is A; the CASE_MANAGER has emitted ET; EM is EXITED

Refines: VP-09-003 — Embargoes SHOULD terminate immediately when there is evidence of active exploitation

Open question: may the Case Owner delegate activating an embargo to the CASE_MANAGER?

Activating a proposed embargo is the Case Owner's decision for the case. The owner sends Add(EmbargoEvent) with target naming the VulnerabilityCase, and inReplyTo naming the Invite(EmbargoEvent) that proposed it. Ending an embargo can already be delegated: the CASE_MANAGER may send the Remove(EmbargoEvent) on the owner's behalf. Activation has no such path.

What is settled is how the owner's own answer bears on any activation. The owner's Accept(Invite(EmbargoEvent)) or Reject(Invite(EmbargoEvent)) is its consent as a participant, and its decision for the case never rewrites that answer. An owner that declined a proposal accepts it before it activates it. So if activation is ever delegated, only an owner that has accepted the proposal can authorize the CASE_MANAGER's Add.

Open: whether the owner may delegate activation at all; how a delegation is expressed on the wire, for example as part of the owner's published embargo policy or as an instruction for one case; and whether the CASE_MANAGER's Add names the owner's Accept or the proposal's Invite in inReplyTo. Once a resolution is reached, it will be reflected in this reference and in the embargo message requirements.

Embargo duration selection. Where several proposals are outstanding, the protocol recommends that participants accept the shortest and propose the remainder as revisions. The rule is a recommendation, so other policies remain admissible. An implementation can defer the choice to the Case Owner, or apply its own organizational policy. This specification does not mandate shortest-wins.

Requirements

ID Priority Requirement Related
EP-08-001 SHOULD This rule covers a case with two or more open embargo proposals and none accepted. A Participant SHOULD accept the proposal whose embargo end_time is earliest, and propose the remainder as revisions.

Two parties proposing 30 and 60 days agree on days 1–30 and disagree only beyond that, so accepting the shorter proposal captures all mutual agreement immediately and leaves the contested remainder to negotiate as a revision. This is the Shortest Embargo Proposed Wins heuristic stated in docs/topics/process_models/em/defaults.md, derived in docs/topics/process_models/em/formal_model.md, and applied to case growth in docs/topics/process_models/em/working_with_others.md.
EP-08-005 SHOULD This rule covers two or more revisions open against an active embargo. A Participant SHOULD accept or reject them one at a time, in earliest-to-latest end_time order.

Taking revisions shortest first applies the Shortest Embargo Proposed Wins heuristic (EP-08-001) to revisions: each accepted revision captures the agreement the longer ones also contain.

Tacit acceptance. A receiver can publish a default embargo policy, its actor default. Where it has, a sender that submits a report without proposing terms accepts that default, and the case begins with that embargo active.

Requirements

ID Priority Requirement Related
EP-01-001 MAY An Actor profile MAY include an embargo_policy field containing the Actor's structured embargo policy record inline. The policy is part of the profile: an Actor has at most one, and it is published, read and replaced as a field of the profile, not as a separate object.

Whoever holds an Actor's profile then holds its embargo terms, so carrying the profile (CP-01-010) carries the policy, and no lookup has to choose among several records.
EP-04-001 MUST When the CASE_OWNER's actor default embargo applies at case creation and the sender submitted no explicit embargo proposal, the case's initial EM state MUST be EM.ACTIVE, not EM.PROPOSED. The sender's report submission without a counter-proposal constitutes tacit acceptance of the CASE_OWNER's actor default embargo.

A sender that submits a report without terms of its own has nothing to object to in the receiver's default, so nobody is left to accept it. A case left at EM.PROPOSED would wait for an answer nobody owes, with no embargo in force at the moment the report is most sensitive.
Refines: DUR-07-003

A protocol default applies when nobody proposes anything. Where neither party proposes terms and the receiver has published no default, an embargo-eligible case still begins with an active embargo, at a short duration fixed by the protocol rather than by either party. The duration is no less than 72 hours and no more than 5 days. Where the case is not embargo-eligible (the vulnerability is public, an exploit is public, or attacks are observed), no embargo is established and the case remains in None.

The protocol default is not a proposal. It takes no part in the shortest-wins comparison above. If it did, a default short enough to be useful would win against every longer proposal and cap every embargo at its own length. The protocol default is also not a minimum. A party that proposes a shorter duration gets the duration it proposed.

Requirements

ID Priority Requirement Related
EP-04-005 MUST A protocol default embargo duration MUST exist.

The goal of the EM process is to lock in an embargo as early as possible (docs/topics/process_models/em/principles.md). Without a protocol default, a case with no embargo proposal and no actor default would have no embargo at all.
EP-04-018 MUST The protocol default embargo duration MUST be no less than 72 hours and no more than 5 days.

The 72-hour floor equals the default EP-07-002 minimum RSVP window, so the shortest embargo the protocol produces is as long as the shortest answer window it grants. The 5-day ceiling keeps a deployment from restoring a default generous enough to make publishing nothing better than publishing a policy.
Extends: EP-04-005
EP-04-019 MUST This rule covers an embargo-eligible case created with no embargo proposal and no actor default. The CASE_MANAGER MUST activate an embargo of the protocol default duration, so the case begins at EM.ACTIVE.

A case with no embargo is the outcome the process exists to avoid, and reaching it through mutual silence is the least deliberate way to arrive there.
Extends: EP-04-005
EP-04-006 MUST NOT The protocol default MUST NOT participate in the shortest-wins comparison of EP-04-003. It is the value applied when no proposal and no actor default applies, never a candidate within that comparison.

A 72-hour protocol default that competed under shortest-wins would win against every longer proposal and cap every embargo in the system at 72 hours, so no longer embargo could ever be agreed. The protocol default answers "what if nobody said anything", not "whose terms are shortest". See ADR-0096.
Derives from: EP-04-003
EP-04-007 MUST NOT The CASE_MANAGER MUST NOT clamp a proposal or actor default that is shorter than the protocol default up to it. It honors that term at its stated duration.

em/principles.md requires embargo duration be "limited to the shortest duration possible", and a Participant is free to set their own terms. EP-04-005's range bounds what the fallback may be configured to; it does not constrain what parties may agree. A reporter who proposes 12 hours gets 12 hours. See ADR-0096.
EP-04-008 MUST NOT The CASE_MANAGER MUST NOT apply the protocol default to a case that is not embargo-eligible. Such a case has P, X or A set at creation.

VP-06-001 already forbids proposing or accepting an embargo negotiation once the vulnerability is public, exploit code is public, or attacks are observed (EMB-01-002 is the accept half of the same prohibition). An embargo on an already-public vulnerability protects nothing, so the protocol default inherits that guard rather than bypassing it. See ADR-0096.
Refines: VP-06-001
EP-04-020 MUST When any of P, X or A is set at case creation, the CASE_MANAGER MUST leave the case at EM.NONE.

VP-06-001 forbids proposing or accepting an embargo once the vulnerability is public, exploit code is public, or attacks are observed. An embargo on an already-public vulnerability protects nothing, so the case starts with none.
Refines: VP-06-001

Outside these two default paths, the protocol recommends that participants accept or reject embargo proposals explicitly, within the period their disclosure policy defines or 14 days, whichever is shorter.

Requirements

ID Priority Requirement Related
VP-06-004 SHOULD Participants SHOULD explicitly accept or reject embargo proposals within the period defined in their VDP or within 14 calendar days of receipt, whichever is shorter.

An open proposal leaves everyone unsure whether information may be shared. A bounded reply time, never more than 14 days, makes the outcome known soon enough for participants to plan.

The two machines answer different questions. Embargo Management says whether the case has an embargo. Embargo consent (§9 Participant Embargo Consent (PEC) State Machine) says whether a given participant has agreed to a given embargo. Neither machine determines the other, so both are needed.

Both read the same register. A participant has one consent row per register entry. Whether the participant is a signatory or has lapsed is read from its rows and the register, not stored (§9.3 Signatory and Lapsed). Two register steps change who is bound. Only one of them writes rows:

  • Activating a revision that ends later than the terms it replaces binds only participants that agreed to the revision. A signatory to the replaced terms that has not agreed to the revision has lapsed. Its agreement covered the previous, shorter terms. A revision that ends no later than the terms it replaces carries every signatory over. The step writes a CARRY_OVER on the row of each signatory for the revision. Proposing a revision changes no one's consent to the embargo in force.
  • Terminating the embargo leaves no entry ACTIVE, so nobody is a signatory and nobody has lapsed. The termination writes no consent row, and every row for a final entry is frozen as it stood.

Requirements

ID Priority Requirement Related
EP-05-001 MUST NOT This rule covers the Case Owner's activation of a revised embargo that ends later than the embargo it replaces (REVISE → ACTIVE). The CASE_MANAGER MUST NOT carry any participant's consent over to it.

A participant who signed for terms T1 has not consented to longer terms T2; treating them as a signatory once T2 is in force would imply consent they never gave. A participant is bound by the revised embargo only through an AGREED consent row for it, so each signatory to the replaced embargo that has not agreed to the revised one has lapsed (CM-18-001), and no write is needed to lapse them. The rule applies at activation rather than at proposal because the participant remains bound by T1 for as long as T1 is the active embargo (ADR-0093, ADR-0122).
Uses definition from: CM-18-001
EP-05-003 MUST This rule covers the Case Owner's activation of a revised embargo that ends no later than the one it replaces. The CASE_MANAGER MUST apply CARRY_OVER to the revised embargo's row of each participant with an AGREED row for the replaced embargo. That includes a participant whose row for the revision is DECLINED (CM-10-001, CM-18-003, MSM-07-005).

Shorter terms ask nothing new: agreeing to N days is agreeing to every shorter period, the same containment that makes shortest-wins (EP-04-003) safe without asking anyone, so their agreement is carried over by writing the row. That holds for a participant that declined the shorter revision too: its decline objected to losing time, not to keeping the embargo, and the decline stays in the ledger (ADR-0122).
Uses definition from: CM-18-001
Uses definition from: CM-18-003
Refines: MSM-07-005
See also: CM-10-001 — context for the reader
EP-05-002 MUST NOT A revision proposal (ACTIVE → REVISE) and any further counter-revision (REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force. The proposer's row for the proposed embargo becomes AGREED (MSM-07-022). Every other participant gets an UNINVITED row for it (CM-18-001). Every other row stays as it is until the Case Owner activates a revision (EP-05-001, EP-05-003). Until then the prior embargo stays in force, and every signatory to it remains one.

A participant cannot lapse until the embargo on the case differs from the one they agreed to. Lapsing on proposal would strand signatories when the revision is rejected, report participants who are still bound and still receive embargoed content as not bound, and lapse the proposer of the revision (ADR-0093). With per-embargo rows a proposal only ever adds rows for the proposed embargo.
Uses definition from: CM-18-001
Refines: MSM-07-022
See also: EP-05-001 — scope boundary: a different transition
See also: EP-05-003 — context for the reader
MSM-07-006 MUST When an ET / REMOVE_EMBARGO_EVENT_FROM_CASE wire activity terminates the embargo register's ACTIVE entry, implementations MUST leave the case with no active embargo. The same step cancels every open proposal, so the derived EM becomes EXITED. No separate outbound wire activity is emitted; the participant position is derived from the case.

A register with a TERMINATED entry accepts no further change (ADR-0122), so a terminated embargo can never be invited to again. That is a fact about the case, which every replica holds once it replays the teardown.
Uses definition from: MSM-02-007
MSM-07-025 MUST NOT When an ET terminates the embargo register's ACTIVE entry, implementations MUST NOT write any participant's consent rows. With no active embargo no participant is a signatory and no row binds anyone. An Accept or Reject that arrives afterwards records nothing (EMB-17-004).

The termination is a fact about the case, so it does not need copying onto each participant record as a terminal consent state. Leaving the rows as they were also keeps the history of who agreed to what, and every row of a final entry is frozen (CM-18-003).
Extends: MSM-07-006
See also: EMB-17-004 — context for the reader

§11.2 Embargo Revision and Termination Cascades specifies both cascades.


8. Case State (CS) Dimensions [N]

Case State records what is known about the vulnerability. It answers two different questions, and it is a compound of two machines because those questions have different owners.

The first is what each vendor has done about the vulnerability: is it aware, does it have a fix, has the fix been deployed? That is participant-specific — each participant answers for itself. The second is what the world knows: is the vulnerability public, is there a public exploit, are attacks happening? That is a fact about the world, shared by the whole case.

The two are tracked separately, as VFD and PXA. Confusing them is the most consequential error in this part of the model: it leads an implementation to record one participant's action as a change to the state of the world, or to treat a world event as though some participant caused it.

Requirements

ID Priority Requirement Related
CM-03-004 MUST CS (PXA sub-state) MUST be participant-agnostic (shared per case)

Public awareness, exploit publication and attacks in the wild are facts about the world, not about one participant. When the vulnerability is public, it is public for all participants. A copy for each participant can only disagree with the facts.
CM-03-005 MUST VFD (Vendor Fix Deployment) state MUST be participant-specific

Fix readiness and deployment are different for each participant. One vendor can ship a fix before another vendor, and a deployer has its own deployment state. A shared VFD state would let the progress of one participant show as the progress of another (ADR-0075).
CM-04-006 MUST NOT A participant-specific transition (RM or VFD) MUST NOT change any case-level (participant-agnostic) state (EM or PXA).

Participant-specific state and case-level state are separate by design (CM-03-002 through CM-03-005). If an RM or VFD transition of one participant wrote across this boundary, it could change the shared embargo or public state.
Satisfies: VP-13-009
CM-04-010 MUST NOT A case-level transition (EM or PXA) MUST NOT change any participant-specific state (RM or VFD).

Participant-specific state and case-level state are separate by design (CM-03-002 through CM-03-005). If a shared event wrote across this boundary, it could overwrite the progress of one participant.
Extends: CM-04-006

8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed

VFD records what a specific participant has done, so each participant has its own value. It moves in one direction only, and through its states in a fixed order: a vendor is aware before a fix can be ready, and a fix is ready before it can be deployed. That ordering leaves four reachable states rather than eight.

State Vendor Aware Fix Ready Fix Deployed
vfd no no no
Vfd yes no no
VFd yes yes no
VFD yes yes yes

Because the axes are ordered, the state is written as a single three-letter token in which case indicates progress: Vfd means the vendor is aware, the fix is not ready, and nothing is deployed.

Requirements

ID Priority Requirement Related
CSB-17-006 MUST An implementation MUST NOT allow a fix to be ready while the vendor is unaware (the vF compound state is impossible).

Fix readiness presupposes vendor awareness; the vF combination is structurally excluded from the 32 valid compound CS states.
CSB-17-007 MUST An implementation MUST NOT allow a fix to be deployed that was never ready (the fD compound state is impossible).

Fix deployment presupposes fix readiness; the fD combination is structurally excluded from the 32 valid compound CS states.

Which participant can cause which VFD transition depends on the roles it holds, and is specified at §13.4.1 Participant-Specific CS Transitions (VFD).

8.2 PXA — Public Aware, Exploit Public, Attacks Observed

PXA records the state of the world, not the state of any participant. There is one PXA value for the case, it is shared case state, and only the CASE_MANAGER writes it (§10.1 Single-Writer Authority).

Unlike VFD, the three axes are independent: any combination can occur, in any order.

Axis Not yet Set Meaning when set
Public Aware p P The vulnerability is known outside the case participants
Exploit Public x X An exploit for the vulnerability has been published
Attacks Observed a A Attacks exploiting the vulnerability have been seen

Independence gives PXA eight states — every combination of the three, written by setting each letter to upper or lower case: pxa, Pxa, pXa, pxA, PXa, PxA, pXA, PXA.

---
title: pxa State Diagram
---
stateDiagram-v2
    direction LR
    [*] --> pxa

    pxa --> Pxa : P
    pxa --> pXa : X
    pxa --> pxA : A

    pXa --> PXa : P
    pXa --> pXA : A

    pxA --> PxA : P
    pxA --> pXA : X

    Pxa --> PxA : A
    Pxa --> PXa : X

    pXA --> PXA : P
    PXa --> PXA : A
    PxA --> PXA : X
    PXA --> [*]

A PXA observation is not tied to any participant's role, because a PXA fact is not any participant's to own — anyone can notice that an exploit has appeared. Reporting is not the same as the case adopting the observation (§13.4.2 Participant-Agnostic CS Transitions (PXA), §11.3 Status Adoption: One Authorization Gate).

Two PXA states are passed through, not rested in

Publishing an exploit makes the vulnerability public. The two states in which an exploit is public while the public is unaware — pXa and pXA — therefore describe a situation that does not persist: they resolve to PXa and PXA. A participant that records an exploit as public records public awareness in the same step, so a case never rests in either state.

The reverse does not hold. Attacks being observed does not by itself make the vulnerability public: an attack can be detected without its mechanism being understood or disclosed. pxA is a state a case can legitimately rest in.

Requirements

ID Priority Requirement Related
CSB-13-001 MUST A Participant whose CS sets the exploit bit while the public bit is unset (···px·) MUST also trigger CS→P (the pX→PX invariant). It triggers CS→P before or with the exploit transition.

The ephemeral state ···pX· (exploit public without public awareness) cannot exist as a stable state. Constraint C-15 requires the transition to be ···px· → ···PX·, not ···px· → ···pX· → ···PX·. Observable consequence: CX emitted from ···px· state must be accompanied by CP. The precondition uses the post-transition pattern ···pX· (X uppercase, P lowercase) since state_entered fires after the X bit is set.

ECA Details

Preconditions

- CS matches pattern ...pX.
- CS pattern: ...pX.

Steps

1. [participant] Emit CX to announce exploit public transition → CX queued for case participants
2. [participant] Emit CP to announce public aware transition (C-15 constraint) → CP queued for case participants

Postconditions

- CS is ···PX·; CX and CP both emitted; pX→PX invariant satisfied

CSB-13-006 MUST A Participant MUST treat the compound transition of CSB-13-001 as atomic, so that it sets the P and X bits together.

If the P and X bits were set in two steps, the participant would pass through the ephemeral state ···pX·, which cannot exist as a stable state (C-15). The write is the exception CSB-17-002 names, and it loses no ordering: ···pX· has one forced successor (CSB-17-012), so a replay recovers X, then P.

ECA Details

Preconditions

- CS matches pattern ...pX.
- CS pattern: ...pX.

Steps

1. [participant] Transition CS to ···PX· (set both public bit P and exploit bit X atomically) → Receiver CS public bit P and exploit bit X both set

Postconditions

- CS is ···PX·, with no stored ···pX· state

Refines: CSB-13-001
Supersedes: CSB-17-002
Supersedes: CSB-17-008
CSB-17-003 MUST An implementation MUST treat the compound states vP (public aware while the vendor is unaware) and pX (exploit public while the public is unaware) as ephemeral.

Neither condition can persist in reality: public awareness reaches the vendor, and a published exploit makes the public aware. Modelling these as ephemeral rather than invalid preserves the causal ordering of the events while forbidding the case from progressing in any other direction first. The pX ephemeral rule is the pX to PX invariant of CSB-13-001 generalised from the entry cascade to every successor of a pX state.

ECA Details

Preconditions

- The case is in one of the 12 ephemeral compound CS states

Postconditions

- Each ephemeral state has exactly one valid successor state

Extends: CSB-13-001
CSB-17-012 MUST From a pX state the next CS event MUST be P.

The forced-successor rule for pX states enforces the pX→PX invariant; pX is ephemeral and P is the only valid continuation.
Refines: CSB-17-003
CSB-17-013 MUST Any CS event other than the forced successor MUST be rejected when the current state is ephemeral (vP or pX).

Accepting any other event would break the vP→VP and pX→PX invariants that the forced-successor rule exists to enforce.
Refines: CSB-17-003

8.3 Case State as a Compound Tuple

Case State is the pair CS = (VFD, PXA), giving 4 × 8 = 32 compound states.

Not every ordering among them is reachable. Each CS event changes one of the six dimensions, once, from not yet happened to happened. The VFD order of §8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed holds in every compound state. Two compound states are ephemeral, and each one has a single forced next event. vP, public awareness while the vendor is unaware, is resolved by Vendor Aware. pX, a public exploit while the public is unaware, is resolved by Public Aware. When a participant writes its own status and the write would enter an ephemeral state, the write also applies the forced event, so that single write changes more than one dimension. A write that sets X while P is unset also sets P, and a write that sets P while V is unset also sets V. This compound write is the one exception to the one-dimension rule. It loses no ordering, because each ephemeral state has only one possible next event. A status received from another participant is that participant's claim, and the receiver records it exactly as sent. When the CASE_MANAGER adopts the claim, the case status it records is in the forced form: a claim of pXa makes the case PXa. A reported CS history is checked by replaying its events in order from vfdpxa, not by comparing timestamps.

Requirements

ID Priority Requirement Related
CSB-17-001 MUST An implementation MUST treat exactly 32 compound CS states as valid: the cross product of the 4 valid VFD states (vfd, Vfd, VFd, VFD) and the 8 PXA states.

The VFD dimension is a linear chain, not a free product of three bits: readiness presupposes awareness and deployment presupposes readiness. Enumerating only the reachable combinations makes the two impossible combinations unrepresentable rather than merely rejected at runtime, which is why CS_vfd has four members and not eight.

ECA Details

Postconditions

- The CS enum has exactly 32 members, one per valid compound state

Refines: SM-09-002 — SM-09-002 states the vF/fD prohibition as a rejection rule; this refines it to a structural guarantee by enumerating only the 32 reachable combinations, so the impossible ones are unrepresentable.
CSB-17-002 MUST A CS transition MUST change exactly one of the six CS dimensions. The one exception is a compound transition, as in CSB-13-006. It applies an event together with the forced successor of the ephemeral state (CSB-17-003) that the event would enter.

CS events are irreversible and are observed one at a time; a compound state change of Hamming distance greater than one conflates two distinct events and loses their ordering, which is exactly the information history validity depends on. These two conditions alone admit 72 transitions; applying the ephemeral-state rule of CSB-17-003 leaves exactly 58 valid CS transitions.

ECA Details

Preconditions

- A (source, destination) pair of compound CS states

Steps

1. [validator] Identify the single dimension that differs between source and destination; reject if more than one differs. If none differs, the write is a same-state re-assertion, which CSB-16-001 and CSB-16-002 permit as a status confirmation: accept it only when the caller has opted in (the allow_null parameter), and reject it otherwise, because a transition validator's default answer for "no change" must be "that is not a transition". → A single CS event accounts for the change, or the caller has explicitly asked for same-state writes to pass
2. [validator] Delegate to the changed dimension's own transition table (is_valid_vfd_transition or is_valid_pxa_transition). → Monotonicity and VFD prerequisite ordering are enforced
3. [validator] Apply the ephemeral-state rule of CSB-17-003 to the source state. → A transition out of a vP or pX state fires only the event that state requires

Postconditions

- Only Hamming-distance-1 monotone transitions are accepted

Constrains: CSB-16-001 — Adds the one-dimension-at-a-time and monotonicity constraints that a per-dimension write validator cannot see. The same-state write CSB-16 permits is preserved via the opt-in described in step 1.
Constrains: CSB-16-002
Uses definition from: CSB-17-003
CSB-17-014 MUST A CS transition MUST change its one dimension from the not-yet-happened value to the happened value.

CS events are irreversible, so a change from the happened value back to the not-yet-happened value describes no event. With CSB-17-002 this condition admits 72 transitions, and the ephemeral-state rule of CSB-17-003 leaves 58.

ECA Details

Postconditions

- Only monotone transitions are accepted

Extends: CSB-17-002
CSB-17-008 MUST A CS transition that changes two or more dimensions at once, that reverses a dimension, or that skips a VFD prerequisite MUST be rejected. The compound transition of CSB-13-006 is exempt from the multi-dimension form only.

Each of the three prohibited forms conflates or reorders distinct causal events; rejecting them enforces the one-event-at-a-time and monotonicity invariants.
CSB-17-009 MUST From a vP state the next CS event MUST be V.

The forced-successor rule is the operational consequence of CSB-17-003's ephemeral classification: each ephemeral state has exactly one valid continuation, enforcing the vP→VP invariant.
CSB-17-004 SHOULD A consumer validating a reported CS history SHOULD validate it causally by replaying the event sequence through CSB-17-002 and CSB-17-003 from the initial state vfdpxa, rather than checking states point-in-time or comparing wall-clock timestamps. A complete history contains all six CS events exactly once; there are exactly 70 valid complete histories out of 720 orderings.

Validity of a case trajectory is a property of the whole ordered sequence, not of any single state: VFDPXA and VFDXAP visit only valid states, but only the first is a possible case history. Wall-clock timestamps cannot substitute, because they may be missing, skewed, or recorded by different participants. SHOULD rather than MUST because a consumer holding only a current state, with no event log to replay, cannot do better.

ECA Details

Preconditions

- An ordered sequence of CS events, possibly incomplete

Steps

1. [validator] Reject any event that occurs more than once in the sequence → Each CS event happens at most once
2. [validator] Replay the sequence from vfdpxa, requiring each step to satisfy CSB-17-002 and CSB-17-003 given every event that preceded it. → Causally impossible orderings are rejected

Postconditions

- A complete valid history terminates in VFDPXA

Uses definition from: CSB-17-002
Uses definition from: CSB-17-003
CSB-17-005 MUST An incomplete CS history MUST be validated as a prefix.

Real cases are usually still in progress, so requiring six events would reject every live case. Ending in an ephemeral state is unavoidable at the prefix level: CSB-17-003's forced successor has not happened yet when the prefix is cut, which is different from an actor persisting an ephemeral state as its own — SM-09-003 still forbids that. Pinning acceptance to CSB-17-004's prefix closure keeps both directions honest: a validator that merely never rejects a genuine prefix could still accept dead ends.

ECA Details

Preconditions

- An ordered sequence of CS events with fewer than six entries

Steps

1. [validator] Apply CSB-17-004's replay to the sequence without requiring that it terminate in VFDPXA. → The prefix is accepted iff it is a prefix of at least one valid complete history

Postconditions

- A prefix ending in an ephemeral state is accepted, and its forced successor per CSB-17-003 is the only legal continuation

Refines: CSB-17-004

The orderings also constrain the embargo. Public awareness, a public exploit and observed attacks each end an active embargo. When the CASE_MANAGER adopts a status that sets one of them while an embargo is active, it terminates the embargo, and it records the CS change before the termination (§11.3 Status Adoption: One Authorization Gate). The embargo therefore ends after the CS change that ends it is recorded, not before.

Requirements

ID Priority Requirement Related
CSB-18-002 MUST NOT Once a CASE_MANAGER act commits, a participant's composite state MUST NOT have the PXA P-bit set (q^cs ∈ ···P··) while an active embargo exists (q^em ∈ {ACTIVE, REVISE}). Public awareness of a vulnerability while an embargo is active is causally impossible in a well-functioning coordination — the P event causes embargo termination, so EM cannot remain ACTIVE once P has occurred.

The P event (public awareness) makes the embargo end. An embargo that stays ACTIVE or REVISE after P is recorded is therefore a causal contradiction, and it misstates the case to every participant that reads it. The emit path does not refuse a P report while an embargo is active, because that report is what causes the embargo to end. The rule is judged per act, not per entry (ADR-0210): the adopting act writes its snapshot before the teardown (RSH-01-004).

ECA Details

Preconditions

- A PXA state and an EM state are both available for the same case

CSB-18-003 MUST NOT Once a CASE_MANAGER act commits, a participant's composite state MUST NOT have the PXA X-bit set (q^cs ∈ ···X·) while an active embargo exists (q^em ∈ {ACTIVE, REVISE}). Public exploit availability while an embargo is active is causally impossible — the X event entails embargo termination.

A public exploit lets attackers use the vulnerability, so secrecy no longer protects users. An embargo that stays ACTIVE or REVISE after X tells participants to keep a secret that attackers already have. It also holds back information that defenders need now, and it misstates the case to every participant that reads it. It is judged when an act commits, as CSB-18-002 is (ADR-0210).

ECA Details

Preconditions

- A PXA state and an EM state are both available for the same case

Derives from: CSB-18-002
CSB-18-004 MUST NOT Once a CASE_MANAGER act commits, a participant's composite state MUST NOT have the PXA A-bit set (q^cs ∈ ···A) while an active embargo exists (q^em ∈ {ACTIVE, REVISE}). Observed attacks while an embargo is active is causally impossible — the A event entails embargo termination.

Observed attacks show that the vulnerability is in use. An embargo that stays ACTIVE or REVISE after A holds back the information that defenders need to protect themselves while the attacks go on. It also misstates the case to every participant that reads it. It is judged when an act commits, as CSB-18-002 is (ADR-0210).

ECA Details

Preconditions

- A PXA state and an EM state are both available for the same case

Extends: CSB-18-002
CSB-04-007 MUST This rule covers a CASE_MANAGER whose RM state is not Closed (q^rm ∉ C) and whose EM is Active or Revise (q^em ∈ {A, R}). Its CS is not yet public (q^cs ∈ ···p··). On receiving CP, it MUST initiate embargo termination by emitting ET in the act that adopts the P value.

VP-09-001 requires immediate embargo termination when public awareness occurs. Only the CASE_MANAGER writes shared EM state, so it emits the ET when it records the P/X/A status (RSH-03-001, EP-09-008); it can be the Case Owner itself. A non-manager Participant reports the CS change and emits no ET (EMB-03-003, ADR-0118). Adopting P also authorizes the termination, so no second approval is asked (ADR-0210).
Refines: CSB-12-001 — The adoption of a received CP
CSB-05-008 MUST This rule covers a CASE_MANAGER whose RM state is not Closed (q^rm ∉ C) and whose EM is Active or Revise (q^em ∈ {A, R}). Its CS is not yet public and not yet exploit-public (q^cs ∈ ···px·). On receiving CX, it MUST initiate embargo termination by emitting ET in the act that adopts the X value.

VP-09-001 requires immediate embargo termination when exploit publication occurs. Only the CASE_MANAGER writes shared EM state, so it emits the ET when it records the P/X/A status (RSH-03-001, EP-09-008); it can be the Case Owner itself. A non-manager Participant reports the CS change and emits no ET (EMB-03-003, ADR-0118). Adopting X also authorizes the termination, so no second approval is asked (ADR-0210).
Refines: CSB-13-002 — The adoption of a received CX
CSB-06-008 MUST This rule covers a CASE_MANAGER whose RM state is not Closed (q^rm ∉ C) and whose EM is Active or Revise (q^em ∈ {A, R}). Its CS is not yet public and has no attacks observed (q^cs ∈ ···p·a). On receiving CA, it MUST initiate embargo termination by emitting ET in the act that adopts the A value.

Observed attacks warrant embargo termination (VP-09-003), and an active embargo cannot coexist with the attacks bit (CSB-18-004). Only the CASE_MANAGER writes shared EM state, so it emits the ET when it records the P/X/A status (RSH-03-001, EP-09-008); it can be the Case Owner itself. A non-manager Participant reports the CS change and emits no ET (EMB-03-003, ADR-0118). Adopting A also authorizes the termination, so no second approval is asked (ADR-0210).
Refines: CSB-14-001 — The adoption of a received CA
CSB-12-004 MUST This rule covers the CASE_MANAGER when it adopts a P value (q^cs → ···P··) while an embargo is active (q^em ∈ {A, R}). It MUST record the adopted P value before it ends the embargo under CSB-12-001.

Every replica replays the ledger in order, so a teardown committed ahead of its cause would show the embargo ending for no recorded reason. CSB-04-003 is the received transition this rule orders; the ledger mechanism is CLP-10-006.
Extends: CSB-12-001
CSB-13-004 MUST This rule covers the CASE_MANAGER when it adopts an X value (q^cs → ···PX·) while an embargo is active (q^em ∈ {A, R}). It MUST record the adopted X value before it ends the embargo under CSB-13-002.

Every replica replays the ledger in order, so a teardown committed ahead of its cause would show the embargo ending for no recorded reason. The received form of this rule is CSB-05-010; the ledger mechanism is CLP-10-006.
Extends: CSB-13-002
CSB-14-005 SHOULD This rule covers the CASE_MANAGER when it adopts an A value (q^cs → ·····A) while an embargo is active (q^em ∈ {A, R}). It SHOULD record the adopted A value before it ends the embargo under CSB-14-001.

Every replica replays the ledger in order, so a teardown committed ahead of its cause would show the embargo ending for no recorded reason. The received form of this rule is CSB-06-010; the ledger mechanism is CLP-10-006.
Extends: CSB-14-001
CSB-05-010 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Active or Revise (q^em ∈ {A, R}) receiving CX MUST record the CS transition to ···PX· before embargo teardown is initiated.

The ledger commits the CS state change before any effect acts on it (CLP-10-006), so every replica sees the cause before its effect.
CSB-06-010 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM Active or Revise (q^em ∈ {A, R}) receiving CA MUST record the CS transition to ···p·A before embargo teardown is initiated.

The ledger commits the CS state change before any effect acts on it (CLP-10-006), so every replica sees the cause before its effect.

8.4 Receiving CS Messages: Own State vs. Model of Others

A participant holds its own case state and a model of what it believes the other participants' states to be. Different events update each one.

  • Receiving a VFD message (CV, CF, CD) updates the receiver's model of the sender's VFD state. The receiver's own VFD state does not change. No acknowledgment is sent: a participant confirms it has the case history by the fact that its ledger replica is unbroken, not by acknowledging each entry (§4.11 Faults and Acknowledgments).
  • Driving one's own VFD transition happens locally, subject to the role requirements of §13.4.1 Participant-Specific CS Transitions (VFD), and is then announced.
  • PXA is shared case state, so an adopted PXA observation updates the case's canonical status rather than any per-participant model (§11.3 Status Adoption: One Authorization Gate).

Requirements

ID Priority Requirement Related
CSB-01-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) receiving CV MUST update their model of the sending Participant's CS state to Vendor Aware (q^cs ∈ Vfd···). No CK message is emitted (MSM-03-008). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), records it. Each replica acknowledges that entry by its unbroken hash chain (MSM-05-002).

CV announces a Vendor-specific CS transition. The receiver does not change their own CS state; they update their awareness model for the sender.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update model of sender's CS state to Vendor Aware (Vfd···) — receiver's own CS state is unchanged → Receiver's awareness model for sender reflects CS=Vfd
2. [receiver] CASE_MANAGER commits the received CV and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Sender's CS state recorded as Vfd; CK discharged by the ledger commit; receiver CS unchanged

Uses definition from: MSM-03-001 — CV shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-02-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) receiving CF MUST update their model of the sending Participant's CS state to Fix Ready (q^cs ∈ VFd···). No CK message is emitted (MSM-03-008). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), records it. Each replica acknowledges that entry by its unbroken hash chain (MSM-05-002).

CF announces a Vendor-specific CS transition. The receiver does not change their own CS state; they update their awareness model for the sender.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update model of sender's CS state to Fix Ready (VFd···) — receiver's own CS state is unchanged → Receiver's awareness model for sender reflects CS=VFd
2. [receiver] CASE_MANAGER commits the received CF and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Sender's CS state recorded as VFd; CK discharged by the ledger commit; receiver CS unchanged

Uses definition from: MSM-03-002 — CF shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-03-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) receiving CD MUST update their model of the sending Participant's CS state to Fix Deployed (q^cs ∈ VFD···). No CK message is emitted (MSM-03-008). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), records it. Each replica acknowledges that entry by its unbroken hash chain (MSM-05-002).

CD announces a Vendor-specific CS transition. The receiver does not change their own CS state; they update their awareness model for the sender.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update model of sender's CS state to Fix Deployed (VFD···) — receiver's own CS state is unchanged → Receiver's awareness model for sender reflects CS=VFD
2. [receiver] CASE_MANAGER commits the received CD and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Sender's CS state recorded as VFD; CK discharged by the ledger commit; receiver CS unchanged

Uses definition from: MSM-03-003 — CD shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CM-04-002 MUST A receiver processing a VFD state transition MUST update the VFD state in the participant status of the sending actor's CaseParticipant

VFD state is participant-specific (CM-03-005). A VFD message reports the fix readiness or deployment of the sender. A record on any other participant would claim a fix that this participant did not make.
Refines: SM-10-001
CM-04-004 MUST When the CASE_MANAGER adopts a PXA transition (public disclosure, exploit publication or attack observation), it MUST record the case-level PXA state in the case's CaseStatus. Every other replica takes that state from the CASE_MANAGER's ledger (RSH-08-003).

PXA state is a case-level fact (CM-03-004). A record of a reported disclosure, exploit or attack on the shared CaseStatus makes it visible to all participants at the same time. This is important because each of these events can end an embargo early. Only the CASE_MANAGER writes canonical case state (ADR-0108).
Refines: SM-10-002
See also: RSH-08-003 — context for the reader
CM-04-005 MUST A receiver processing a VFD or PXA transition MUST validate the requested transition against the authoritative current state before recording it

A transition is valid only from the current state of the case or participant. If the receiver records a transition without a check against the authoritative current state, a stale or out-of-order message can move the state backward or skip a necessary step. Every replica then copies the incorrect state.

An embargo binds the participants who agreed to it. Embargo Management (§7 Embargo Management (EM) State Machine) records whether the case has an embargo. It cannot record who has agreed, because that answer differs per participant. Participant Embargo Consent records it.

This distinction has practical consequences. A participant invited to a case that already has an active embargo has not yet agreed to anything. The CASE_MANAGER does not send that participant embargoed content until the participant agrees (§9.7 Gating Full Case Delivery). A participant that declines is still in the case and still receives the negotiation traffic (§9.5 Embargo Traffic Reaches Non-Signatories). The case-level embargo state cannot express either position.

Consent is per participant, but the CASE_MANAGER writes it. The CASE_MANAGER records consent on the participant's record in the case, next to the participant's other case state.

Informative: provenance

The original protocol design had four state machines and no consent machine. This machine emerged during implementation, when the case-level embargo state could not distinguish "no embargo exists" from "this participant has not yet agreed". This machine is normative here, because correct embargo behavior cannot be specified without it.

9.1 States

Consent applies to specific terms. A participant therefore has one consent row for every entry in the case's embargo register (§7 Embargo Management (EM) State Machine), and each row holds one of the five states below. A row answers one question: what has this participant said about this one embargo? A participant can therefore be bound by the embargo in force and have already agreed to a proposed revision of it, on two different rows.

State Meaning
UNINVITED Not asked about this embargo; the start state of every row
INVITED Asked, with no answer yet; carries that invitation's RSVP deadline
AGREED Agreed to this embargo: explicitly, as its proposer, by seeding, or by carry-over
DECLINED Explicitly refused this embargo, or withdrew from it
TIMED_OUT Invited, and the RSVP deadline passed with no answer; not a refusal

Every row is written. Proposing an embargo writes an UNINVITED row for it on every current participant. Creating a participant record writes an UNINVITED row for every entry already in the register. No state is read from a missing row. A missing row is a defect, and an attempt to read one raises an error.

Requirements

ID Priority Requirement Related
CM-18-001 MUST Each participant record MUST hold one embargo consent row for every entry in the case's embargo register. Each row holds one of five states. The UNINVITED state means not asked, and is the start state. The INVITED state means asked, with no answer yet. The AGREED state records agreement, and DECLINED records an explicit refusal or a withdrawal. The TIMED_OUT state means invited, with the RSVP deadline passed and no answer. A participant is a signatory when its row for the register's ACTIVE entry is AGREED. A participant has lapsed when three things hold. An entry is ACTIVE, and the participant's row for it is neither AGREED nor DECLINED. Following replaces back from the ACTIVE entry, the first entry whose row is AGREED or DECLINED has an AGREED row. Both positions are read from the rows and the register, never stored (CM-18-016). With no ACTIVE entry, nobody is a signatory and nobody has lapsed.

One row for each pair of participant and embargo records each answer one time. To find if a participant is bound by the active embargo, a reader looks at the row for the active embargo. Thus there is no second record to reconcile, and a first proposal and a revision use the same rules (ADR-0122). TIMED_OUT is different from DECLINED, so that every reader can tell silence from a refusal (ADR-0118). A terminated embargo is a fact of the register, not a fact about each participant. A lapse follows the replaces chain. Thus only an embargo that was in force can bind, and a withdrawal from a later embargo ends the binding of an earlier embargo.
CM-18-019 MUST Proposing an embargo MUST write an UNINVITED consent row for it on every current participant.

A participant that was not asked holds a row that says so. Thus no reader infers "not asked" from a missing record, and a check can use the register to find a row for each participant and each embargo (CM-18-001).
Implements: CM-18-001
CM-18-020 MUST Creating a participant record MUST write an UNINVITED consent row on it for every entry already in the case's embargo register.

A participant that joins after embargoes were proposed was asked about none of them. A row for each entry records that, so the participant holds a row for every entry from its creation on (CM-18-001), and no reader meets a missing row.
Implements: CM-18-001
CM-18-021 MUST NOT A reader MUST NOT read a missing consent row as any consent state. A missing row is a defect.

Every row is written (CM-18-019, CM-18-020), so a missing row comes only from a fault. A reader that treated it as UNINVITED, or as any other state, would hide the fault, and could count a participant as asked, bound or free when it is not.
Extends: CM-18-001
CM-10-001 MUST CaseParticipant MUST record its consent per embargo: one consent row for every entry in the case's embargo register, naming the embargo and the participant's answer to it, UNINVITED until it is asked (CM-18-001). A participant agrees to an embargo explicitly, by an Accept, as its proposer, by seeding (CM-14-003, CM-14-005), or by containment, when the Case Owner activates a revision that ends no later than terms the participant had agreed to (EP-05-001). Each invitation's RSVP deadline is stored on that invitation's INVITED row (CM-28-013). No other record of embargo consent may exist on the participant.

Consent is per embargo (ADR-0093, ADR-0122), so a revision does not inherit an agreement given to an earlier version (CM-18-001). The CM-10-004 content gate reads the rows, so they must name every embargo that binds the participant, including one that containment carries over: an agreement to N days is an agreement to every shorter period, so no explicit Accept is needed for it. A second record of consent beside the rows can disagree with them, and a reader cannot know which is correct.
Uses definition from: CM-18-001
See also: CM-14-003 — context for the reader
See also: CM-14-005 — context for the reader
See also: CM-28-013 — context for the reader
See also: EP-05-001 — context for the reader

A participant that joins late stays UNINVITED on embargoes that are no longer in force. That participant is invited only to the embargo in force and to open revisions.

UNINVITED and DECLINED both leave the participant unbound by the embargo that the row answers. They are distinct states, because it matters whether the participant gave an answer. The lapsed read stops at a DECLINED row and passes over an UNINVITED row (§9.3 Signatory and Lapsed). The CASE_MANAGER relays an open proposal to a joiner only while the joiner's row for that proposal is UNINVITED.

Requirements

ID Priority Requirement Related
CM-11-006 MUST When the CASE_MANAGER sends a stub Invite (Invite(VulnerabilityCase preview)[target=Actor]), it MUST create the invitee's CaseParticipant in the same step. The participant is inert (CM-10-004).

The CASE_MANAGER needs to track every invitee from the moment it is invited — whether it has been told and how it answered — including the invitees that decline (ADR-0114).
Uses definition from: CM-10-004
CM-11-026 MUST The CaseParticipant a stub Invite creates MUST hold the Invite's roles, RM RECEIVED, VF v (VENDOR), and an INVITED row for an active embargo.

The invitee has been told of the case and has decided nothing. RM RECEIVED and VF v record exactly that. The INVITED row records that it was asked about the embargo in force and has not answered (CM-18-001).
Extends: CM-11-006
CM-11-023 MUST When it sends a stub Invite, the CASE_MANAGER MUST commit its own add_case_participant_to_case entry, Add(CaseParticipant) with the case as its target and context (CLP-07-021), separate from the Invite's invite_actor_to_case entry.

The ledger holds the wire messages that the actors exchanged, and every state change has a message. The Invite is one message. Creating the invitee's record is the CASE_MANAGER's own act, so it is a second message with its own entry (ADR-0114, ADR-0124).
Extends: CM-11-006
Refines: CLP-07-021
CM-11-024 MUST The add_case_participant_to_case entry MUST carry the whole participant record as stored: its statuses and consent rows, with their ids and times.

A replica copies the record from the entry and derives nothing (CM-11-025, ADR-0124). The entry must therefore carry every field the CASE_MANAGER holds, or the replica's record differs from the CASE_MANAGER's.
Extends: CM-11-023
CM-11-025 MUST A replica MUST store an invitee's record exactly as the add_case_participant_to_case entry carries it, in the case its target names, and derive none of it from the Invite's entry.

Replicas copy; they never mint ids, read clocks or run lifecycle logic (ADR-0124). A record a replica derived could differ from the CASE_MANAGER's in an id or a time, and the copies of the case would then disagree.
Depends on: CM-11-024
EP-09-011 MUST When the CASE_MANAGER admits a participant (Accept(Invite(VulnerabilityCase preview)[target=Actor])) while an embargo proposal is open, it MUST relay an Invite(EmbargoEvent) for every open proposal to the joiner and commit each as a ledger entry, after the joiner holds the case and the prior ledger. Each Invite has actor set to the CASE_MANAGER's ID and attributedTo set to the proposal's original proposer (EP-09-002). A proposal whose consent row for the joiner has already left UNINVITED is not relayed again. Every participant holds a row for every register entry (CM-18-001). The row's state, not its presence, says whether the joiner was asked. The joiner's row for the active embargo is unchanged (EP-09-004), so a joiner that accepts the revision is a signatory of it at activation and one that does not lapses (ADR-0093, EP-05-001).

A joiner is seated after the relay of a proposal (EP-09-002), so it was never on the roster when the Invite went out, and nothing else would ask it. A new participant becomes a signatory to the embargo in effect when it joins, and is asked about a revision on the table exactly like the participants who were present when it was proposed.
Uses definition from: EP-09-002
Uses definition from: CM-18-001
See also: EP-05-001 — context for the reader
See also: EP-09-004 — context for the reader

INVITED carries the invitation's RSVP Deadline on the row itself (§9.4 Deadlines and the Pocket Veto). Each deadline belongs to one invitation. A participant can therefore hold several INVITED rows with different deadlines. When one deadline passes, it times out only its own row.

---
title: Participant Embargo Consent State Machine (one row per participant and embargo)
---
stateDiagram-v2
    direction LR
    [*] --> UNINVITED
    UNINVITED --> INVITED: INVITE
    UNINVITED --> AGREED: AGREE
    UNINVITED --> DECLINED: DECLINE
    INVITED --> AGREED: AGREE
    INVITED --> DECLINED: DECLINE
    INVITED --> TIMED_OUT: TIME_OUT
    AGREED --> DECLINED: DECLINE
    DECLINED --> INVITED: INVITE
    DECLINED --> AGREED: AGREE
    TIMED_OUT --> INVITED: INVITE
    TIMED_OUT --> AGREED: AGREE
    TIMED_OUT --> DECLINED: DECLINE

The diagram shows the five states of one consent row and the triggers INVITE, AGREE, DECLINE and TIME_OUT that move it. CARRY_OVER also moves every state except AGREED to AGREED, when the Case Owner activates a revision that ends no later than the embargo it replaces; those edges are omitted for legibility. No state is terminal: a row stops accepting triggers when its embargo's register entry reaches a final status.

9.2 Transitions and Guards

Five triggers drive each row. INVITE records an invitation. AGREE and DECLINE record an answer. TIME_OUT fires when the RSVP deadline of an invitation passes with no answer. CARRY_OVER agrees for a participant when the Case Owner activates a revision that asks nothing new of that participant.

Trigger From To
INVITE UNINVITED, DECLINED, TIMED_OUT INVITED
AGREE UNINVITED, INVITED, DECLINED, TIMED_OUT AGREED
DECLINE UNINVITED, INVITED, AGREED, TIMED_OUT DECLINED
TIME_OUT INVITED TIMED_OUT
CARRY_OVER every state except AGREED AGREED

No other trigger is valid from any state. A row for an embargo whose register entry is final (REJECTED, SUPERSEDED, CANCELLED or TERMINATED) accepts no trigger. The consent given to an embargo that is no longer in play therefore stays frozen as it stood.

AGREED refuses INVITE. A new request does not undo consent that a participant already gave. If the terms change after a participant agrees, that participant is invited on its row for the new embargo. This invitation leaves its AGREED row for the old embargo unchanged.

Requirements

ID Priority Requirement Related
CM-18-003 MUST The consent row machine MUST implement exactly the following valid triggers, each applied to the row for one embargo: INVITE (from UNINVITED, DECLINED or TIMED_OUT, to INVITED), AGREE (from UNINVITED, INVITED, DECLINED or TIMED_OUT, to AGREED), DECLINE (from UNINVITED, INVITED, AGREED or TIMED_OUT, to DECLINED), TIME_OUT (from INVITED only, to TIMED_OUT) and CARRY_OVER (from every state except AGREED, to AGREED). No other trigger is valid from any state, and a row for an entry in a final register status (SUPERSEDED, REJECTED, CANCELLED, TERMINATED) accepts no trigger at all.

DECLINED and TIMED_OUT are not terminal. The CASE_MANAGER can invite again a participant that declined or that let an invitation time out, for example when the embargo terms change. AGREED does not accept a new invitation, so a second request does not cancel a consent that the participant gave. AGREE is valid from DECLINED, because an Accept after a decline is a change of answer by the participant. The participant has just said that it accepts. Thus its row moves directly, with no re-invite step. Only the participant's own answer moves a DECLINED row in this way. Seeding (CM-14-003, CM-14-005) and the Accept of the full-case Invite never cancel a decline. Per ADR-0048, AGREE and DECLINE are valid directly from UNINVITED, because consent does not always come through an invitation. A Finder who sets the embargo on its own case has no inviter. Participants added during case initialization already have an embargo in scope (ADR-0041). The reporter gives its consent when it submits the report (CM-14-005). A required synthetic INVITED step for these paths would record an invitation that did not occur. Per ADR-0093, DECLINE is also valid from AGREED. A participant bound by an embargo MAY withdraw its consent when it rejects the active embargo (VP-13-007, VP-13-008). A rejection of a proposed embargo declines only the row for that embargo. It does not change the participant's row for the embargo in force (MSM-07-004). Per ADR-0118, TIME_OUT is only the timer path (CM-18-002). A late Accept that the CASE_MANAGER honours moves TIMED_OUT → AGREED directly (EMB-17-002), and a late explicit Reject moves TIMED_OUT → DECLINED. Only the activation of a revision that ends at or before the end of the embargo it replaces causes CARRY_OVER (EP-05-003). CARRY_OVER also lifts a DECLINED row. An agreement to N days is an agreement to every shorter period. A decline of a shorter revision objects to the loss of time, not to the embargo. A row whose embargo is final records the past. Thus a participant cannot give more consent to it. The CASE_MANAGER answers a late Accept of such terms with an invitation to the case's current terms, which are the Active Embargo or, with none in force, the earliest-expiring open proposal (EMB-17-003, EP-08-002). A lapse and a termination are not triggers. They are derived (CM-18-001, CM-18-016).
Uses definition from: CM-18-001
CM-18-004 MUST NOT A participant's consent row MUST NOT move from AGREED to INVITED directly. The only paths back to INVITED from a resolved row are DECLINED → INVITED (re-invite after explicit decline) and TIMED_OUT → INVITED (re-invite after an unanswered invitation timed out); a participant that has lapsed is re-invited on its row for the new embargo (an INVITED row for it), which leaves its AGREED row for the old embargo alone.

Consent already given cannot be withdrawn by re-inviting the participant. A signatory to the active embargo is bound by it; only replacing that embargo with longer terms (which lapses the participant by derivation — ADR-0093, ADR-0122) or the participant's own withdrawal (DECLINE) ends that position.
Derives from: CM-18-003

AGREE and DECLINE are valid directly from UNINVITED. Consent does not always come through an invitation. A finder that opens a case for its own finding and sets its default embargo received no invitation from anybody. A reporter consents by reporting. A required INVITED step on these paths would make the case history record an invitation that did not happen.

A repeated answer is not a transition. When a participant sends the same answer to the same invitation again, the CASE_MANAGER changes nothing, records nothing in the case ledger and sends nothing, whatever activity id the repeat carries. A different answer is a new answer, and the table above applies to it. A participant that declined and then agrees has changed its answer, so its row moves directly to AGREED, with no new invitation.

Requirements

ID Priority Requirement Related
CM-13-005 MUST A repeated embargo answer is a second Accept, or a second Reject, of one embargo invitation by the same participant, whatever its activity id. The receiver of a repeated answer MUST change no state, add no ledger entry and send no message because of it. Answers from different participants are separate consents.

Delivery is at least once. A participant can send the same answer again under a new activity id. If a repeat counted, the receiver would add a ledger entry and a fan-out for a consent that did not change. Every replica would then record an answer that was not a new decision. Each participant gives consent for itself. Thus the answer of one participant is never a repeat of the answer of a different participant.

None of DECLINED, TIMED_OUT and AGREED is terminal. A DECLINED or TIMED_OUT row can be invited again, and this re-invitation makes renegotiation possible. An AGREED row can be declined. What ends the life of a row is its register entry reaching a final status, not any state of the row.

9.3 Signatory and Lapsed

Two positions a participant can hold are not states. Each position is a read of the participant's rows and the case's register. Neither position is stored or drawn on the state machine.

Read Definition
Signatory The participant's row for the register's ACTIVE entry is AGREED.
Lapsed An entry is ACTIVE, the participant's row for it is neither AGREED nor DECLINED, and, following replaces back from the ACTIVE entry, the first entry whose row is AGREED or DECLINED has an AGREED row.

With no ACTIVE entry nobody is a signatory and nobody has lapsed. After an embargo is terminated, no entry is ACTIVE, so the termination writes no row. The position of every participant follows from the register alone.

Requirements

ID Priority Requirement Related
CM-18-001 MUST Each participant record MUST hold one embargo consent row for every entry in the case's embargo register. Each row holds one of five states. The UNINVITED state means not asked, and is the start state. The INVITED state means asked, with no answer yet. The AGREED state records agreement, and DECLINED records an explicit refusal or a withdrawal. The TIMED_OUT state means invited, with the RSVP deadline passed and no answer. A participant is a signatory when its row for the register's ACTIVE entry is AGREED. A participant has lapsed when three things hold. An entry is ACTIVE, and the participant's row for it is neither AGREED nor DECLINED. Following replaces back from the ACTIVE entry, the first entry whose row is AGREED or DECLINED has an AGREED row. Both positions are read from the rows and the register, never stored (CM-18-016). With no ACTIVE entry, nobody is a signatory and nobody has lapsed.

One row for each pair of participant and embargo records each answer one time. To find if a participant is bound by the active embargo, a reader looks at the row for the active embargo. Thus there is no second record to reconcile, and a first proposal and a revision use the same rules (ADR-0122). TIMED_OUT is different from DECLINED, so that every reader can tell silence from a refusal (ADR-0118). A terminated embargo is a fact of the register, not a fact about each participant. A lapse follows the replaces chain. Thus only an embargo that was in force can bind, and a withdrawal from a later embargo ends the binding of an earlier embargo.
CM-18-019 MUST Proposing an embargo MUST write an UNINVITED consent row for it on every current participant.

A participant that was not asked holds a row that says so. Thus no reader infers "not asked" from a missing record, and a check can use the register to find a row for each participant and each embargo (CM-18-001).
Implements: CM-18-001
CM-18-020 MUST Creating a participant record MUST write an UNINVITED consent row on it for every entry already in the case's embargo register.

A participant that joins after embargoes were proposed was asked about none of them. A row for each entry records that, so the participant holds a row for every entry from its creation on (CM-18-001), and no reader meets a missing row.
Implements: CM-18-001
CM-18-021 MUST NOT A reader MUST NOT read a missing consent row as any consent state. A missing row is a defect.

Every row is written (CM-18-019, CM-18-020), so a missing row comes only from a fault. A reader that treated it as UNINVITED, or as any other state, would hide the fault, and could count a participant as asked, bound or free when it is not.
Extends: CM-18-001
MSM-07-006 MUST When an ET / REMOVE_EMBARGO_EVENT_FROM_CASE wire activity terminates the embargo register's ACTIVE entry, implementations MUST leave the case with no active embargo. The same step cancels every open proposal, so the derived EM becomes EXITED. No separate outbound wire activity is emitted; the participant position is derived from the case.

A register with a TERMINATED entry accepts no further change (ADR-0122), so a terminated embargo can never be invited to again. That is a fact about the case, which every replica holds once it replays the teardown.
Uses definition from: MSM-02-007
MSM-07-025 MUST NOT When an ET terminates the embargo register's ACTIVE entry, implementations MUST NOT write any participant's consent rows. With no active embargo no participant is a signatory and no row binds anyone. An Accept or Reject that arrives afterwards records nothing (EMB-17-004).

The termination is a fact about the case, so it does not need copying onto each participant record as a terminal consent state. Leaving the rows as they were also keeps the history of who agreed to what, and every row of a final entry is frozen (CM-18-003).
Extends: MSM-07-006
See also: EMB-17-004 — context for the reader

After the case is public, an exploit is public or attacks are observed, abandoning an open proposal also writes no row. The CASE_MANAGER cancels the proposal with a Reject if it received the proposal, or with an Undo if it made the proposal itself. Then the CASE_MANAGER withdraws each invitation that it relayed for the proposal, with an Undo. Each row for the canceled proposal is frozen as it stood.

The CASE_MANAGER's Reject is its abandonment, not its consent. A CASE_MANAGER that has a stake in an embargo therefore records its own answer as its own update of the row, never as a Reject.

Requirements

ID Priority Requirement Related
EMB-16-001 MUST A Participant in EM Proposed (q^em ∈ P) MUST abandon the proposed embargo when it detects a CS transition into P, X or A. The P state is public (q^cs ∈ ···P··), X is exploit-available (q^cs ∈ ····X·), and A is attacks-observed (q^cs ∈ ·····A). It cancels each open proposal in the case's embargo register, so EM derives None (q^em P → N). The CASE_MANAGER cancels a proposal it received with its ER, Reject(Invite(EmbargoEvent)), committed as reject_invite_to_embargo_on_case. It cancels a proposal it made itself with its Undo(Invite(EmbargoEvent)), committed as undo_invite_to_embargo_on_case. After either, it sends its Undo(Invite(EmbargoEvent)) of each Invite it relayed for that proposal. A proposal never relayed is cancelled all the same.

EMB-01-002 establishes that embargo negotiation is not viable once public disclosure, exploit availability, or attacks have occurred. EMB-01-002 is framed as a guard on receiving EP, but the same viability constraint applies when a P/X/A state change arrives while a proposal is already in flight. Continuing to negotiate a proposed embargo in these conditions would be misleading to other Participants and counter to the purpose of coordinated disclosure. CANCEL records that nobody decided the proposal (ADR-0122). An actor undoes only an activity it performed, so withdrawing an Invite one sent is an Undo and declining one received is a Reject; a CASE_MANAGER act with a participant's verb and object carries the participant's semantic type (ADR-0152).

ECA Details

Preconditions

- EM state is Proposed
- EM state: PROPOSED
- CS transitions to public (q^cs ∈ ···P··)
- CS pattern: ...P..
- CS transitions to exploit-available (q^cs ∈ ····X·)
- CS pattern: ....X.
- CS transitions to attacks-observed (q^cs ∈ ·····A)
- CS pattern: .....A

Steps

1. [system] Detect that CS has transitioned to a P/X/A state while EM is Proposed → An open proposal is recognised
2. [system] As the CASE_MANAGER, cancel each open proposal: commit its Reject of the proposal, or its Undo of an own proposal, then an Undo of each Invite relayed for it → Each proposal's register entry is CANCELLED and EM derives NONE; the entries are committed and replayed by every replica

Postconditions

- EM state is NONE; the abandonment is committed; proposed embargo abandoned

EMB-16-003 MUST A Participant that abandons a proposed embargo on a P/X/A transition (EMB-16-001) MUST notify the other Participants.

Continuing to negotiate a proposed embargo that is no longer viable would mislead the other Participants. The CASE_MANAGER's committed entries are the notice to every other Participant (EP-09-007, EP-09-009).
Extends: EMB-16-001
EMB-16-004 MUST The CASE_MANAGER MUST commit the entries that abandon every open proposal (EMB-16-001) in one transaction (CLP-07-015).

A partly committed abandonment would leave some proposals open after the case reached P/X/A, so the case's register and its replicas would disagree about which proposals are still open.
Extends: EMB-16-001
Refines: CLP-07-015
EMB-16-005 MUST A replica MUST apply each abandoned proposal's CANCEL once, from the entry that carries it (ADR-0152).

The CASE_MANAGER's Reject cancels the proposal, and each Undo after it finds the proposal cancelled and changes nothing. Applying the CANCEL from its own entry keeps the replica's register equal to the CASE_MANAGER's.
Extends: EMB-16-001

A participant lapses when the Case Owner activates a revision that ends later than the embargo that the participant agreed to, and the participant has not agreed to the revision. The participant did agree, but the embargo in force has since become something that the participant did not agree to. Only the embargoes that were once in force are on the replaces chain. Agreement to a proposal that never took effect therefore gives the participant nothing to lapse from. A participant that withdrew from a later embargo has a DECLINED row on the chain. That participant has not lapsed when a further revision replaces that later embargo.

Lapsed is neither the proposal state nor the deadline state

A revision that is only proposed lapses nobody. A revision that ends no later than the accepted terms also lapses nobody. A participant that lets an invitation deadline pass reaches TIMED_OUT on that invitation's row, not lapsed. A lapse is not timer-based and has no transition of its own. A lapsed participant is re-invited on an INVITED row for the embargo in force, and the deadline attaches to that invitation.

A revision does not move anyone's consent to the embargo in force until it takes effect. While a revision is only proposed, the prior embargo is in force and every signatory to it remains one. The proposer's row for the revision is AGREED, because proposing terms is consenting to them. Every other participant gets an UNINVITED row for the revision. A signatory that agrees to the revision records that agreement on the revision's row. A signatory that declines the revision refuses those terms and nothing more, on that row only.

Requirements

ID Priority Requirement Related
EP-05-002 MUST NOT A revision proposal (ACTIVE → REVISE) and any further counter-revision (REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force. The proposer's row for the proposed embargo becomes AGREED (MSM-07-022). Every other participant gets an UNINVITED row for it (CM-18-001). Every other row stays as it is until the Case Owner activates a revision (EP-05-001, EP-05-003). Until then the prior embargo stays in force, and every signatory to it remains one.

A participant cannot lapse until the embargo on the case differs from the one they agreed to. Lapsing on proposal would strand signatories when the revision is rejected, report participants who are still bound and still receive embargoed content as not bound, and lapse the proposer of the revision (ADR-0093). With per-embargo rows a proposal only ever adds rows for the proposed embargo.
Uses definition from: CM-18-001
Refines: MSM-07-022
See also: EP-05-001 — scope boundary: a different transition
See also: EP-05-003 — context for the reader
MSM-07-003 MUST The wire activity ACCEPT_INVITE_TO_EMBARGO_ON_CASE (wire form: Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase])) is always its sender's own consent, the Case Owner's included. An actor applying it MUST apply the PEC AGREE trigger to the sender's row for the accepted embargo. The row advances from UNINVITED, INVITED, DECLINED or TIMED_OUT to AGREED. The accepted embargo may be the active embargo, a first proposal (EM PROPOSED) or a proposed revision of an embargo still in force. Only the accepted embargo's row is marked. A participant is a signatory exactly when its row for the active embargo is AGREED. So accepting a proposed revision binds the participant to nothing new until the owner activates it (MSM-07-008). An Accept from a DECLINED row is the participant changing its answer, so the row moves directly to AGREED with no re-invite first (CM-18-003). An Accept of an embargo that is not available records nothing (CM-18-003): MSM-07-012 refuses it, and MSM-07-039 answers one the register never held.

The Case Owner's decision for the case has its own activity (MSM-07-008, ADR-0122), so an Accept of an Invite means one thing whoever sends it and no handler branches on the sender to learn what it means. The PEC AGREE trigger is valid directly from UNINVITED because consent can be self-determined without an invitation (ADR-0048, ADR-0091, CM-18-003). Consent is per embargo (CM-10-001, ADR-0093, ADR-0122): an Accept is always a statement about the embargo it names, so it always marks that embargo's row and there is no first-proposal versus revision asymmetry to special-case.
Uses definition from: CM-18-003
See also: MSM-07-008 — context for the reader
MSM-07-004 MUST The wire activity REJECT_INVITE_TO_EMBARGO_ON_CASE (wire form: Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase])) is its sender's own consent whenever a participant sends it, the Case Owner included. Unless MSM-07-014 refuses it, an actor applying it MUST apply the PEC DECLINE trigger to the sender's row for the rejected embargo. DECLINE is valid from UNINVITED, INVITED, AGREED or TIMED_OUT. A Reject of the active embargo from any row but AGREED refuses the terms in force and declines that row only. The CASE_MANAGER's own Reject of a proposal is not its consent but its abandonment (MSM-07-016).

Symmetric with MSM-07-003: the Case Owner's rejection of a proposal for the case has its own activity (MSM-07-009, ADR-0122), so a Reject of an Invite is the sender's consent and nothing else. The PEC DECLINE trigger is valid directly from UNINVITED for symmetric reasons to AGREE (ADR-0048, ADR-0091, CM-18-003).
Uses definition from: CM-18-003
MSM-07-015 MUST An actor that applies a Reject of a proposed embargo that is not active MUST leave the sender's row for the active embargo unchanged. A signatory's rejection of a proposed revision refuses those terms; it is not withdrawal from the embargo in force. When no embargo is in force (EM PROPOSED), a Reject of a proposal declines that proposal's row only. It withdraws from nothing, and the participant's AGREED rows for other open proposals stay AGREED.

Consent is per embargo, so a signatory who refuses proposed terms is still bound by, and still consents to, the embargo that remains active; only the Case Owner decides whether the proposal replaces it (MSM-07-009, ADR-0122).
Extends: MSM-07-004

A signatory withdraws by leaving the embargo in force with Leave(EmbargoEvent), not by rejecting an invitation to it. The withdrawal declines the signatory's row for the embargo in force. The withdrawal also declines each open proposal's row that the signatory had agreed to, because every open proposal is a revision of the embargo that the signatory is leaving. A Reject of the active embargo from an AGREED row is refused with a reported reason. The Case Owner does not leave an embargo. The Case Owner ends an embargo by terminating it.

Requirements

ID Priority Requirement Related
MSM-07-010 MUST The wire activity Leave(EmbargoEvent)[context=VulnerabilityCase] is a participant's withdrawal of its consent to the case's active embargo. For a sender whose row for that embargo is AGREED, the receiver MUST apply the PEC DECLINE trigger to that row. A Leave changes no register entry.

Accept and Reject answer an Invite; leaving an embargo one is bound by is a different act, as Leave(VulnerabilityCase) is for leaving the case. A dedicated activity covers every signatory, including those made signatories with no Invite (CM-14-005, CM-11-001), and keeps a Reject from meaning refusal or withdrawal by the state of the case. The rejected alternatives are recorded in ADR-0122.
Uses definition from: VAM-05-011
Uses definition from: CM-18-003
Implements: VP-13-017
MSM-07-035 MUST NOT A DECLINED participant MUST NOT hold an AGREED row for an embargo that can become active without re-invitation.

A participant that has withdrawn from an embargo has to be asked again before terms bind it, or its withdrawal would be undone by an activation it took no part in.
MSM-07-034 MUST On a withdrawal (MSM-07-010), the receiver MUST also decline every open proposal's row that the sender had AGREED to. Every open proposal is a revision of the embargo withdrawn from (EP-08-004).

An agreed revision left in place would make the withdrawer a signatory again as soon as the owner activated it (MSM-07-035).
Implements: MSM-07-035
Extends: MSM-07-010
Derives from: EP-08-004
MSM-07-036 MUST The receiver MUST refuse a Leave(EmbargoEvent), with a reported reason, in three cases. Its embargo is not the active one, the sender's row for it is not AGREED, or the sender is the Case Owner. The Case Owner ends an embargo by terminating it (CM-02-005).

Only a signatory of the embargo in force can withdraw from it, and the Case Owner holds the termination instead.
Extends: MSM-07-010
See also: CM-02-005 — context for the reader
VAM-05-011 MUST WITHDRAW_FROM_EMBARGO_ON_CASE MUST be represented as Leave(EmbargoEvent)[context=VulnerabilityCase], whose object is the embargo in force, carried inline or by reference, and not an Invite (ADR-0122).

Withdrawal answers no Invite, so it names the embargo itself; it is told apart from Leave(VulnerabilityCase), which leaves the case, by its object (MSM-07-010).

Only the Case Owner's decision changes the embargo on the case. The answers of the other participants inform that decision. When the owner activates a revision, the direction of the change decides what happens to the consent of the signatories to the old terms:

  • A revision that ends no later than the terms it replaces asks nothing new of anyone who agreed to the old terms, because agreeing to N days is agreeing to every shorter period. The CASE_MANAGER applies CARRY_OVER to the revision's row of every participant whose row for the replaced embargo is AGREED. This rule includes a DECLINED row for the revision.
  • A revision that ends later asks for more than they promised. No row is written. By the definition above, a signatory to the old terms whose row for the revision is not AGREED has lapsed.

In both cases, a participant that already holds an AGREED row for the revision is a signatory to the revision by lookup. This is true for the proposer and for an early acceptor. Only signatories to the old terms are carried over. A participant that had lapsed from an earlier embargo stays lapsed until it is re-invited or agrees. If the activation makes the invitation of an INVITED participant stale, that participant is re-invited to the current terms, as in §9.4 Deadlines and the Pocket Veto. If the owner rejects the revision instead, the old terms stand and nobody's consent changes.

Requirements

ID Priority Requirement Related
EP-09-005 MAY The Case Owner MAY activate or reject an open revision at any time, without waiting for any other participant to answer the revision Invite. The owner's Add(EmbargoEvent)[target=VulnerabilityCase] activates the revision and the owner's Reject(EmbargoEvent)[target=VulnerabilityCase] keeps the prior terms (MSM-07-008, MSM-07-009); either is committed as a ledger entry and decides the embargo. The owner's Accept or Reject of the revision Invite is only its own consent (MSM-07-003, MSM-07-004).

Only the Case Owner's answer changes the embargo on the case; the other participants' answers inform that decision, they do not make it (ADR-0093). The Invites are not a vote: they gather the consent records the activation cascade reads (EP-05-001). The owner's decision settles the embargo; the answers settle who is bound by it.
Uses definition from: MSM-07-008
Uses definition from: MSM-07-009
See also: MSM-07-003 — context for the reader
See also: MSM-07-004 — context for the reader
MSM-07-008 MUST The wire activity ACTIVATE_EMBARGO_ON_CASE (wire form: Add(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST activate the named proposal's embargo register entry and supersede any entry in force in the same step. The derived EM becomes ACTIVE (EA, or EC for a revision).

Giving the owner's decision its own activity retires the two-audience rule: an Accept of an Invite is always the sender's consent (MSM-07-003), and this activity is always the owner's decision for the case, so neither meaning depends on who sent the message (ADR-0122). The activity is an Add because the case gains the embargo, as the Remove that ends it takes it away, so the decision and a consent differ by verb (ADR-0180). When it replaces an embargo in force, the MSM-07-005 consent rule settles the rows.
Uses definition from: VAM-05-008
MSM-07-027 MUST The CASE_MANAGER MUST accept ACTIVATE_EMBARGO_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Activating an embargo is the Case Owner's decision for the case (CM-02-005), so no other participant's activity may make it.
Extends: MSM-07-008
Refines: HP-01-006
MSM-07-028 MUST ACTIVATE_EMBARGO_ON_CASE MUST mark the Case Owner's row for the activated embargo AGREED when that row is UNINVITED, INVITED or TIMED_OUT. An AGREED row is left as it is, and an activation from a DECLINED row is refused (MSM-07-037).

The owner that activates terms is bound by them, so its own row has to say so. A row that holds no answer the owner gave, or only a lapsed invitation, contradicts nothing when it becomes AGREED, so the owner need not accept before it activates (ADR-0180).
Extends: MSM-07-008
Uses definition from: CM-18-003
MSM-07-029 MUST The CASE_MANAGER MUST refuse ACTIVATE_EMBARGO_ON_CASE before committing it in two cases. One is a named embargo that is not an open proposal of the case. The other is CS that is public, exploited or attacked (EMB-02-002).

Refusing a doomed activation before the commit keeps the ledger free of an entry that replicas, copying its step, would apply without the CASE_MANAGER's P/X/A check (CM-23-016).
Extends: MSM-07-008
Refines: EMB-02-002
MSM-07-009 MUST The wire activity REJECT_EMBARGO_PROPOSAL_ON_CASE (wire form: Reject(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST reject the named proposal's embargo register entry. Once no other proposal is open, the derived EM becomes NONE (ER) or stays ACTIVE with the prior terms in force (EJ). It stays PROPOSED or REVISE while another proposal is open (EMB-18-005).

The owner's rejection decides the proposal for the case; whether the owner, as a participant, also refuses those terms is a separate Reject of the Invite (MSM-07-004). The owner's own row does not constrain the rejection: an owner that accepted terms for itself may still reject them for the case (ADR-0180). Keeping the two apart lets the owner keep the prior terms without declining them (ADR-0122).
Uses definition from: VAM-05-009
Uses definition from: EMB-18-005
MSM-07-030 MUST The CASE_MANAGER MUST accept REJECT_EMBARGO_PROPOSAL_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Deciding a proposal for the case is the Case Owner's authority, so no other participant's activity may reject it for the case.
Extends: MSM-07-009
Refines: HP-01-006
MSM-07-032 MUST This rule covers REJECT_EMBARGO_PROPOSAL_ON_CASE of the last open revision while CS is public, exploited or attacked. The CASE_MANAGER MUST also terminate the embargo in the same act (EMB-04-002). It trial-applies both steps before committing either. It commits the Reject's entry carrying the REJECT step, then its own ET Remove(EmbargoEvent) entry carrying the TERMINATE step. A refused termination commits neither.

Reverting to the prior terms is not viable once disclosure has happened, so the rejection ends the embargo. Deciding both steps together means a replica copying both entries ends with the revision REJECTED and EM EXITED, as the CASE_MANAGER does.
Extends: MSM-07-009
Refines: EMB-04-002
MSM-07-033 MUST The CASE_MANAGER MUST refuse REJECT_EMBARGO_PROPOSAL_ON_CASE before committing it when the named embargo is not an open proposal of the case.

There is nothing to decide, and a committed entry naming no open proposal would be applied by every replica that copies it.
Extends: MSM-07-009
MSM-07-031 MUST NOT REJECT_EMBARGO_PROPOSAL_ON_CASE MUST NOT change any participant's consent rows, the Case Owner's included.

The owner's decision for the case is not its consent as a participant; that is a Reject of the Invite (MSM-07-004).
Extends: MSM-07-009
EP-05-001 MUST NOT This rule covers the Case Owner's activation of a revised embargo that ends later than the embargo it replaces (REVISE → ACTIVE). The CASE_MANAGER MUST NOT carry any participant's consent over to it.

A participant who signed for terms T1 has not consented to longer terms T2; treating them as a signatory once T2 is in force would imply consent they never gave. A participant is bound by the revised embargo only through an AGREED consent row for it, so each signatory to the replaced embargo that has not agreed to the revised one has lapsed (CM-18-001), and no write is needed to lapse them. The rule applies at activation rather than at proposal because the participant remains bound by T1 for as long as T1 is the active embargo (ADR-0093, ADR-0122).
Uses definition from: CM-18-001
EP-05-003 MUST This rule covers the Case Owner's activation of a revised embargo that ends no later than the one it replaces. The CASE_MANAGER MUST apply CARRY_OVER to the revised embargo's row of each participant with an AGREED row for the replaced embargo. That includes a participant whose row for the revision is DECLINED (CM-10-001, CM-18-003, MSM-07-005).

Shorter terms ask nothing new: agreeing to N days is agreeing to every shorter period, the same containment that makes shortest-wins (EP-04-003) safe without asking anyone, so their agreement is carried over by writing the row. That holds for a participant that declined the shorter revision too: its decline objected to losing time, not to keeping the embargo, and the decline stays in the ledger (ADR-0122).
Uses definition from: CM-18-001
Uses definition from: CM-18-003
Refines: MSM-07-005
See also: CM-10-001 — context for the reader
MSM-07-005 MUST This rule covers the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] (MSM-07-008) that replaces active embargo A with revision B. The register activates B and supersedes A, so the derived EM goes REVISE → ACTIVE, or stays REVISE while another proposal is open (EMB-18-005). Implementations MUST settle every participant's consent rows against B.

Only the owner's acceptance changes the embargo on the case; other participants' accepts and rejects are recorded per embargo and inform that decision. When it replaces the embargo in force, each participant's standing has to be read again against the new terms (ADR-0093).
Uses definition from: CM-18-003
Uses definition from: MSM-07-008
Uses definition from: EMB-18-005
MSM-07-021 MUST NOT A revision proposal (EV, ACTIVE → REVISE, or a counter-revision REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force.

While a revision is merely proposed the prior embargo is still in force and every signatory to it is still bound by it, so nothing about their consent has changed (ADR-0093).
MSM-07-022 MUST When a participant proposes a revision, implementations MUST mark the proposer's row for the proposed embargo AGREED.

Proposing terms is agreeing to them, so the proposer needs no Invite of its own proposal.
Extends: MSM-07-021
MSM-07-023 MUST The CASE_MANAGER MUST commit each carried-over row as its own CASE_MANAGER Update(EmbargoConsent) ledger entry, after the Accept's entry. The owner's own row is what its Accept states, applied from the Accept's entry.

The CASE_MANAGER decides the carry-over. Committing each carried-over row as its own entry keeps every replica's consent rows in step with the CASE_MANAGER's.
Implements: EP-05-003
MSM-07-024 MUST Every replica MUST copy the CASE_MANAGER's carried-over consent entries rather than run the carry-over itself (ADR-0124, CLP-07-013, CM-23-016).

A replica that ran the containment comparison on its own state could reach a different answer from the CASE_MANAGER's.
Depends on: MSM-07-023
Refines: CM-23-016
See also: CLP-07-013 — context for the reader
MSM-07-020 MUST NOT This rule covers the owner's activation of revision B in place of active embargo A, where B ends later than A. Implementations MUST NOT write any consent row to lapse a participant. A participant whose row for B is not AGREED is not a signatory to B, and has lapsed if it had agreed to A (CM-18-001).

Longer terms ask for more than the signatories of A promised, so only those who agreed to B are bound by B, and the rows say so without a write.
Refines: MSM-07-005
Uses definition from: CM-18-001

9.4 Deadlines and the Pocket Veto

An embargo invitation does not stay open indefinitely. If a participant neither agrees nor declines before the RSVP deadline, its row for that invitation moves to TIMED_OUT. This move is the pocket veto. The protocol does not treat silence as assent, because proceeding on an unanswered invitation would assert an agreement that the participant never gave. The protocol also does not record silence as a refusal. Only an explicit refusal reaches DECLINED.

Requirements

ID Priority Requirement Related
CM-18-002 MUST When an invitation's RSVP deadline passes with no answer, the CASE_MANAGER MUST apply the TIME_OUT trigger to that invitation's row only, recording TIMED_OUT, never DECLINED. A lapse has no timer and is not a stored transition (CM-18-001, CM-18-016). A lapsed participant's deadline is the one on its re-invitation to the embargo in force (CM-28-013).

Per ADR-0093, ADR-0122 and notes/participant-embargo-consent.md, a participant has lapsed when the active embargo was replaced by longer terms it has not accepted. While a revision is only proposed, the prior embargo is still in force and binds every signatory, so nothing about their consent has changed. Per ADR-0118, a participant that did not answer has made no decision. Thus a timeout records TIMED_OUT, distinct from an explicit DECLINED, and both are re-invitable. Nothing stalls on a lapsed participant: the CM-10-004 gate already excludes it from embargoed content, and no invitation gives it a deadline. An RSVP deadline belongs to one invitation and is stored on that invitation's INVITED row (CM-28-013). Its passing times out only that row, never the participant's other invitations. Code, logs, demos and replicas read the consent row, not ledger provenance (ADR-0118), so the row itself carries the distinction. A late Accept the CASE_MANAGER honours returns a TIMED_OUT row to AGREED, a signatory only if that embargo is in force (EMB-17-002, MSM-07-003). ADR-0118 reverses ADR-0065's choice to record a lapsed invitation as DECLINED.
Uses definition from: CM-18-001
Uses definition from: CM-18-003
Refines: CM-28-005
See also: CM-18-016 — context for the reader
See also: CM-28-013 — context for the reader
CM-18-022 MAY A timer expiry (pocket veto) MAY drive a row's INVITED → TIMED_OUT transition, with no explicit participant action.

A pocket veto exists so that an unanswered invitation cannot stall coordination. A participant that does not answer has made no decision, so the transition needs no act from it (ADR-0118).
Refines: CM-18-002
CM-18-023 SHOULD The pocket-veto timer period SHOULD be a policy window of 7 days.

An Invite that names no deadline still needs one, or an unanswered invitation can stall coordination. A fixed default window gives every such invitation the same deadline, so every participant can predict when silence becomes TIMED_OUT.
Extends: CM-18-022
CM-28-020 MUST A consent row MUST reach DECLINED only by an explicit refusal.

Reserving DECLINED for an explicit refusal lets the consent row tell "never responded" from "explicitly declined". Code, logs, demos and replicas read the row, not ledger provenance, so the row must carry the difference (ADR-0118).
Extends: CM-18-002
MSM-07-007 MUST The timer-based pocket-veto transition MUST be enforced lazily, with no outbound wire message for the consent change itself. That transition moves the row of the invitation whose deadline passed from INVITED to TIMED_OUT. A lapse has no timer path (CM-18-002): a lapsed participant is re-invited, and the deadline attaches to that invitation.

Inaction cannot produce an outbound message because there is no actor-observable event to report. The expiry is a derived conclusion from (the row's rsvp_deadline, now). Requiring a wire message would demand the system speak on behalf of a participant who has said nothing, which contradicts the Actor Knowledge Model (AKM).
Implements: CM-18-002
MSM-07-026 MUST The CASE_MANAGER MUST author a case-ledger entry that records a pocket-veto expiry (CM-28-005), so the consent change is visible in the canonical ledger. No other protocol wire activity is required.

The ledger entry is the record of the derived expiry, not a message sent by the silent participant. The entry already reaches every owner entitled to case content, so a second message would only duplicate it.
Refines: CM-28-005

The deadline is explicit or defaulted:

  • An embargo invitation can carry its own endTime, giving an explicit RSVP Deadline. When present, this endTime takes precedence over the policy window.
  • When the invitation has no endTime, a policy window applies. The default window is 7 days.

Requirements

ID Priority Requirement Related
CM-28-001 MUST An actor that reads an Invite(EmbargoEvent) MUST read its activity-level end_time, when present, as the RSVP-by deadline for that invitation. After that instant the invitation is no longer open.

as_Object.end_time is inherited by as_Activity and therefore by every Vultron activity, so no vocabulary extension is required. On an Activity, AS2 end_time already means "valid until", making the RSVP reading idiomatic rather than a repurposing. Placing the deadline on the activity rather than on the embargo object is what allows the same embargo to be offered to several actors with different deadlines, and to one actor twice. See ADR-0065.
CM-28-017 MAY An Invite(EmbargoEvent) activity MAY carry an activity-level end_time.

Every AS2 activity inherits end_time from as_Object, so a sender can state the RSVP-by deadline with no vocabulary extension. The field stays optional: without it, the CM-18-023 policy window sets the deadline (CM-28-019). See ADR-0065.
Uses definition from: CM-28-001
CM-28-018 MUST NOT An actor that reads an Invite(EmbargoEvent) MUST NOT read its activity-level end_time as the embargo's expiry.

An embargo invitation carries two end_time fields one nesting level apart: the Invite's is the RSVP-by deadline, and the nested EmbargoEvent's is when the embargo ends. A reader that takes one for the other lapses the invitation or the embargo at the wrong instant. See ADR-0065.
Extends: CM-28-001
CM-28-002 MUST When an Invite(EmbargoEvent) carries an end_time, that value MUST be authoritative for the invitation's expiry, superseding the receiver's local policy window. The resulting deadline stays subject to the EP-07-006 ceiling.

An explicit wire value lets both parties calculate the same lapse time from the same field, with no more messages. A window that only the receiver knows does not let the two parties agree if an invitation is still open. See ADR-0065.
Supersedes: CM-18-023
Refines: EP-07-006
CM-28-019 MUST When an Invite(EmbargoEvent) carries no end_time, the CM-18-023 policy window MUST set the invitation's expiry. The resulting deadline stays subject to the EP-07-006 ceiling.

An Invite without a deadline still needs one, and a sender that predates ADR-0065 sends none. The policy window keeps the behaviour those invitations had before the wire value existed. See ADR-0065 and ADR-0096.
Extends: CM-28-002
Refines: EP-07-006
Uses definition from: CM-18-023
EP-07-001 MUST When an Invite(EmbargoEvent) carries no Invite.end_time, an implementation MUST apply a default RSVP window, measured from the invitation's published timestamp.

An invitation with no deadline would leave the invitee's consent row INVITED for ever. A default window gives every invitation an end, so silence resolves. See ADR-0065.
EP-07-009 SHOULD The default RSVP window of EP-07-001 SHOULD be 7 days, matching CM-18-023.

Aligning the fallback with the CM-18-023 policy window means an invitation that omits end_time gets the same answer window as the policy grants. See ADR-0065.
Extends: EP-07-001
See also: CM-18-023 — context for the reader

In both cases, two rules later in this section set a lower bound and an upper bound on the result. The explicit endTime takes precedence over the policy window, but neither one escapes the minimum window or the embargo-end ceiling. The pocket veto is the implicit form of this one mechanism, not a second mechanism alongside it.

One invitation carries two different end times

The invitation's endTime is the RSVP Deadline for the invitee. The embargo event nested inside the invitation has its own endTime, which is when the embargo would expire. They sit one nesting level apart and mean different things.

An implementation that reads the embargo's expiry as the RSVP deadline will hold invitations open for the embargo's full duration. An implementation that reads the RSVP deadline as the embargo expiry will end embargoes days after they were agreed.

Recording the deadline. When the CASE_MANAGER relays an invitation, it sets the Invite's endTime and records the deadline on the invitee's INVITED row for the invited embargo. Every replica records the same deadline by copying the CASE_MANAGER's ledger entry for that row. A participant does not derive or store a deadline when it receives an Invite.

Requirements

ID Priority Requirement Related
CM-28-012 MUST When the CASE_MANAGER relays an Invite(EmbargoEvent) to a participant (EP-09-002) it MUST set the Invite's end_time to that Invite's published time plus the configured RSVP window, subject to the EP-07-002 minimum and the EP-07-006 ceiling. The Invites of one relay round are emitted in sequence and need not share one deadline.

If the wire carries no deadline, each receiving store uses the EP-07-001 window from its own ActorConfig. Two replicas can then disagree about when the same invitation closes. The relaying CASE_MANAGER is the enforcement authority (CM-28-003). It states the deadline one time, and every participant reads the same value from the same object. ASK-03-004 requires the same of an ask (ADR-0065, ADR-0113).
Uses definition from: EP-09-002
Refines: EP-07-002
Refines: EP-07-006
CM-28-013 MUST The CASE_MANAGER MUST record an Invite's RSVP deadline on the invitee's INVITED row for that embargo, in an Update(EmbargoConsent) entry right after the Invite's (CLP-07-013).

The deadline is case state about the invitee. As with all other case state, the CASE_MANAGER writes it one time, and it gets to replicas through the ledger (ADR-0108, ADR-0124). A deadline that a receiver writes would be in one store only. Replicas could then disagree about whether the invitation is open (ADR-0113).
Extends: CM-28-012
Refines: CLP-07-013
CM-28-023 MUST Every replica MUST record an Invite's RSVP deadline by copying the CASE_MANAGER's CM-28-013 Update(EmbargoConsent) entry (EP-09-007, ADR-0124).

The deadline is case state about the invitee, so it reaches replicas through the ledger like all other case state (ADR-0108, ADR-0124). A replica that copies the entry holds the same deadline as the CASE_MANAGER, so the two agree on whether the invitation is open (ADR-0113).
Depends on: CM-28-013
Refines: EP-09-007
CM-28-024 MUST NOT A participant MUST NOT derive or store an RSVP deadline on receipt of an Invite (EP-09-003).

A deadline that a receiver writes would be in one store only, and replicas could then disagree about whether the invitation is open. The CASE_MANAGER writes the deadline once (CM-28-013), and replicas copy it (CM-28-023; ADR-0113).
Extends: CM-28-013
Refines: EP-09-003

Enforcing the deadline. Only the CASE_MANAGER enforces the deadline. It records each expiry as its own ledger entry, and a replica learns of the expiry from that entry, never by computing it.

Requirements

ID Priority Requirement Related
CM-28-003 MUST The actor holding CASE_MANAGER MUST be the enforcement authority for embargo invite expiry.

Centralising enforcement at the CASE_MANAGER matches the case-communication model (PCR-08) and the CASE_MANAGER's role as canonical ledger author (ADR-0019, ADR-0021). See ADR-0065.
CM-28-014 MUST Only the CASE_MANAGER evaluates invite expiry (CM-28-003). Its Update(EmbargoConsent) carrying the invitee's TIMED_OUT row (CM-28-009) MUST be committed by the CASE_MANAGER before the row is written (ADR-0124, CLP-07-013), and reaches replicas as that ledger entry (CM-28-030). A replica learns an expiry from that entry, copying the row, and never computes one.

Only the CASE_MANAGER can write a ledger entry. Thus an expiry that another store calculates has one of two results. It is an entry that the store has no authority to commit, or it is a private difference that no replica shares. The CASE_MANAGER commits the expiry first, and replicas copy it by replay. Thus the consent row of every replica is equal to that of the CASE_MANAGER, and one clock decides (ADR-0113, ADR-0124).
Extends: CM-28-009
Refines: CLP-07-013
See also: CM-28-003 — context for the reader
CM-28-009 MUST When an RSVP deadline passes unanswered, the CASE_MANAGER MUST record the expiry as its own Update(EmbargoConsent) with the invitee's full TIMED_OUT row, committed as sent. The entry differs from the invitee's Reject(Invite(EmbargoEvent)), whose row is DECLINED.

The expiry is the occasion and the Update is the CASE_MANAGER's act on it, a real AS2 activity (ADR-0140). The TIMED_OUT row it carries makes expiry-versus-refusal distinguishable in the ledger (CM-28-005), and it is how a replica learns the TIMED_OUT state without computing it (CM-28-014). A second, invitee-attributed entry would record an act nobody sent. See ADR-0065, ADR-0118.
Refines: CM-28-005
CM-28-022 MUST NOT The CASE_MANAGER MUST NOT record an invitation's expiry as an activity attributed to the invitee, which sent nothing.

An invitee-attributed entry would record an act that nobody sent, and a reader of the ledger would take the silence for the invitee's answer. The expiry is the CASE_MANAGER's own act on its own clock (ADR-0140). See ADR-0065, ADR-0118.
Extends: CM-28-009

Informative: when the CASE_MANAGER checks deadlines

The reference implementation enforces the deadline lazily. When the CASE_MANAGER next handles the case, it compares each deadline against its own clock, so no scheduler or timer service is needed.

Before it commits the Case Owner's decision on a proposal, whenever it processes any other received embargo activity for the case, and whenever it runs an embargo trigger of its own, it expires every INVITED row whose deadline has passed and whose embargo is an open proposal or the embargo in force. A row of a replaced, rejected, canceled or ended embargo is frozen, so the sweep skips it. The sweep runs after the activity's sender has been admitted and before the activity's own refusals. An expiry is therefore recorded even when the activity is then refused.

A minimum window applies. The minimum window for an RSVP Deadline is the lesser of a configured window, 72 hours by default, and the time remaining in the embargo the invitation concerns. An inviting actor does not send an invitation whose deadline is shorter than the minimum. A receiver that gets one anyway extends the deadline to the minimum, and does not reject the invitation for this reason. A too-short deadline is the proposer's error, and a refusal of the invitation would penalize the invitee for that error.

Requirements

ID Priority Requirement Related
EP-07-002 MUST An inviting actor MUST set each Invite(EmbargoEvent)'s Invite.end_time at least the minimum RSVP window after the invitation's published timestamp. The minimum is the lesser of a fixed window and the time remaining in the embargo.

An unbounded-downward deadline weaponises the mechanism: a one-minute RSVP window formally invites a participant while guaranteeing they cannot answer, excluding them with the appearance of due process. See ADR-0065.
EP-07-010 SHOULD The fixed window of the minimum RSVP window (EP-07-002) SHOULD be 72 hours.

Seventy-two hours gives an invitee a realistic chance to answer across time zones and weekends, and it equals the floor of the protocol default embargo (EP-04-018). See ADR-0065.
Extends: EP-07-002
EP-07-003 MUST When a receiving actor receives an Invite(EmbargoEvent) whose Invite.end_time is earlier than the applicable minimum window, it MUST clamp the effective deadline up to that minimum. The applicable minimum is the one computed by EP-07-002, so the clamp never raises the deadline past the embargo's own end.

Clamping makes a coercive deadline ineffective rather than fatal. Rejecting the invitation outright would hand the sender exactly what a hostile sender wants — an invite that never takes effect — and would punish the invitee for the inviter's misbehaviour. See ADR-0065.
Uses definition from: EP-07-002
EP-07-004 MUST NOT A receiving actor MUST NOT reject an Invite(EmbargoEvent) as malformed solely on the basis of a sub-minimum deadline.

Rejecting the invitation would hand a hostile sender exactly what they want — an invite that never takes effect — and punishes the invitee for the inviter's misbehaviour.
Derives from: EP-07-003

A deadline does not outlive its embargo. An RSVP Deadline never falls after the end of the embargo it concerns. If a computed deadline, whether from the invitation's explicit endTime or from the policy window, would fall after that end, it is clamped down to the embargo's end.

Requirements

ID Priority Requirement Related
EP-07-006 MUST NOT An RSVP deadline MUST NOT fall after the end of the embargo it concerns.

An invitee must be able to answer while the embargo still exists. A deadline past the embargo's end asks the invitee to consent to an embargo that is already over, and records its silence as an expiry after the answer stopped mattering. See ADR-0096.
Constrains: CM-18-023
Constrains: EP-07-002
EP-07-011 MUST When a computed RSVP deadline would fall after the embargo's end_time, the actor that computes it MUST clamp it down to that end_time. This holds for a deadline from an explicit Invite.end_time and from the CM-18-023 policy window alike.

Clamping is how a deadline is kept within the embargo (EP-07-006) without refusing the invitation: the invitee can still answer while the embargo exists.
Implements: EP-07-006
Uses definition from: CM-18-023

An invitee needs to be able to answer while there is still something to answer about. For example, a participant is invited to a 24-hour embargo with no explicit endTime, and the policy window is 7 days. The participant's inaction would be recorded as a time-out on day 7, six days after the embargo ended. This example is why the minimum window above is relative, not absolute. A 12-hour embargo grants a 12-hour answer window. That window is not an unreasonably short deadline when 12 hours is the whole embargo.

A late acceptance is not refused for being late. The CASE_MANAGER does not refuse a late accept on deadline grounds. What decides the answer, on time or late, is whether the accepted embargo is still available: the case's Active Embargo or one of its open proposals, before its end time. Three cases apply:

  • If the accepted embargo is available, the CASE_MANAGER records the accept exactly as an on-time accept. Its entry is the accept itself, and a TIMED_OUT or DECLINED row moves to AGREED directly.
  • If the case held the accepted embargo but it is no longer available, the CASE_MANAGER refuses the accept with the refusal notice and records nothing. An embargo is no longer available when it was replaced, rejected, canceled or terminated, or when its end time has passed. When the case holds current terms, the CASE_MANAGER also relays a fresh invitation carrying them, on behalf of their proposer.
  • If the case never held the accepted embargo, the CASE_MANAGER answers with a processing fault, Create(ProcessingFault), and sends no refusal notice. The sender's view of the case is wrong, so its accept was not understood.

The participant keeps its place in the case in every case.

Requirements

ID Priority Requirement Related
EMB-17-001 MUST A CASE_MANAGER receiving an Accept(Invite(EmbargoEvent)) after the invitation's effective RSVP deadline MUST NOT reject it solely because the deadline has passed.

Being liberal in what is accepted serves CVD outcomes. A late accepter is volunteering to coordinate; refusing them converts a missed deadline into a lost participant, which is worse for the case than a late consent. See ADR-0065.

ECA Details

Preconditions

- The referenced invitation's effective RSVP deadline has passed

Postconditions

- The Accept is not refused on deadline grounds; one of EMB-17-002, EMB-17-003, or EMB-17-004 has been applied

EMB-17-012 MUST The CASE_MANAGER MUST check whether a late Accept(Invite(EmbargoEvent)) names an available embargo (MSM-07-012). Those are the case's Active Embargo and its open proposals (MSM-07-003), before their end time. It then applies EMB-17-002, EMB-17-003 or EMB-17-004.

A late Accept can name the embargo in force, an open proposal, terms the case decided, replaced or let run out, or terms it never held. Each needs its own answer, read by the same test as for an on-time Accept. "Is this the Active Embargo" leaves out a case under proposal, and a test without the end time honours an Accept of terms that bind nobody. See ADR-0065.

ECA Details

Preconditions

- The referenced invitation's effective RSVP deadline has passed

Postconditions

- One of EMB-17-002, EMB-17-003, or EMB-17-004 has been applied

Extends: EMB-17-001
Refines: MSM-07-012
Uses definition from: MSM-07-003
See also: EMB-17-002 — context for the reader
See also: EMB-17-003 — context for the reader
See also: EMB-17-004 — context for the reader
MSM-07-012 MUST An available embargo is the case's Active Embargo or one of its open proposals, before its end time. An Accept, on time or late, may name an embargo the register holds but that is not available. That embargo was replaced, rejected, cancelled or terminated, or it is past its end time. The CASE_MANAGER MUST refuse that Accept before committing it, with the refusal notice that reports the reason (CLP-05-001). When the case holds terms of its own, the fresh Invite of EMB-17-003 goes with the notice.

The embargo the Accept names decides the answer, not the clock: an RSVP deadline says whether the invitation is open, not whether the terms bind (ADR-0065). Terms that can no longer bind record nothing (CM-18-003), and an ACTIVE entry past its end time binds nobody before the clock ends it. Refusing before the commit keeps the Accept off the ledger, and the notice tells the sender its answer is moot.
Supersedes: MSM-07-003 — In the case it names, the refusal replaces the AGREE
Uses definition from: CLP-05-001
MSM-07-039 MUST An Accept, on time or late, may name an embargo the case's register never held. The CASE_MANAGER MUST answer that Accept with Create(ProcessingFault) to its sender, not with the refusal notice (MSM-05-001). Nothing is ledgered for it, the fault included (ASK-07-008).

A sender that names terms the case never held has a wrong view of the case. Its Accept was received but not understood, which MSM-05-001 answers with a processing fault. A refusal notice would tell it that its answer is moot, which presumes the case once held the terms. The fault tells it to resynchronise instead.
Supersedes: MSM-07-003 — In the case it names, the fault replaces the AGREE
Refines: MSM-05-001
See also: ASK-07-008 — the fault is not ledgered
EMB-17-002 MUST When the accepted embargo is available (MSM-07-012), the CASE_MANAGER MUST honour the late Accept. Available means the case's Active Embargo or one of its open proposals (MSM-07-003), before its end time. An ACTIVE entry past its end time is not available, so a late Accept of it is refused, not honoured. It marks the participant's consent row for that embargo AGREED, exactly as it would for an on-time Accept. A row at TIMED_OUT moves directly to AGREED (TIMED_OUT → AGREED, ADR-0118). So does one at DECLINED (DECLINED → AGREED, CM-18-003): the participant has changed its answer, so it is not re-invited first. The CASE_MANAGER honours it by committing the received Accept verbatim as accept_invite_to_embargo_on_case, carrying the row it states, as an on-time Accept is committed (EMB-17-009, ADR-0152).

An answer the case can still record is sound whenever it arrives. The deadline governs whether the invitation is open, not whether the agreement is sound, and an open proposal's row takes an answer until the Case Owner decides it, so dropping a late Accept of an open proposal would hide a willing participant from that decision. See ADR-0065. The Accept states the change, so its entry is the change's entry (CLP-07-013), and a replica reaches the state an on-time Accept leaves.

ECA Details

Preconditions

- EM state is Proposed, Active or Revise
- EM state: PROPOSED, ACTIVE, REVISE
- The accepted embargo is the case's Active Embargo or one of its open proposals, and its end time has not passed

Steps

1. [system] Record the PEC AGREE transition for the accepting participant → The participant's consent row for the accepted embargo is AGREED

Postconditions

- The participant's consent row for the accepted embargo is AGREED, so it is a signatory when that embargo is the Active Embargo

Refines: EMB-17-001
Uses definition from: MSM-07-012
Uses definition from: MSM-07-003
Uses definition from: CM-18-003
EMB-17-003 MUST An Accept, late or on time, may name an embargo the register holds but that is not available. The CASE_MANAGER refuses it with the refusal notice (MSM-07-012). When the case holds terms of its own, the CASE_MANAGER MUST also send the accepter a fresh Invite(EmbargoEvent) naming those terms. The fresh Invite goes alongside the refusal notice. The terms are the case's Active Embargo, while it is available. Otherwise they are its earliest-expiring available open proposal (EP-08-002). An accepting participant at TIMED_OUT moves TIMED_OUT → INVITED for the invited embargo (ADR-0118). The fresh Invite is a relay (EP-09-002). Its actor is the CASE_MANAGER. Its attributedTo names the invited embargo's proposer, or the CASE_MANAGER itself when it made the embargo as the protocol default, without a proposal.

Recording the stale Accept as consent binds the participant to terms it never saw; refusing it alone leaves a willing participant unasked. The re-invite asks about the terms that bind, in a relay's shape (ADR-0152). Naming the Active Embargo alone leaves a case under proposal with nothing to invite to. The earliest-expiring proposal is the one a participant answers first (EP-08-001); arrival order would ask about superseded terms. See ADR-0065.

ECA Details

Preconditions

- The register holds the accepted embargo, but it is not available, and the case has an available Active Embargo or open proposal

Steps

1. [system] Emit the refusal notice and a fresh Invite(EmbargoEvent) to the accepting actor carrying the case's current terms → Accepting participant's consent row for the invited embargo is INVITED; stale Accept is not recorded as consent

Postconditions

- A fresh invitation for the case's current terms has been sent; the actor remains a case participant

Refines: EMB-17-001
Extends: MSM-07-012
Uses definition from: EP-08-002
Uses definition from: EP-09-002
EMB-17-013 MUST Once it has queued the fresh Invite of EMB-17-003 (SYNC-09-002), the CASE_MANAGER MUST commit it as invite_to_embargo_on_case. The invitee's INVITED row with the Invite's deadline follows it (CM-28-013).

The re-invite asks about terms somebody proposed, exactly as a relay does, so it carries the relay's semantic type (ADR-0152). Committing it after it is queued lets a rebuilt send keep the same id (SYNC-09-002).
Extends: EMB-17-003
Refines: CM-28-013
Refines: SYNC-09-002
EMB-17-014 MUST A replica MUST apply the CASE_MANAGER's re-invite (EMB-17-003) through the relay slot, so that the Invite proposes nothing and EM does not move.

The replica's register already holds the embargo the Invite names, so the Invite asks for consent to it and changes no embargo state (ADR-0152).
Extends: EMB-17-003
EMB-17-004 MUST This rule covers a case with no Active and no Proposed Embargo (EM EXITED or NONE). There, the CASE_MANAGER MUST answer a late Accept of an embargo its register holds with the refusal notice alone (MSM-07-012). A redelivery of the same Accept gets the same result.

Follows the EMB-07-003 precedent for post-terminal messages: no transition. There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested — but the actor's case participation is independent of embargo consent and MUST survive. The sender is still owed word that its answer did not count, which the refusal notice gives (CLP-05-001). An Accept of terms the case never held gets a processing fault instead (MSM-07-039). See ADR-0065.

ECA Details

Preconditions

- EM state is EXITED (embargo terminated) or NONE (no embargo started)
- EM state: EXITED, NONE

Steps

1. [system] Refuse the Accept with the refusal notice, committing nothing and sending nothing else → Participant consent rows are unchanged; participant remains in the case; no ledger entry is committed and only the refusal notice is sent

Postconditions

- No embargo state change; accepting actor remains a case participant

Refines: EMB-17-001
Refines: MSM-07-012
EMB-17-015 MUST NOT The CASE_MANAGER MUST NOT commit any ledger entry for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004).

An entry acknowledging the Accept would change nothing at any receiver. The Accept is refused, and a refusal is never written to the ledger (CLP-04-007).
Part of: EMB-17-004
EMB-17-016 MUST NOT This rule covers a late Accept of an embargo the register holds, in a case with no Active and no Proposed Embargo (EMB-17-004). The CASE_MANAGER MUST NOT send any activity in reply to it but the refusal notice.

There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested. The refusal notice is owed: it tells the sender its answer did not count (MSM-07-012).
Part of: EMB-17-004
EMB-17-017 MUST The CASE_MANAGER MUST leave the participant's consent rows unchanged for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004). Nothing is recorded after a termination (EM EXITED), and a TIMED_OUT row stays TIMED_OUT when no embargo has started (EM NONE) (ADR-0118).

The Accept names an embargo that is no longer, or not yet, in force, so no row can bind to it. The actor's case participation is independent of embargo consent and survives.
Part of: EMB-17-004
EMB-17-006 MUST NOT When the accepted embargo is not available, the CASE_MANAGER refuses the Accept (MSM-07-012). It MUST NOT refuse the accepting actor's participation: the refusal is of the Accept alone.

Refusing a willing participant discards coordination capacity. The refusal notice says the answer is moot, never that the actor is unwelcome, and re-inviting to the current terms is the rest of the answer. See ADR-0065.
Extends: EMB-17-003
Refines: MSM-07-012
EMB-17-008 MUST NOT When the case has no Active Embargo and no Proposed Embargo (EM state is EXITED or NONE), the CASE_MANAGER MUST NOT remove the accepting actor from the case.

Case participation is independent of embargo consent; the actor's willingness to coordinate must not result in their removal. See ADR-0065.
Derives from: EMB-17-004

A time-out and a refusal reach different states. Silence records TIMED_OUT. An explicit refusal records DECLINED. The case ledger also distinguishes them, because it holds either the refusal that was sent or the CASE_MANAGER's record of the expiry. But every reader of the consent rows can tell the two states apart without the ledger. Both can be invited again, and both move to AGREED directly on a late accept of the current terms.

Requirements

ID Priority Requirement Related
CM-28-005 MUST An expired embargo invitation MUST be distinguishable from an explicit refusal both in the participant's consent row (TIMED_OUT versus DECLINED, CM-18-002) and in the canonical case ledger (CM-28-009).

The canonical ledger is the project's history mechanism (ADR-0019), so expiry-versus-refusal is recoverable from it; since ADR-0118 the consent row carries the distinction too, so a reader that consults only the participant record also sees it. See ADR-0065, ADR-0118.

9.5 Embargo Traffic Reaches Non-Signatories

Embargo consent gates case content. It does not gate the negotiation about the embargo itself.

The CASE_MANAGER delivers embargo meta-protocol activities addressed to a participant directly (an embargo Invite and its responses) to that participant, even when that participant declined, timed out or lapsed. These activities are not ledger fan-out, which the content gate holds back from non-signatories. A participant cannot agree to revised terms that nobody told it about. A participant that declined the original terms can still accept the revision.

Requirements

ID Priority Requirement Related
CM-10-005 MUST NOT This rule covers each Add(CaseLedgerEntry) the CASE_MANAGER sends, as fan-out of a new entry or as a replay answering a Reject(CaseLedgerEntry) (SYNC-03-002). While an embargo is active, the CASE_MANAGER MUST NOT send one to a participant that has not accepted that embargo (the CM-10-004 content gate).

The ledger fan-out is how participants learn every accepted case change, and each entry carries its payload verbatim — an added report or note reaches the recipient whole. Fan-out is therefore "sharing case updates" in CM-10-004's sense. An entry cannot be redacted per recipient without breaking the hash chain. Skipping a single entry does not work either: the replica buffers the next one as a forward gap and Rejects to request the missing entry (SYNC-14-002), so the replay would deliver the withheld content anyway. The gate therefore pauses the participant's whole stream, replay included, rather than filtering entries; the replica stays at the last entry it was sent.
Refines: CM-10-004
Uses definition from: SYNC-03-002
CM-10-008 MUST While an embargo is active, the CASE_MANAGER MUST still deliver an embargo Invite, and its responses, to a participant that has not accepted the embargo. These are embargo meta-protocol activities addressed to the participant directly, not ledger fan-out.

These activities are not ledger fan-out, so the CM-10-005 pause does not cover them. A participant that never receives the embargo Invite cannot accept the embargo, so its paused stream could never resume.
Extends: CM-10-005

Only case content (report details, fix status, sensitive notes) is gated on being a signatory (§9.7 Gating Full Case Delivery).

9.6 Being Bound by the Embargo

Whether a participant is currently bound by the embargo is a single yes-or-no question. The protocol answers this question from the consent rows. A participant is bound exactly when it is a signatory, that is, when its row for the register's ACTIVE entry is AGREED (§9.3 Signatory and Lapsed).

This is a derived fact, not an independent one. Being bound is not recorded as a value that can be set separately from the rows it reports. Such a value and the rows could then disagree. A case that reports a participant as bound while its rows say otherwise has no correct reading.

Every change of consent is one of two kinds, so that every change is a valid one and is recorded as such:

  • a consent trigger applied through the transitions of §9.2 Transitions and Guards
  • a copy of the row that a ledger entry carries, after a check of its starting state, made the same way by the CASE_MANAGER and by every replica

The CASE_MANAGER commits every consent row that it changes as its own Update(EmbargoConsent) ledger entry. For a row that it brings into existence, the entry is Create(EmbargoConsent). Each such entry comes after the entry of the act that caused the change. When the act's own activity states the row, the act's entry is also the row's entry. Examples are a participant's Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) or, for the Case Owner's own row, its Add(EmbargoEvent)[target=VulnerabilityCase] that activates an embargo.

Requirements

ID Priority Requirement Related
CLP-07-013 MUST The CASE_MANAGER MUST commit every change it makes to the case file as its own CaseLedgerEntry, never making a change that has no committed entry. The act's entry comes first. When the act's own activity states a change, that entry is the change's entry, and applying it writes only what the activity states. Examples are Add(Note)[target=VulnerabilityCase] carrying the note, and an invitee's Accept of the stub Invite marking its own consent and joining. A decision the CASE_MANAGER takes from local policy or the clock may change the case file. Such a decision is committed as the change it makes, before the change is made. A decision that changes nothing is not committed, such as noticing that a deadline has passed or that a closure is complete (ADR-0152). Moving the case's ledger position (ledgerPosition) to an entry as it is committed (SYNC-16-005) is part of applying that entry. It is not a change to the case file of its own, and takes no entry.

Two replicas at the same ledger position must hold the same case file, and a replica infers nothing. If a change is not in the ledger, it did not happen (ADR-0124). One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times. Full records are ledger content that the hash chain must cover (CLP-07-006).
Extends: CLP-07-002
Uses definition from: SYNC-16-005
CLP-07-021 MUST Each change an act causes, beyond what the act's own activity states, MUST follow the act's entry as its own CASE_MANAGER-authored entry. The entries follow in the order the CASE_MANAGER writes them. Each one's payloadSnapshot carries the object in full (CLP-07-006). A record the change adds to one of the case's lists (its participants, reports, notes, statuses, vulnerability items or case references) is recorded as an Add of the record with the case as its target. Any other record the CASE_MANAGER brings into existence is recorded as a Create, and a changed record as an Update.

One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times, and replicas at one ledger position then differ. Full records are ledger content that the hash chain must cover (CLP-07-006). A record that belongs to a case list needs the case as the entry's target: a Create has none, so a replica would have to decide which list the record joins, which is lifecycle logic a replica must not run (CM-23-044). The one Add both brings the record and lists it.
Extends: CLP-07-013
See also: CLP-07-006 — context for the reader
CM-23-016 MUST A participant's case replica is the case as it stood when the replica was seeded, plus the ledger entries since. A replica MUST apply the entries in ledger order by copying the objects they carry, so replicas at one ledger position hold identical case files.

The CASE_MANAGER is the single writer (ADR-0108), and the ledger records each change when the CASE_MANAGER makes it (CLP-07-013). If each replica copies what the entries carry, in the same order, two replicas at the same position hold the same case file as each other and as the CASE_MANAGER. CM-23-023 gives the rule for closure. This requirement gives it for every replicated change (ADR-0124).
CM-23-044 MUST NOT A replica applying an entry MUST NOT mint an id, read a clock, read local policy or state outside the case, or run lifecycle logic. Walking the RM transition table from its own stored state to a target state is such logic.

A replica can find its own path from its own state, which can be out of date. It can then write an RM state that the ledger never recorded. A replica that builds a record itself gives it an id and a time that differ from those of the CASE_MANAGER. In both cases, the replicas diverge from the CASE_MANAGER (ADR-0124).
Extends: CM-23-016

Informative: how the reference implementation does this

The reference implementation exposes adherence as a computed lookup over the stored consent rows and the register, so there is no separate field that can disagree with the rows. Any mechanism with that property gives the same reading.

9.7 Gating Full Case Delivery

Before the CASE_MANAGER delivers full case content (Announce(VulnerabilityCase) carrying report details, vulnerability description, and sensitive notes), the recipient is an active participant:

  1. The participant has joined the case: the case initialization sequence seated it, or it accepted the stub Invite, and it has not been removed.
  2. The participant is a signatory to the active embargo (its row for the active embargo is AGREED), or no embargo is in force (EM is not ACTIVE or REVISE).

Content stops for a participant whose closure the ledger records, after the entries that record its own closure.

Requirements

ID Priority Requirement Related
CM-10-004 MUST The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).

Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122).
Uses definition from: CM-14-001
Uses definition from: CM-18-001
Uses definition from: CM-31-001
CM-17-005 MUST NOT Presence in the case participant list MUST NOT be treated as acceptance of the invitation or as entitlement to case content. An invitee is in the list from the stub Invite onward (CM-11-006); only an active participant (CM-10-004) is entitled to case content.

The CASE_MANAGER tracks every invitee from the moment it is invited, including one that declines, so the participant list holds inert participants. Any consumer that reads membership as "accepted" would hand case content to an actor that has not consented.
Uses definition from: CM-10-004
See also: CM-11-006 — context for the reader
CM-23-004 MUST NOT The CASE_MANAGER MUST NOT send any case content to a participant whose closure an earlier ledger entry records, except as CM-23-031, CM-31-009 and CM-31-030 allow. That entry is the participant's status entry with rmState=CLOSED. Case content is CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements. A participant that has left receives no entry after those that record its departure, the CASE_MANAGER's own closure included.

RM.CLOSED is the participant's own statement that it stops its work on the case, possibly while the case is still open. Its replication process is then assumed to have stopped, as the CASE_MANAGER's is once the case is fully closed (CM-23-013). A closed participant receives no more content, so it does not see embargoed material after it leaves. Only the ledger advances a replica, so a closed replica does not converge on later closures, by design.
Extends: CM-10-004
CM-23-031 MUST The CASE_MANAGER MUST send each entitled leaver the entries that record its own closure, chosen by their subject, not by the leaver's status. These are the close_case entry and each status entry after it, up to the one reaching RM.CLOSED (CM-23-021, CM-23-022). They never widen entitlement (CM-10-004): an inert or removed leaver is not sent them.

The entries that record a participant's own closure come before it stops, so its replica still receives every step, the one that reaches RM.CLOSED included. The leaver's status is already RM.CLOSED when the last of them is fanned out. Thus a choice by status would withhold that last step.
Supersedes: CM-23-004
Uses definition from: CM-10-004
Uses definition from: CM-23-021
Uses definition from: CM-23-022
CM-23-032 MUST NOT A closing participant MUST NOT write its own RM.CLOSED to its replica in place of the CASE_MANAGER's closure entries (CM-23-031).

The CASE_MANAGER writes the leaver's closure and commits each step (CM-23-022). A participant that wrote its own RM.CLOSED would hold a step that no ledger entry records, and its replica would diverge from the CASE_MANAGER (ADR-0114).
Extends: CM-23-031

Recall: report management states

State Meaning
Start No report has been received
Received A report has arrived; triage is not yet complete
Invalid This participant assessed the report as invalid
Valid This participant assessed the report as valid
Deferred This participant is deferring further action
Accepted This participant accepted the report for active work
Closed This participant closed the report

Full definitions are in §6.1 States.

The gate is joining plus consent — not RM progress

It is tempting to read the gate as an RM state: RM.ACCEPTED, or RM.RECEIVED as "admitted". Both readings are wrong.

An invitee is at RM.RECEIVED from the stub Invite, before it has answered, and is still inert. Being in the case's participant list at RM.RECEIVED is therefore not entitlement to case content.

The invitee reaches ACCEPTED only after it receives the full case and runs its triage cycle (§6.3 Per-Participant RM Tracking). If delivery required ACCEPTED, a participant could never obtain the case that it needs to reach the state that gates delivery.

Joining and embargo consent — not RM progress — are the gate on case content. The ordering is: the invitee accepts the stub Invite, which joins the case and agrees to any active embargo it has not declined, and then the CASE_MANAGER delivers the full case.

This gate matters to the cascade ordering of §11 Model Interactions and Cascade Rules. Accept(Invite) agrees to any active embargo on the joiner's row for that embargo, unless that row is DECLINED. This agreement lets delivery proceed immediately, with no wait for a separate consent round-trip. A joiner whose row for the active embargo is DECLINED stays declined, because an explicit refusal outranks the consent that joining implies. That joiner is in the case but inert until it changes its answer.

Requirements

ID Priority Requirement Related
CM-11-001 MUST When a participant accepts the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.

The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this.
Uses definition from: CM-10-001
Extends: BT-10-005

10. Case Coordination [N]

Every case has a CASE_MANAGER. The CASE_MANAGER is a protocol role (CVDRole.CASE_MANAGER), and a participant holds it from case creation onward. The participant that holds it may be the actor that created the case, or an actor that the case's creator delegated case maintenance to. This section names the authority the CASE_MANAGER: whichever participant holds the role for the case (§2.2 Roles).

Requirements

ID Priority Requirement Related
CM-02-014 MUST A VulnerabilityCase MUST have both a CASE_OWNER participant and a CASE_MANAGER participant from the moment of creation onward. Neither slot may be left empty or deferred to a later operation. Role delegation transfers the CASE_MANAGER role without a gap.

An empty CASE_OWNER or CASE_MANAGER slot leaves every role check without an answer from the moment the case exists, and a case created without either has no participant entitled to repair it (ADR-0088). Both creation paths register a CASE_MANAGER: a dedicated CASE_MANAGER actor (ADR-0041), or the creating actor holding both roles. With a CASE_MANAGER always present, every case-scoped message has the CASE_MANAGER to go through (PCR-08-001).
Extends: CM-02-001
CM-24-014 MUST An actor that finds no CASE_MANAGER for a case MUST fail the act, never sending the activity directly to another participant instead (CM-24-008).

An actor that finds no CASE_MANAGER reads a corrupt roster, since a case always has one (CM-02-014). A direct send to a participant would bypass the ledger and the recipient rules (PCR-08-001). It would also hide the corruption behind an apparent success. A failed act shows the corruption (ADR-0113).

This section specifies what the CASE_MANAGER does for its case. It is the only writer of the case's shared state (§10.1 Single-Writer Authority), and every case-scoped message passes through it (§10.2 Routing Topology). The case-creation message is the root of every participant's trust in it (§10.3 Case Bootstrap and the Trust Root). It replicates the case ledger to every active participant and delivers the case to each new one (§10.4 Ledger Replication and Case Delivery). It also decides which participants' claims become the case's canonical status (§10.5 Claims and Canonical Status).

The cascades that the CASE_MANAGER runs when one state machine's transition obliges another are specified at §11 Model Interactions and Cascade Rules. How a participant joins a case, changes role in it and leaves it is at §12 Participant Lifecycle Within a Case.

Informative: the dedicated Case Actor is an implementation choice

The reference implementation runs one Case Actor service per container, which holds the CASE_MANAGER role for all the cases it manages. That choice goes further than the protocol requires. The protocol requires a participant that holds the role, and any participant can hold it, including the Case Owner itself. Nothing in this section depends on whether the holder is a dedicated actor.

10.1 Single-Writer Authority

The participant holding the CASE_MANAGER role is the only entity authorized to write the case's shared state. That shared state is the Public aware, eXploit public, Attacks observed (PXA) axis, the EM state, the Embargo Register, and the case ledger. No other participant writes shared case state directly. Every such change goes through the CASE_MANAGER.

Requirements

ID Priority Requirement Related
VP-17-001 MUST Every change to the canonical case state MUST go through the CASE_MANAGER, so no participant changes that state directly.

This single-writer axiom prevents concurrent-write races and ensures that all shared state changes flow through the actor's consistency checks and persistence layer. The CS participant-specific axes (RM, VFD) are owned by each participant's CaseParticipant record and are intentionally excluded from this restriction.

The participant-specific axes are report management and Vendor aware, Fix ready, fix Deployed (VFD). Each participant's own CaseParticipant record owns these axes, and they are explicitly not subject to this restriction. A participant is the authority on its own report management and VFD state.

This rule exists to make concurrent claims resolvable. Two participants may report contradictory observations about the world at the same moment. With one writer, the case has one answer, and the decision about which claim becomes that answer is explicit (§10.5 Claims and Canonical Status) rather than a race. The routing rule below follows from it.

10.2 Routing Topology

Once a case exists, every case-scoped message follows this path:

Participant → CASE_MANAGER → CaseLedgerEntry → Add(CaseLedgerEntry) → all Participants
  • A participant addresses a case-scoped Activity to the CASE_MANAGER alone, never to the other participants.
  • The CASE_MANAGER records the message in the case ledger, and the ledger entry is what it sends on to the other participants.
  • Add of a CaseLedgerEntry to the case's ledger is the only way a participant learns of an admitted change to shared case state.

Requirements

ID Priority Requirement Related
PCR-08-001 MUST After a case is created and its CASE_MANAGER introduced, a participant MUST address each case-scoped message to that CASE_MANAGER alone, never directly to another participant. Case-scoped messages include notes, status updates, embargo proposals, RM transitions and any other protocol message about the case. The one exception is RK, Read(Offer(VulnerabilityReport)). RK answers the reporter's original Offer outside the case. So an addressee of that Offer sends RK to the reporter, never to the CASE_MANAGER (RMB-08-003, RMB-08-005).

A participant sends each case-scoped message to the CASE_MANAGER, so that the CASE_MANAGER can check the sender, record the change in the case ledger and send it on to the other participants (PCR-08-003). A message sent straight to a peer gets none of these steps, so the peer's replica and the canonical case disagree. RK is not a case message: it answers the reporter's Offer, which the reporter sent to that receiver before the case existed, so the answer goes back to the reporter (RMB-08-003).
See also: RMB-08-005 — context for the reader
PCR-08-005 MUST A participant MUST take the sole to: recipient of a case-scoped message from its case replica. That recipient is the participant holding the CASE_MANAGER role, never the case's full participant list.

The case's full participant list includes actors that are not entitled to every message (CM-10-004), and it reaches peers that the CASE_MANAGER has not yet checked the message for. Taking the CASE_MANAGER from the participant's own replica gives one recipient that the participant already trusts.
PCR-08-003 MUST The CASE_MANAGER MUST, for every participant message it receives and accepts, commit a CaseLedgerEntry recording the outcome and broadcast Add(CaseLedgerEntry) to the case's active participants (CM-10-004) as the standard cascade. This cascade is the only mechanism by which participants learn of accepted case-state changes.

Participants learn of case changes only from the ledger. If the CASE_MANAGER applied a change without an entry, or recorded an entry without sending it, the other replicas would never learn of the change and would disagree with the canonical case.
Uses definition from: CM-10-004
PCR-08-002 MUST NOT A participant actor MUST NOT assume that other participants will receive its case-scoped messages through any channel other than the CASE_MANAGER's Add(CaseLedgerEntry) broadcast. Sending to the whole roster or any multi-recipient list that includes non-CASE_MANAGER actors is a violation of this rule.

Only the CASE_MANAGER's Add(CaseLedgerEntry) tells a participant what the case ledger holds. A participant that sends its message to other participants as well gives them a change that the CASE_MANAGER has not yet checked or recorded, and they may act on a change that the CASE_MANAGER later refuses.

There are exactly two exceptions, and both are confined to case bootstrap. Both occur before the reporter has been introduced to the CASE_MANAGER, so the reporter has none to route through (§10.3 Case Bootstrap and the Trust Root):

  1. Pre-case report submission — the reporter sends the report directly to the vendor. No case exists, and therefore no participant holds the CASE_MANAGER role.
  2. Case creation handshake — the receiving party sends the case-creation message back to the reporter as itself. That message introduces the actor that holds the role (§10.3 Case Bootstrap and the Trust Root). When that actor is not the receiving party, its first message to the reporter is a later sync. The reporter holds that sync if it arrives before the introduction.

Requirements

ID Priority Requirement Related
CBT-01-010 MUST When the actor enacting CASE_MANAGER is not the report receiver, the CASE_MANAGER MUST NOT address its Create(VulnerabilityCase) to the original report submitter. That activity goes to the report receiver (the Case Owner), which relays the introduction (CBT-01-001). The CASE_MANAGER's first message to the submitter is an Announce. A submitter that receives it before the introduction holds it under CBT-03-001 and CBT-03-002.

The submitter never addressed the CASE_MANAGER, so a Create from it cannot be checked against anything the submitter wrote (CBT-01-005). Introducing the CASE_MANAGER through the actor the submitter chose keeps one trust anchor for the submitter and removes the route that trusted a sender because its own snapshot named it (ADR-0132).
Uses definition from: CBT-01-001
Derives from: CBT-01-005
See also: CBT-03-001 — context for the reader
See also: CBT-03-002 — context for the reader

The report acknowledgment, RK, falls outside this rule rather than adding a bootstrap exception. It answers the reporter's original report offer, outside the case, so it goes to the reporter directly, never to the CASE_MANAGER. The routing requirements above state this exception.

This is a routing rule, not a prohibition on talking

The rule above scopes Vultron protocol messages about a case. It does not say that participants may not communicate with each other, and the protocol has no way to enforce such a thing. Participants routinely talk directly — by mail, by phone, in a shared channel — and that is outside the protocol's scope.

What the rule means is narrower. A case-scoped Vultron Activity delivered directly from one participant to another is not part of the protocol. A receiving implementation has no obligation to apply it. Case state changes through the ledger or not at all.

Informative: why route through one writer

Routing through a single writer avoids the coordination cost of agreeing an order among peers, while still leaving each participant its own replica and its own view. The cost is that the CASE_MANAGER is a single point of coordination authority for the case, and its availability bounds how fast that case can progress.

This is scoped per case. The role is held for one case at a time, different cases may be managed by different actors, and the role is transferable (§12.3 Case Ownership Transfer).

The protocol deliberately leaves more decentralized realizations open. One example is a ledger shared among peers. It would remove the single point of authority, but it would need agreement on ordering. This version does not specify one, and no implementation of one exists.

10.3 Case Bootstrap and the Trust Root

A case's trust is established at its bootstrap, the step from the pre-case exchange to a case with a CASE_MANAGER.

The case-creation message is the trust root. When a case is created for a report, the receiving party sends the reporter a case-creation message as itself: the actor the reporter chose. That message introduces the actor holding the CASE_MANAGER role, which may be the receiving party or another actor it delegated case maintenance to. The reporter trusts the introduction because it came from the actor the reporter addressed, and never because a case snapshot names its own sender. Every participant's trust in the ledger derives from it: a participant accepts entries from the CASE_MANAGER because it accepts the message that established which actor holds the role.

Requirements

ID Priority Requirement Related
CBT-01-001 MUST When a case is created in response to an inbound Offer(VulnerabilityReport), the actor that received the report (the report receiver) MUST establish trust at the original report submitter by sending it, as itself, a one-time Create(VulnerabilityCase) activity. When the CASE_MANAGER is a different actor from the report receiver, that activity introduces the CASE_MANAGER the receiver delegated case maintenance to (ADR-0132).

The reporter must learn that its report became a case, and which actor coordinates the case. The submitter chose the report receiver and wrote a record of that choice before the case existed. A case that arrives first from an actor the submitter never addressed gives it nothing to check the sender against, and a roster the sender wrote is not an anchor. The receiver already knows the CASE_MANAGER, so it vouches for it.
CBT-01-005 MUST NOT A report submitter MUST NOT trust a newly introduced CASE_MANAGER unless its bootstrap Create(VulnerabilityCase) comes from the report's receiver and references the submitted report.

The report receiver is an actor the submitter chose when it sent the report. The record the submitter wrote when it sent the report ties the report to that actor, so the sender cannot forge it (PCR-05-001). The sender writes the roster in the snapshot, so any actor can name itself CASE_MANAGER there. The report reference also stops an actor from attaching an unrelated case to the submitter.
CBT-01-017 MUST The report submitter MUST check the bootstrap of CBT-01-005 against a record it wrote itself before the case arrived, never against the snapshot's roster.

The sender writes the roster in the snapshot, so any actor can name itself CASE_MANAGER there. The record the submitter wrote when it sent the report ties the report to the actor it chose, so the sender cannot forge it (PCR-05-001).
Implements: CBT-01-005
CBT-01-011 MUST A participant MUST refuse a bootstrap Create(VulnerabilityCase) from a sender no trust anchor it wrote names as the expected sender, and store nothing from it. A snapshot naming that sender as CASE_MANAGER does not change this (CBT-01-017).

The sender wrote the snapshot, so a roster in it proves nothing about the sender's authority (ADR-0132; notes/participant-case-replica.md).
Refines: CBT-01-005
See also: CBT-01-017 — context for the reader

The case-creation message carries the whole case inline. A receiver seeds its replica of the case from this one message, and it trusts no actor to fetch a missing part from until it accepts the message. So the message carries the complete case and each CaseParticipant record inline rather than by reference. It may name the report by reference: the receiver offered that report, so it already holds it. A receiver that finds a required participant missing, or named only by reference, rejects the message as a protocol error.

Requirements

ID Priority Requirement Related
CBT-01-002 MUST The bootstrap Create(VulnerabilityCase) activity MUST carry the complete VulnerabilityCase inline, rather than a reference, a minimal stub or a partial trust-only payload.

The receiver seeds its Participant Case Replica from this activity. A stub or a partial case leaves it nothing complete to seed from. A reference leaves it nothing to read: it has no trusted source to fetch the case from, because it trusts the CASE_MANAGER only after it accepts this activity (ADR-0170).
Refines: AKM-03-001
CBT-01-007 MUST The bootstrap Create(VulnerabilityCase) payload MUST carry each CaseParticipant record the case lists inline.

The receiver seeds its replica from this payload, and later guards read the participant records it seeds, such as the participant checks on a sender. A record the payload leaves out is one the replica lacks when a guard needs it. A record named only by reference is left out too: the receiver does not fetch it (AKM-05-007), because before it accepts this activity it has no trusted source to fetch it from (ADR-0170).
Refines: CBT-01-002
CBT-05-008 MUST This rule covers a receiver that finds required participant data absent from a bootstrap Create(VulnerabilityCase) (CBT-01-007). It MUST reject the bootstrap as a protocol error, never skipping the participant, inferring its state, or synthesizing a record from data the payload lacks.

Silent reconstruction of missing protocol data masks protocol bugs: a fallback that fills in missing data "from domain knowledge" makes the protocol look as if it works when it does not, so the failure must be visible to be diagnosed and fixed. Replicas are built only from ledger content; data not in the ledger did not happen. A participant the payload names only by reference is absent too: CBT-01-007 requires it inline, and the receiver does not fetch it (AKM-05-007).
Derives from: CBT-01-007

A late joiner inherits that trust transitively. An actor invited after the case is under way never sees the original creation message. It trusts the invitation that named the CASE_MANAGER. It then receives the case snapshot and the prior ledger entries from the CASE_MANAGER (§10.4 Ledger Replication and Case Delivery). It trusts them because it trusts that invitation.

Requirements

ID Priority Requirement Related
CBT-04-001 MUST For a participant added after case creation, the trust-establishing message MUST be InviteActorToCase from the CASE_MANAGER rather than Create(VulnerabilityCase).

A late joiner submitted no report, so it holds no record that ties a case to an actor it chose. The stub Invite gives it one: the joiner chooses to accept it, and the accepted Invite is its Trust Anchor for the case (PCR-03-004). A Create(VulnerabilityCase) from an actor the joiner never dealt with gives it nothing to check the sender against.
CBT-04-002 MUST The trust-establishing invite for a late joiner MUST identify both the case and the CASE_MANAGER that will send subsequent Announce(VulnerabilityCase) updates.

The joiner checks each later Announce(VulnerabilityCase) against the Trust Anchor the Invite left. If the Invite does not name both the case and the CASE_MANAGER, the joiner cannot tell which sender to trust for which case.

The hash-chaining of the ledger lets the joiner verify it received an unbroken history. This is a check against tampering and omission, not a second source of trust.

The threat model, identity verification, and the limits of this trust chain are covered at §16.1 Trust Model.

10.4 Ledger Replication and Case Delivery

The CASE_MANAGER keeps every active participant's replica in step with the case through two operations.

Operation What the CASE_MANAGER does
Ledger replication Sends each committed ledger entry to every active participant, as Add(CaseLedgerEntry). This is the only way a participant learns of an admitted change to shared case state (§10.2 Routing Topology)
Case delivery Sends a participant the full case once it is an active participant (§9.7 Gating Full Case Delivery), then the ledger entries committed before it joined, oldest first (§11.1 Admitting a Participant)

Their wire activities are given at §4.12 Ledger Replication Messages and §4.7 Case and Participant Messages. Both operations reach only active participants. Being in the case's participant list is not enough.

Requirements

ID Priority Requirement Related
CM-10-004 MUST The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).

Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122).
Uses definition from: CM-14-001
Uses definition from: CM-18-001
Uses definition from: CM-31-001
CM-17-005 MUST NOT Presence in the case participant list MUST NOT be treated as acceptance of the invitation or as entitlement to case content. An invitee is in the list from the stub Invite onward (CM-11-006); only an active participant (CM-10-004) is entitled to case content.

The CASE_MANAGER tracks every invitee from the moment it is invited, including one that declines, so the participant list holds inert participants. Any consumer that reads membership as "accepted" would hand case content to an actor that has not consented.
Uses definition from: CM-10-004
See also: CM-11-006 — context for the reader

A ledger entry records the asserted activity as it was sent. Its payload snapshot is the received body of an activity the CASE_MANAGER received, or the body it delivered for one it sent itself. Each nested object stays as the asserting activity carried it. It stays inline where its sender inlined it, and by reference where its sender named an object every replica already holds.

Requirements

ID Priority Requirement Related
CLP-07-011 MUST The payloadSnapshot of a CaseLedgerEntry MUST be the verbatim AS2 activity that was asserted, with no field of it dropped, re-serialized, inlined, patched or merged. For an activity the CASE_MANAGER received, it is the JSON body as received (VM-08-002). For one the CASE_MANAGER emits, it is the body it delivered (VM-08-003). An activity the CASE_MANAGER sends and ledgers is one activity. So the case's genesis entry is the Create(VulnerabilityCase) it sends for the case, not a second activity built for the ledger. The metadata the CASE_MANAGER adds lives on the entry, outside the snapshot: the index, the hashes, the commit and receipt times, and the case it names in its context.

The payload snapshot is the replication substrate, and the entry hash covers it, so what it holds is what every replica treats as the event. A snapshot rebuilt from the receiver's object graph records the receiver's reconstruction, not what the sender claimed, and every rewrite is one more thing a replica must reproduce exactly to verify a hash (ADR-0107).
Uses definition from: VM-08-002
Refines: VM-08-003
CLP-07-006 MUST The CASE_MANAGER MUST record each nested object of a payloadSnapshot exactly as the asserted activity carried it, never inlining, resolving or replacing a reference. An entry the CASE_MANAGER authors carries in full every object it records. A received entry is the received body (CLP-07-011). So an object is inline where its sender inlined it, as a sender does every object its recipient cannot be expected to hold. It is bare where its sender named an object the case's replicas already hold (AKM-02-002). A replica that does not hold an object named by reference dereferences it.

A protocol rule, not this prototype's inline-object shortcut (AKM-03-003): the entry hash covers the payloadSnapshot and nothing outside it, so an object carried in full is under the hash every participant verifies, and an object named by id is only identified by it. Filling a reference in at the CASE_MANAGER would put the receiver's reconstruction in place of what was sent, and a replica could not tell the sender's claim from the fill-in (ADR-0107).
See also: AKM-02-002 — context for the reader
See also: CLP-07-011 — context for the reader
CLP-07-018 MUST NOT The CASE_MANAGER MUST NOT refuse an entry for a bare reference anywhere but the snapshot's own object, whose type is half of the entry's signature.

A sender may name by id any object the case's replicas already hold (AKM-02-002), so a bare reference elsewhere is a valid entry. Only the snapshot's own object must be inline, because its type selects the entry's signature.
Derives from: CLP-07-006

The CASE_MANAGER never fills a reference in. The entry hash covers the snapshot and nothing outside it. A filled-in snapshot would thus record the CASE_MANAGER's reconstruction, not what was sent. The entry hash is computed over the RFC 8785 JSON Canonicalization Scheme (JCS) serialization of the content it covers (§5.2 Serialization), so every replica hashes the same bytes for it. How a message carries an object inline or by reference is specified at §5.2 Serialization.

10.5 Claims and Canonical Status

Two status records carry the case's state, and they are the most easily confused types in the protocol (§4.3 Object Types). The difference between them is one of authority rather than content.

  • A ParticipantStatus is a claim. It carries what one participant reports about its own state, or observes about the world. Any participant may write one, and writing one does not change what the case asserts.
  • A CaseStatus is canonical. It carries what the case asserts: its embargo state and what is publicly known. Only the CASE_MANAGER writes it (§10.1 Single-Writer Authority).

A claim becomes canonical only when the CASE_MANAGER adopts it. Adoption is an authorization decision with a named default, not an automatic consequence of receipt (§11.3 Status Adoption: One Authorization Gate). The two types are not interchangeable. A participant that emits CaseStatus is asserting authority it does not hold. A CASE_MANAGER that treats an inbound ParticipantStatus as canonical has skipped the decision.

The status messages depend on who is sending. The six case state shorthands (§4.9 Case State Messages) do not have one wire form; they have two, and the sender's authority decides which applies:

  • A participant reporting its own VFD progress, or an observation about the world, sends Add of a ParticipantStatus. This is a claim.
  • The CASE_MANAGER, having adopted a claim, sends Add of a CaseStatus targeting the case's status history, <case>/statuses. This is the canonical write.

A participant never sends Add of a CaseStatus, and a receiver refuses one from any sender other than the CASE_MANAGER.

Requirements

ID Priority Requirement Related
RSH-04-001 MUST NOT An actor that is not the CASE_MANAGER MUST NOT emit Add(CaseStatus).

CaseStatus encodes shared EM and PXA state for the entire case. The CASE_MANAGER is the authoritative writer of canonical case state (ADR-0210, CLP-09). Allowing participants to emit Add(CaseStatus) directly would bypass the adoption authorization model.
RSH-04-007 MUST A participant that is not the CASE_MANAGER MUST report the CaseStatus it suggests by embedding it in its own Add(ParticipantStatus).

A participant cannot send Add(CaseStatus) (RSH-04-001), but its view of P, X or A still needs to reach the case. Embedding it in the participant's own status puts it through the adoption gate (RSH-01-003).
Extends: RSH-04-001
RSH-04-005 MUST A receiver MUST refuse a received Add(CaseStatus) unless the case's CASE_MANAGER sent it to a participant.

RSH-04-001 reserves Add(CaseStatus) for the CASE_MANAGER, which sends it to participants inside a case ledger entry. add_case_status_tree has no StatusAdoptionGate, so admitting it from another sender would adopt that participant's P, X or A report without the Case Owner approval RSH-07-001 requires. A participant embeds the P, X or A it reports in its own Add(ParticipantStatus) instead (RSH-04-007), which the CASE_MANAGER adopts through the gate (RSH-01-003).
Derives from: RSH-04-001
Refines: HP-01-006
RSH-04-012 MUST When a receiver refuses an Add(CaseStatus) under RSH-04-005, it MUST write nothing past intake and send nothing.

A refused status is one the receiver must not act on. A write past intake would change case state on the refused claim, and a reply would answer a sender that had no right to send it.
Extends: RSH-04-005

An implementation that maps all six shorthands to CaseStatus regardless of sender will have participants asserting authority they do not hold. The rest of the shorthand mapping is at §4.13 Formal Message Set.


11. Model Interactions and Cascade Rules [N]

The five state machines are not independent. A transition in one produces obligations in others, and this section specifies those couplings.

Each coupling is a cascade: a state change raises a domain event, and the CASE_MANAGER handles that event by applying further changes. Every cascade step is authorized separately, and where the order of steps matters this section says so. The cascades below are the complete set that this specification requires.

Recall: which machine owns which state

Machine Ownership Written by
Report Management (RM) Participant-specific The participant is the source, and the CASE_MANAGER records each value on the participant's record. The CASE_MANAGER also writes the invitee's initial Received when it sends the stub Invite, keeps Received when the invitee accepts it, and writes Closed when the invitee rejects it.
Vendor aware, Fix ready, fix Deployed (VFD) Participant-specific The participant is the source, and the CASE_MANAGER records each value on the participant's record. For a vendor invitee, the CASE_MANAGER also writes the initial vfd when it sends the stub Invite, and Vfd when the invitee accepts or rejects it.
Embargo Management (EM) Shared case state The CASE_MANAGER only
Public aware, eXploit public, Attacks observed (PXA) Shared case state The CASE_MANAGER only
Participant Embargo Consent (PEC) Per-participant The CASE_MANAGER only

11.1 Admitting a Participant

When an actor accepts the stub Invite, the CASE_MANAGER admits it to the case and delivers the case content. The CASE_MANAGER created the actor's inert participant record, at RM state Received, when it sent the stub Invite (§12.2 Invitation and Acceptance). The steps are ordered because each one supplies a precondition for the next.

---
title: Admitting a participant
---
sequenceDiagram
    autonumber
    participant I as Invited actor
    participant CM as CASE_MANAGER
    participant P as Active participants

    I->>CM: Accept(Invite(VulnerabilityCase preview)[target=Actor])
    CM->>CM: Commit ledger entry for the acceptance
    CM->>P: Add(CaseLedgerEntry)
    CM->>CM: Record effect: RM stays Received, embargo consent AGREED
    CM->>I: Announce(VulnerabilityCase) — full case content
    CM->>I: Prior ledger entries, oldest first
    CM->>I: Invite(whole VulnerabilityCase)[target=Actor] — full-case Invite

On receiving Accept(Invite), the CASE_MANAGER performs these four steps in this order:

  1. Commit a ledger entry recording the acceptance, and send that entry to every active participant.
  2. Record the acceptance's effect on the participant. Its RM state stays Received. Its consent row for the active embargo, if any, becomes AGREED, unless the participant had declined that embargo.
  3. When the participant is now active, send Announce(VulnerabilityCase) carrying the full case snapshot, then replay the ledger entries committed before this participant joined, oldest first.
  4. Send the full-case Invite, which asks the participant to judge the case.

Requirements

ID Priority Requirement Related
CM-17-004 MUST When the CASE_MANAGER receives Accept(Invite(VulnerabilityCase preview)[target=Actor]) from an invitee, it MUST, in this order: (1) commit a ledger entry for the Accept and fan it out to every active participant (CM-10-004); (2) record the Accept's effect on the participant (CM-11-001); (3) when the participant is now active, send it Announce(VulnerabilityCase) and replay all prior CaseLedgerEntry records to it in log-index order (CM-11-008); and (4) send it the full-case Invite (CM-11-010).

Each step needs the step before it. The ledger records the Accept before any step acts on it (CLP-10-006). The participant's record must show that it joined before the participant is active and entitled to content (CM-10-004). The participant must hold the case and its history before it can make a decision about the case. Delivery to each recipient is in order (ADR-0112). Thus the full-case Invite, which the CASE_MANAGER queues last, arrives when the participant can answer it (CM-11-010).
Uses definition from: CM-11-001
Uses definition from: CM-11-008
Uses definition from: CM-11-010
Uses definition from: CM-10-004
CM-11-001 MUST When a participant accepts the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.

The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this.
Uses definition from: CM-10-001
Extends: BT-10-005
CM-11-008 MUST When the CASE_MANAGER processes Accept(Invite(VulnerabilityCase preview)[target=Actor]) and the participant is active (CM-10-004), it MUST send the participant Announce(VulnerabilityCase) and begin replaying the case ledger to it without waiting for any further signal from the participant.

The participant is entitled to case content from the moment it is active, and the history is part of what it then judges. The Accept is the readiness signal; out-of-order arrival is buffered (SYNC-14, SYNC-15) and a real gap is recovered by Reject(CaseLedgerEntry) and replay.
Uses definition from: CM-10-004
CM-11-010 MUST After CM-11-008, the CASE_MANAGER MUST send the participant the full-case Invite, Invite(whole VulnerabilityCase)[target=Actor], queued after the last replayed ledger entry.

AS2 puts what one is invited to in object, so the Invite carries the whole case it asks the participant to judge (ADR-0205); the participant is active, so it is entitled to it (CM-10-004), and reads the case from its own replica. Delivery to each recipient is ordered (ADR-0112), so queuing the Invite after the replay means it usually arrives once the participant can answer it. The protocol does not rely on that order (ADR-0161): CM-11-033 covers an Invite that arrives first.
Depends on: CM-11-008
CM-11-031 MUST The full-case Invite MUST name the case by ID and carry the log_index and entry_hash of the CASE_MANAGER's ledger tail when it issued the Invite.

The Invite's ledger position is the floor the participant must reach before answering (ADR-0121). It travels as the Invite's ledgerPosition, the property every case activity carries (VAM-04-011, SYNC-18-001, ADR-0156).
Extends: CM-11-010
CM-11-032 MUST A receiver MUST refuse a full-case Invite whose sender is not the CASE_MANAGER on its replica of the case.

Only the case's CASE_MANAGER may ask a participant to judge the case. The receiver judges the Invite only when it holds the replica (CM-11-033), so the replica's CASE_MANAGER is the only record the sender check needs. The stub-Invite trust anchor decides an earlier question: whether the Announce may create that replica (PCR-03-004).
CM-11-033 MUST A receiver MUST NOT judge a full-case Invite for a case it holds no replica of.

The protocol does not rely on delivery order (ADR-0161), so the Invite can arrive before the Announce (CM-11-010). It is case-scoped: the inbox's defer check holds it until the Announce creates the replica, then replays it (HP-01-041). With no trust anchor, no Announce can create the replica (PCR-03-004), so the held Invite expires unprocessed (CBT-03-003) and the receiver fails closed.
Extends: CM-11-032
Depends on: HP-01-041

Recall: report management states

State Meaning
Start No report has been received
Received A report has arrived; triage is not yet complete
Invalid This participant assessed the report as invalid
Valid This participant assessed the report as valid
Deferred This participant is deferring further action
Accepted This participant accepted the report for active work
Closed This participant closed the report

Full definitions are in §6.1 States.

Step 3 delivers the content that step 2 authorizes: the embargo consent recorded in step 2 is what the delivery gate tests (§9.7 Gating Full Case Delivery). Step 4 follows the replay, so the participant judges a case it already holds.

11.2 Embargo Revision and Termination Cascades

A change to the embargo in force propagates to participants' consent, because consent is given to specific terms. A change that is only proposed does not. Each cascade below starts from a step on the case's embargo register (§7.1.1 The Embargo Register), and the EM state follows from the register.

Recall: embargo management states

State Meaning Embargo register entries
None No embargo is in effect for this case, and none is proposed none ACTIVE, PROPOSED or TERMINATED
Proposed At least one embargo is proposed, and none is in force one or more PROPOSED, none ACTIVE
Active An embargo is in force, and no revision is open one ACTIVE, none PROPOSED
Revised An embargo is in force, and at least one revision of it is open one ACTIVE, one or more PROPOSED
Exited The embargo has been torn down one TERMINATED

Full definitions are in §7.1 States.

A revision is proposed (EM enters, or stays at, Revised). The register gains a PROPOSED entry for the revision, and every other participant gets an UNINVITED row for it. No consent to the embargo in force changes: the prior embargo is still in force and every signatory to it remains one. The CASE_MANAGER records the proposer's row for the revision as AGREED, because proposing terms is consenting to them.

Requirements

ID Priority Requirement Related
CM-18-001 MUST Each participant record MUST hold one embargo consent row for every entry in the case's embargo register. Each row holds one of five states. The UNINVITED state means not asked, and is the start state. The INVITED state means asked, with no answer yet. The AGREED state records agreement, and DECLINED records an explicit refusal or a withdrawal. The TIMED_OUT state means invited, with the RSVP deadline passed and no answer. A participant is a signatory when its row for the register's ACTIVE entry is AGREED. A participant has lapsed when three things hold. An entry is ACTIVE, and the participant's row for it is neither AGREED nor DECLINED. Following replaces back from the ACTIVE entry, the first entry whose row is AGREED or DECLINED has an AGREED row. Both positions are read from the rows and the register, never stored (CM-18-016). With no ACTIVE entry, nobody is a signatory and nobody has lapsed.

One row for each pair of participant and embargo records each answer one time. To find if a participant is bound by the active embargo, a reader looks at the row for the active embargo. Thus there is no second record to reconcile, and a first proposal and a revision use the same rules (ADR-0122). TIMED_OUT is different from DECLINED, so that every reader can tell silence from a refusal (ADR-0118). A terminated embargo is a fact of the register, not a fact about each participant. A lapse follows the replaces chain. Thus only an embargo that was in force can bind, and a withdrawal from a later embargo ends the binding of an earlier embargo.
CM-18-019 MUST Proposing an embargo MUST write an UNINVITED consent row for it on every current participant.

A participant that was not asked holds a row that says so. Thus no reader infers "not asked" from a missing record, and a check can use the register to find a row for each participant and each embargo (CM-18-001).
Implements: CM-18-001
CM-18-020 MUST Creating a participant record MUST write an UNINVITED consent row on it for every entry already in the case's embargo register.

A participant that joins after embargoes were proposed was asked about none of them. A row for each entry records that, so the participant holds a row for every entry from its creation on (CM-18-001), and no reader meets a missing row.
Implements: CM-18-001
CM-18-021 MUST NOT A reader MUST NOT read a missing consent row as any consent state. A missing row is a defect.

Every row is written (CM-18-019, CM-18-020), so a missing row comes only from a fault. A reader that treated it as UNINVITED, or as any other state, would hide the fault, and could count a participant as asked, bound or free when it is not.
Extends: CM-18-001
EP-05-002 MUST NOT A revision proposal (ACTIVE → REVISE) and any further counter-revision (REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force. The proposer's row for the proposed embargo becomes AGREED (MSM-07-022). Every other participant gets an UNINVITED row for it (CM-18-001). Every other row stays as it is until the Case Owner activates a revision (EP-05-001, EP-05-003). Until then the prior embargo stays in force, and every signatory to it remains one.

A participant cannot lapse until the embargo on the case differs from the one they agreed to. Lapsing on proposal would strand signatories when the revision is rejected, report participants who are still bound and still receive embargoed content as not bound, and lapse the proposer of the revision (ADR-0093). With per-embargo rows a proposal only ever adds rows for the proposed embargo.
Uses definition from: CM-18-001
Refines: MSM-07-022
See also: EP-05-001 — scope boundary: a different transition
See also: EP-05-003 — context for the reader

The Case Owner activates the revision. The register activates the revision's entry and supersedes the entry in force, in one step. EM returns to Active, or stays at Revised while another revision is open. The owner's row for the revision becomes AGREED unless it already is. If the revision ends no later than the embargo it replaces, the CASE_MANAGER applies CARRY_OVER. That transition goes to the revision's row of every participant whose row for the replaced embargo is AGREED, a DECLINED revision row included. If the revision ends later, no row is written. In that case, a signatory to the replaced terms whose row for the revision is not AGREED has lapsed. That lapse is read from its rows and the register (§9.3 Signatory and Lapsed). A participant that has already agreed to the revision is its signatory by lookup.

Requirements

ID Priority Requirement Related
EMB-18-005 MUST Every change to a case's embargo register MUST move the case's EM state only along an EM transition for the change's EM trigger: a proposal is propose, an activation is accept, a rejection, or the cancellation of open proposals with no embargo in force, is reject, and a termination is terminate. The EM transitions are propose: N→P, P→P, A→R, R→R; reject: P→N, P→P, R→A, R→R; accept: P→A, P→R, R→A, R→R; and terminate: A→X, R→X. A rejection leaves Proposed, and a rejection or an acceptance leaves Revise, only when no proposal remains open; an acceptance from Proposed moves to Active, or to Revise while another proposal stays open.

EM is computed from the embargo register (ADR-0122), not replaced by it: the EM state machine remains the protocol's model, and the register is a layer beneath it. With several proposals open, rejecting or activating one leaves the others open: a rejection keeps EM in Proposed or Revise until the last one is off the table, and an activation from Proposed puts the embargo in force with the others pending as revisions, in Revise (ADR-0130).
Extends: EMB-18-001
EP-05-001 MUST NOT This rule covers the Case Owner's activation of a revised embargo that ends later than the embargo it replaces (REVISE → ACTIVE). The CASE_MANAGER MUST NOT carry any participant's consent over to it.

A participant who signed for terms T1 has not consented to longer terms T2; treating them as a signatory once T2 is in force would imply consent they never gave. A participant is bound by the revised embargo only through an AGREED consent row for it, so each signatory to the replaced embargo that has not agreed to the revised one has lapsed (CM-18-001), and no write is needed to lapse them. The rule applies at activation rather than at proposal because the participant remains bound by T1 for as long as T1 is the active embargo (ADR-0093, ADR-0122).
Uses definition from: CM-18-001
EP-05-003 MUST This rule covers the Case Owner's activation of a revised embargo that ends no later than the one it replaces. The CASE_MANAGER MUST apply CARRY_OVER to the revised embargo's row of each participant with an AGREED row for the replaced embargo. That includes a participant whose row for the revision is DECLINED (CM-10-001, CM-18-003, MSM-07-005).

Shorter terms ask nothing new: agreeing to N days is agreeing to every shorter period, the same containment that makes shortest-wins (EP-04-003) safe without asking anyone, so their agreement is carried over by writing the row. That holds for a participant that declined the shorter revision too: its decline objected to losing time, not to keeping the embargo, and the decline stays in the ledger (ADR-0122).
Uses definition from: CM-18-001
Uses definition from: CM-18-003
Refines: MSM-07-005
See also: CM-10-001 — context for the reader
MSM-07-005 MUST This rule covers the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] (MSM-07-008) that replaces active embargo A with revision B. The register activates B and supersedes A, so the derived EM goes REVISE → ACTIVE, or stays REVISE while another proposal is open (EMB-18-005). Implementations MUST settle every participant's consent rows against B.

Only the owner's acceptance changes the embargo on the case; other participants' accepts and rejects are recorded per embargo and inform that decision. When it replaces the embargo in force, each participant's standing has to be read again against the new terms (ADR-0093).
Uses definition from: CM-18-003
Uses definition from: MSM-07-008
Uses definition from: EMB-18-005
MSM-07-021 MUST NOT A revision proposal (EV, ACTIVE → REVISE, or a counter-revision REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force.

While a revision is merely proposed the prior embargo is still in force and every signatory to it is still bound by it, so nothing about their consent has changed (ADR-0093).
MSM-07-022 MUST When a participant proposes a revision, implementations MUST mark the proposer's row for the proposed embargo AGREED.

Proposing terms is agreeing to them, so the proposer needs no Invite of its own proposal.
Extends: MSM-07-021
MSM-07-023 MUST The CASE_MANAGER MUST commit each carried-over row as its own CASE_MANAGER Update(EmbargoConsent) ledger entry, after the Accept's entry. The owner's own row is what its Accept states, applied from the Accept's entry.

The CASE_MANAGER decides the carry-over. Committing each carried-over row as its own entry keeps every replica's consent rows in step with the CASE_MANAGER's.
Implements: EP-05-003
MSM-07-024 MUST Every replica MUST copy the CASE_MANAGER's carried-over consent entries rather than run the carry-over itself (ADR-0124, CLP-07-013, CM-23-016).

A replica that ran the containment comparison on its own state could reach a different answer from the CASE_MANAGER's.
Depends on: MSM-07-023
Refines: CM-23-016
See also: CLP-07-013 — context for the reader
MSM-07-020 MUST NOT This rule covers the owner's activation of revision B in place of active embargo A, where B ends later than A. Implementations MUST NOT write any consent row to lapse a participant. A participant whose row for B is not AGREED is not a signatory to B, and has lapsed if it had agreed to A (CM-18-001).

Longer terms ask for more than the signatories of A promised, so only those who agreed to B are bound by B, and the rows say so without a write.
Refines: MSM-07-005
Uses definition from: CM-18-001

The Case Owner rejects the revision. The register rejects the revision's entry. EM returns to Active once no other revision is open. No consent row changes, the owner's included, and the prior terms stand. One case differs: when the rejected revision is the last open one and the case is already public, exploited or attacked, the same act also terminates the embargo.

Requirements

ID Priority Requirement Related
MSM-07-009 MUST The wire activity REJECT_EMBARGO_PROPOSAL_ON_CASE (wire form: Reject(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST reject the named proposal's embargo register entry. Once no other proposal is open, the derived EM becomes NONE (ER) or stays ACTIVE with the prior terms in force (EJ). It stays PROPOSED or REVISE while another proposal is open (EMB-18-005).

The owner's rejection decides the proposal for the case; whether the owner, as a participant, also refuses those terms is a separate Reject of the Invite (MSM-07-004). The owner's own row does not constrain the rejection: an owner that accepted terms for itself may still reject them for the case (ADR-0180). Keeping the two apart lets the owner keep the prior terms without declining them (ADR-0122).
Uses definition from: VAM-05-009
Uses definition from: EMB-18-005
MSM-07-030 MUST The CASE_MANAGER MUST accept REJECT_EMBARGO_PROPOSAL_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Deciding a proposal for the case is the Case Owner's authority, so no other participant's activity may reject it for the case.
Extends: MSM-07-009
Refines: HP-01-006
MSM-07-033 MUST The CASE_MANAGER MUST refuse REJECT_EMBARGO_PROPOSAL_ON_CASE before committing it when the named embargo is not an open proposal of the case.

There is nothing to decide, and a committed entry naming no open proposal would be applied by every replica that copies it.
Extends: MSM-07-009
MSM-07-031 MUST NOT REJECT_EMBARGO_PROPOSAL_ON_CASE MUST NOT change any participant's consent rows, the Case Owner's included.

The owner's decision for the case is not its consent as a participant; that is a Reject of the Invite (MSM-07-004).
Extends: MSM-07-009
MSM-07-032 MUST This rule covers REJECT_EMBARGO_PROPOSAL_ON_CASE of the last open revision while CS is public, exploited or attacked. The CASE_MANAGER MUST also terminate the embargo in the same act (EMB-04-002). It trial-applies both steps before committing either. It commits the Reject's entry carrying the REJECT step, then its own ET Remove(EmbargoEvent) entry carrying the TERMINATE step. A refused termination commits neither.

Reverting to the prior terms is not viable once disclosure has happened, so the rejection ends the embargo. Deciding both steps together means a replica copying both entries ends with the revision REJECTED and EM EXITED, as the CASE_MANAGER does.
Extends: MSM-07-009
Refines: EMB-04-002
EMB-04-002 MUST The CASE_MANAGER in EM Revise (q^em ∈ R) with CS in a public/exploit/attack state (q^cs ∉ ···pxa) that commits the Case Owner's EJ of the last open revision MUST emit ET in the same act to terminate the embargo, rather than reverting to Active.

Reverting to Active is not viable once public disclosure has occurred. VP-09-001 requires termination in these states. "Rather than reverting" describes where the act ends: EM ends EXITED, never back in Active. Inside the act, the CASE_MANAGER records the rejection as decided (the revision REJECTED) and then terminates the embargo, as two entries a replica copies in order (MSM-07-032, CM-23-016).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...P..
- EM state: REVISE
- CS pattern: ...P..
- EM state is Revise; CS matches pattern ....X.
- EM state: REVISE
- CS pattern: ....X.
- EM state is Revise; CS matches pattern .....A
- EM state: REVISE
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Commit the Case Owner's EJ, then emit ET to terminate the embargo in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- ET emitted; EM state is EXITED

Refines: VP-09-001 — Embargoes SHALL terminate immediately when public/exploit
Uses definition from: MSM-02-004 — EJ shorthand wire-type mapping

The embargo is terminated (EM enters Exited). The register terminates the entry in force and cancels every open proposal in the same step. No consent row is written. With no ACTIVE entry, no participant is a signatory and none has lapsed. Every row for the terminated and canceled entries is frozen as it stood, so an accept that arrives afterwards records nothing.

Requirements

ID Priority Requirement Related
EP-08-004 MUST When an embargo terminates (EM ACTIVE or REVISE → EXITED), the implementation MUST close every open proposal, cancelling it in the same embargo register step that terminates the embargo (ADR-0122), not only the entry for the terminated embargo itself. Every proposal open while EM is ACTIVE or REVISE is a revision of the active embargo, and a revision of an embargo that no longer exists cannot be accepted.

A case has at most one active embargo (VP-04-002), so while EM is ACTIVE or REVISE every open proposal is by construction a revision of that embargo; no field linking a revision to the embargo it revises is needed to know which proposals a termination decides. EP-08-003's text reaches the terminated embargo; this entry reaches the proposals about it.
Refines: EP-08-003
MSM-07-006 MUST When an ET / REMOVE_EMBARGO_EVENT_FROM_CASE wire activity terminates the embargo register's ACTIVE entry, implementations MUST leave the case with no active embargo. The same step cancels every open proposal, so the derived EM becomes EXITED. No separate outbound wire activity is emitted; the participant position is derived from the case.

A register with a TERMINATED entry accepts no further change (ADR-0122), so a terminated embargo can never be invited to again. That is a fact about the case, which every replica holds once it replays the teardown.
Uses definition from: MSM-02-007
MSM-07-025 MUST NOT When an ET terminates the embargo register's ACTIVE entry, implementations MUST NOT write any participant's consent rows. With no active embargo no participant is a signatory and no row binds anyone. An Accept or Reject that arrives afterwards records nothing (EMB-17-004).

The termination is a fact about the case, so it does not need copying onto each participant record as a terminal consent state. Leaving the rows as they were also keeps the history of who agreed to what, and every row of a final entry is frozen (CM-18-003).
Extends: MSM-07-006
See also: EMB-17-004 — context for the reader
EMB-17-004 MUST This rule covers a case with no Active and no Proposed Embargo (EM EXITED or NONE). There, the CASE_MANAGER MUST answer a late Accept of an embargo its register holds with the refusal notice alone (MSM-07-012). A redelivery of the same Accept gets the same result.

Follows the EMB-07-003 precedent for post-terminal messages: no transition. There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested — but the actor's case participation is independent of embargo consent and MUST survive. The sender is still owed word that its answer did not count, which the refusal notice gives (CLP-05-001). An Accept of terms the case never held gets a processing fault instead (MSM-07-039). See ADR-0065.

ECA Details

Preconditions

- EM state is EXITED (embargo terminated) or NONE (no embargo started)
- EM state: EXITED, NONE

Steps

1. [system] Refuse the Accept with the refusal notice, committing nothing and sending nothing else → Participant consent rows are unchanged; participant remains in the case; no ledger entry is committed and only the refusal notice is sent

Postconditions

- No embargo state change; accepting actor remains a case participant

Refines: EMB-17-001
Refines: MSM-07-012
EMB-17-015 MUST NOT The CASE_MANAGER MUST NOT commit any ledger entry for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004).

An entry acknowledging the Accept would change nothing at any receiver. The Accept is refused, and a refusal is never written to the ledger (CLP-04-007).
Part of: EMB-17-004
EMB-17-016 MUST NOT This rule covers a late Accept of an embargo the register holds, in a case with no Active and no Proposed Embargo (EMB-17-004). The CASE_MANAGER MUST NOT send any activity in reply to it but the refusal notice.

There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested. The refusal notice is owed: it tells the sender its answer did not count (MSM-07-012).
Part of: EMB-17-004
EMB-17-017 MUST The CASE_MANAGER MUST leave the participant's consent rows unchanged for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004). Nothing is recorded after a termination (EM EXITED), and a TIMED_OUT row stays TIMED_OUT when no embargo has started (EM NONE) (ADR-0118).

The Accept names an embargo that is no longer, or not yet, in force, so no row can bind to it. The actor's case participation is independent of embargo consent and survives.
Part of: EMB-17-004

After a teardown. The termination's own ledger entry, fanned out as Add(CaseLedgerEntry), records the end. The activity that tells the other participants depends on which actor started the teardown:

  • A received Remove(EmbargoEvent). The Case Owner sends the CASE_MANAGER a Remove(EmbargoEvent) before the embargo's end time. The CASE_MANAGER tears the embargo down and then sends Announce(EmbargoEvent) to every other active participant.
  • A teardown the CASE_MANAGER starts. The CASE_MANAGER ends the embargo itself, by its own decision, at the end time, or in the P/X/A cascade of §11.3 Status Adoption: One Authorization Gate. Its own Remove(EmbargoEvent) is then the notice, and it sends that activity to every other active participant. No Announce(EmbargoEvent) follows it.

When the teardown comes before the embargo's end time, on either path, the CASE_MANAGER also sends a direct Remove(EmbargoEvent) notice to each signatory the ledger fan-out does not reach. A teardown at the end time sends no such notice, because every signatory already knows the end time. No message is sent for consent, because none is written.

Requirements

ID Priority Requirement Related
EP-09-009 MUST NOT The CASE_MANAGER's commit of a received embargo activity, fanned out as Add(CaseLedgerEntry), is the acknowledgement the EMB behavioural requirements express as "emit EK". Implementations MUST NOT define or emit an EK message to acknowledge an embargo activity.

No EK exists in the production stack and MSM-02-009 records that its purpose is served by ledger hash-chain continuity. Under the relay every accepted embargo activity is committed and announced, so the record the specs want the receiver to produce already exists; a second acknowledgement would be a message with no reader (#3918).
Refines: MSM-02-009
EMB-19-001 MUST The actor that holds the CASE_MANAGER role for the case MUST author the activity that tells the other participants of an embargo teardown. That activity is an Announce(EmbargoEvent) after a received Remove(EmbargoEvent), and the CASE_MANAGER's own Remove(EmbargoEvent) for a teardown it starts.

The teardown changes canonical case state, so the actor that holds the CASE_MANAGER role announces it, and the participants are its audience. The tree that commits the teardown runs as the CASE_MANAGER, because the ledger commit is gated on that role. An announcement addressed to the CASE_MANAGER would therefore go to the announcing actor itself, and the teardown would reach nobody.
CM-31-009 MUST This rule covers each signatory that the ledger fan-out does not reach: one removed (CM-31-001), or one at RM CLOSED that the CM-23-004 fan-out skips. When the active embargo is terminated, the CASE_MANAGER MUST send each such signatory a direct Remove(EmbargoEvent). Termination includes the case becoming public.

A participant that stopped receiving case content while bound stays bound, and without this it never learns that the obligation ended early. A past-dated Announce(EmbargoEvent) is not used: its meaning would depend on the receiver's clock, and an early end is an event, not a date that passed.
Uses definition from: CM-31-001
Supersedes: CM-23-004
CM-31-030 MUST When a shorter revision replaces the active embargo, the CASE_MANAGER MUST send each signatory that CM-31-009 covers a direct Announce(EmbargoEvent) with the new terms. No notice is owed for a longer revision, or for expiry on the agreed date.

A participant bound by the embargo must learn that its obligation shortened, and a paused replica cannot learn it from the ledger. A longer revision does not bind a participant that never agreed to it, and expiry on the agreed date is already known to it. A revision that ends at the same time as the embargo it replaces is on the EP-05-003 carry-over arm, so it is sent like a shorter one.
Extends: CM-31-009
Supersedes: CM-23-004
CM-31-031 MUST NOT The CASE_MANAGER MUST NOT put any other case content in a CM-31-009 or CM-31-030 notice.

The notice exists only to tell a bound participant that the embargo ended or shortened. The recipient has stopped receiving case content, so anything more would leak content it is not entitled to.
Extends: CM-31-009
Extends: CM-31-030
EMB-19-004 MUST NOT The CASE_MANAGER MUST NOT address the teardown Announce(EmbargoEvent) (EMB-19-001) to the CASE_MANAGER.

The tree that commits the teardown runs as the CASE_MANAGER, because the ledger commit is gated on that role. An announcement addressed to the CASE_MANAGER would go to the announcing actor itself and loop back for no additional record.
Extends: EMB-19-001
EMB-19-003 MUST The CASE_MANAGER MUST address the teardown Announce(EmbargoEvent) (EMB-19-001) to every active participant (CM-10-004) except itself.

The teardown changes canonical case state, and the participants are the audience of that change.
Extends: EMB-19-001
Uses definition from: CM-10-004

Recall: participant embargo consent states

State Meaning
UNINVITED Not asked about this embargo; the start state of every row
INVITED Asked, with no answer yet; carries that invitation's RSVP deadline
AGREED Agreed to this embargo: explicitly, as its proposer, by seeding, or by carry-over
DECLINED Explicitly refused this embargo, or withdrew from it
TIMED_OUT Invited, and the RSVP deadline passed with no answer; not a refusal

Full definitions are in §9.1 States.

Every one of these changes reaches the case ledger, and every replica applies it by copying. The act's own activity carries its whole register step: a termination's entry also cancels every open proposal, and an activation's entry also supersedes the embargo it replaces. Where the act's activity states a row itself, as the owner's Add states the owner's agreement, the act's entry carries that row.

Each other consent row that the CASE_MANAGER writes as a consequence of the act is its own CASE_MANAGER entry after the act's entry. Examples are an UNINVITED row, the proposer's AGREED row or a CARRY_OVER. That entry is a Create(EmbargoConsent) for a new row or an Update(EmbargoConsent) for a changed one, and it carries the row in full. A replica copies those rows and never decides a carry-over, an expiry or a lapse itself.

Requirements

ID Priority Requirement Related
CLP-07-013 MUST The CASE_MANAGER MUST commit every change it makes to the case file as its own CaseLedgerEntry, never making a change that has no committed entry. The act's entry comes first. When the act's own activity states a change, that entry is the change's entry, and applying it writes only what the activity states. Examples are Add(Note)[target=VulnerabilityCase] carrying the note, and an invitee's Accept of the stub Invite marking its own consent and joining. A decision the CASE_MANAGER takes from local policy or the clock may change the case file. Such a decision is committed as the change it makes, before the change is made. A decision that changes nothing is not committed, such as noticing that a deadline has passed or that a closure is complete (ADR-0152). Moving the case's ledger position (ledgerPosition) to an entry as it is committed (SYNC-16-005) is part of applying that entry. It is not a change to the case file of its own, and takes no entry.

Two replicas at the same ledger position must hold the same case file, and a replica infers nothing. If a change is not in the ledger, it did not happen (ADR-0124). One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times. Full records are ledger content that the hash chain must cover (CLP-07-006).
Extends: CLP-07-002
Uses definition from: SYNC-16-005
CLP-07-021 MUST Each change an act causes, beyond what the act's own activity states, MUST follow the act's entry as its own CASE_MANAGER-authored entry. The entries follow in the order the CASE_MANAGER writes them. Each one's payloadSnapshot carries the object in full (CLP-07-006). A record the change adds to one of the case's lists (its participants, reports, notes, statuses, vulnerability items or case references) is recorded as an Add of the record with the case as its target. Any other record the CASE_MANAGER brings into existence is recorded as a Create, and a changed record as an Update.

One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times, and replicas at one ledger position then differ. Full records are ledger content that the hash chain must cover (CLP-07-006). A record that belongs to a case list needs the case as the entry's target: a Create has none, so a replica would have to decide which list the record joins, which is lifecycle logic a replica must not run (CM-23-044). The one Add both brings the record and lists it.
Extends: CLP-07-013
See also: CLP-07-006 — context for the reader
CM-23-016 MUST A participant's case replica is the case as it stood when the replica was seeded, plus the ledger entries since. A replica MUST apply the entries in ledger order by copying the objects they carry, so replicas at one ledger position hold identical case files.

The CASE_MANAGER is the single writer (ADR-0108), and the ledger records each change when the CASE_MANAGER makes it (CLP-07-013). If each replica copies what the entries carry, in the same order, two replicas at the same position hold the same case file as each other and as the CASE_MANAGER. CM-23-023 gives the rule for closure. This requirement gives it for every replicated change (ADR-0124).
CM-23-044 MUST NOT A replica applying an entry MUST NOT mint an id, read a clock, read local policy or state outside the case, or run lifecycle logic. Walking the RM transition table from its own stored state to a target state is such logic.

A replica can find its own path from its own state, which can be out of date. It can then write an RM state that the ledger never recorded. A replica that builds a record itself gives it an id and a time that differ from those of the CASE_MANAGER. In both cases, the replicas diverge from the CASE_MANAGER (ADR-0124).
Extends: CM-23-016

11.3 Status Adoption: One Authorization Gate

A participant's report does not become canonical case state on arrival. It passes one authorization point, the adoption gate, where the CASE_MANAGER decides whether the claim becomes canonical case state. That one decision also authorizes what the adopted state calls for, such as ending an embargo, so the CASE_MANAGER asks no second approval.

Adoption

A participant reports an observation by sending Add(ParticipantStatus) to the CASE_MANAGER. A participant does not send Add(CaseStatus): writing canonical case status is reserved to the CASE_MANAGER (§10.1 Single-Writer Authority).

The CASE_MANAGER records the claim in the case ledger first, and then decides whether to adopt it as canonical.

Who authorizes adoption. The CASE_MANAGER adopts a Case Owner's report without seeking approval. The Case Owner is the party whose authorization the other reports need, so asking it to approve its own report would be circular. For every other sender, the protocol's default is that the CASE_MANAGER obtains Case Owner authorization before it adopts the report as canonical case state. This default is deliberate: without it, any admitted participant could force a change to canonical case state.

Requirements

ID Priority Requirement Related
RSH-07-006 MUST NOT Before it adopts a P, X or A value that the Case Owner reports, the CASE_MANAGER MUST NOT ask the Case Owner to approve it.

The Case Owner is the authority that RSH-07-001 asks. Asking it to approve its own report would be circular and would hold the case's canonical state on a question with only one possible answer. The report is still judged by the acceptance rules of RSH-09.
RSH-07-001 MUST Before it adopts a P, X or A value that a non-owner participant reports, the CASE_MANAGER MUST by default obtain the Case Owner's authorization. Adoption makes the value canonical case state.

A permissive default lets any admitted participant, a hostile or defective sentinel included, force PXA adoption and start the embargo teardown with no Case Owner confirmation. So the default is conservative, and permissive behavior needs an explicit opt-in (ADR-0076). The authorization also covers the teardown the adopted value calls for (ADR-0210). The rule says what a receiver does with a reported status, so every CASE_MANAGER obeys it. The Case Owner's own report is RSH-07-006.

A deployment where every admitted participant is trusted, and where the cost of Case Owner approval is too high, can configure a permissive policy instead. That configuration is an explicit operator choice, not a default. It is not a way to unblock a path that the gate is correctly blocking.

Not yet in main: asking the Case Owner

The reference implementation does not yet ask the Case Owner to authorize a non-owner's report. The request it would send is an authorization ask (ASK-01-001), which Known Gaps lists as not yet met, tracked by #2885. Meanwhile, the core default records a non-owner's report but does not adopt it, and asks no one. The FastAPI server makes that explicit choice: it is configured with the permissive policy, so it adopts the report without asking. A Case Owner's own report is adopted without asking, as RSH-07-006 says.

What is adopted. The CASE_MANAGER accepts a reported status as sent or refuses all of it, and the refusal names every refused value and why. A valid vfd update is refused with an rm value in the same report that cannot be accepted, and the sender corrects and resends the status.

Requirements

ID Priority Requirement Related
RSH-09-001 MUST A CASE_MANAGER receiving an Add(ParticipantStatus, target=<participant>/statuses) MUST either accept the status whole, recording exactly the status it received, or refuse the whole update.

The case ledger records what each participant asserted, and every replica copies what it records (CLP-07-013, CM-23-016). A status partly accepted is one nobody sent (ADR-0107).
RSH-09-010 MUST NOT The CASE_MANAGER MUST NOT record, commit or replicate a status that differs from the ParticipantStatus it received. Filling a dimension the sender omitted with a value of its own is one such difference.

A status rewritten before it is recorded is one nobody sent: the ledger could then neither show what the sender claimed nor let a replica verify it (ADR-0107). An omitted dimension is absent from the status the sender sent (ADR-0075), so recording it as absent is recording the status as sent.
Refines: RSH-09-001
RSH-09-002 MUST When any acceptance rule refuses a received status, the CASE_MANAGER MUST refuse the whole update. It appends nothing, commits no ledger entry for it and adopts nothing from it.

A status partly accepted would record one nobody sent (RSH-09-001), so a refusal by any one rule refuses the whole status.
Refines: RSH-09-001
RSH-09-011 MUST The CASE_MANAGER's refusal notice for a status refused under RSH-09-002 MUST name every refused dimension and the reason for each.

A sender can correct an update only if it learns everything that is wrong with it in one answer (EH-07-001). Naming one reason at a time would cost a round trip per mistake.
Extends: RSH-09-002

On adoption, the CASE_MANAGER commits the adopted status as its own Add(CaseStatus) case ledger entry, setting every public-state flag the report sets and clearing none. It writes the entry directly, never by sending an Add(CaseStatus) to itself, and a receiver refuses an Add(CaseStatus) from any other sender. Recording the claim executes no side-effect: side-effects follow the canonical write.

Requirements

ID Priority Requirement Related
RSH-01-003 MUST When the CASE_MANAGER adopts the CaseStatus that a sender's ParticipantStatus embeds, it MUST record the post-adoption CaseStatus in the canonical case ledger. It records nothing when the adoption changes neither EM nor PXA (RSH-04-009).

Adoption is the only path that moves the P, X or A state of a participant into the case status (RSH-04-005). Replicas learn the adopted status only from the ledger, so an adoption with no record leaves them stale. A record that copies the PXA of the case again adopts nothing.
See also: RSH-04-009 — context for the reader
RSH-01-005 MUST The post-adoption CaseStatus of RSH-01-003 MUST set each of P, X and A that either the case's current PXA state or the adopted CaseStatus sets. It clears none that the case already sets.

A record that clears a latch that the case set already undoes the report of another participant. P, X and A latch on only, so the union of the two is the only result that loses no report.
Extends: RSH-01-003
RSH-04-004 MUST The CASE_MANAGER MUST make the CaseStatus record of RSH-04-002 and RSH-04-003 by committing a canonical CaseLedgerEntry that carries the new CaseStatus. It then announces the entry with Add(CaseLedgerEntry) for participant replica sync.

Replicas learn of the CASE_MANAGER's own EM or PXA change only from the announced entry, so the record is a committed entry that the CASE_MANAGER announces.
Implements: RSH-04-002
Implements: RSH-04-003
RSH-04-008 MUST NOT The CASE_MANAGER MUST NOT adjudicate its own CaseStatus as a received message. It is the authority for its own outbound state changes.

The CASE_MANAGER's own EM or PXA transition is an authoritative state change, not a received message. A received Add(CaseStatus) is admitted only from the CASE_MANAGER at a participant replica (RSH-04-005, RSH-08-003), so judging its own change as one would apply a rule meant for others.
Extends: RSH-04-004
RSH-04-009 MUST NOT The CASE_MANAGER MUST NOT commit or record a CaseStatus snapshot whose EM and PXA equal those of the case's last committed CaseStatus (CLP-07-013, ADR-0152). It measures the change against the ledger, not against the case's current status, which already carries the register's EM (ADR-0122).

Replicas learn of a change only from the announced entry. An entry that repeats the last committed CaseStatus would hand every replica a duplicate that records no change.
Extends: RSH-04-004
Refines: CLP-07-013
RSH-04-005 MUST A receiver MUST refuse a received Add(CaseStatus) unless the case's CASE_MANAGER sent it to a participant.

RSH-04-001 reserves Add(CaseStatus) for the CASE_MANAGER, which sends it to participants inside a case ledger entry. add_case_status_tree has no StatusAdoptionGate, so admitting it from another sender would adopt that participant's P, X or A report without the Case Owner approval RSH-07-001 requires. A participant embeds the P, X or A it reports in its own Add(ParticipantStatus) instead (RSH-04-007), which the CASE_MANAGER adopts through the gate (RSH-01-003).
Derives from: RSH-04-001
Refines: HP-01-006
RSH-04-012 MUST When a receiver refuses an Add(CaseStatus) under RSH-04-005, it MUST write nothing past intake and send nothing.

A refused status is one the receiver must not act on. A write past intake would change case state on the refused claim, and a reply would answer a sender that had no right to send it.
Extends: RSH-04-005

The default is Case Owner authorization, not automatic adoption

With a permissive default, any admitted participant could force a canonical PXA change, and through it an embargo teardown, with no Case Owner confirmation. That includes a hostile or malfunctioning participant admitted as an external monitor. A conservative default makes that a protocol guarantee rather than a deployment posture.

Side-effects

After the canonical write, the CASE_MANAGER evaluates what the new canonical state requires. When the adopted status sets Public Aware, Exploit Public, or Attacks Observed (§8.2 PXA — Public Aware, Exploit Public, Attacks Observed), the CASE_MANAGER ends an active embargo in the same act.

The check follows the canonical write, never precedes it. What is written is the CaseStatus record that holds the case's shared EM and PXA values. The check reads that written record, so the side-effect always follows from canonical state, not from an unadopted claim.

Requirements

ID Priority Requirement Related
RSH-03-001 MUST The CASE_MANAGER MUST trigger embargo teardown when the canonical CaseStatus carries CS.P (public awareness), CS.X (exploit public), or CS.A (attacks observed).

All three flags signal a breach of the conditions that justify an active embargo. Covering only CS.P (as the prior PublicDisclosureBranchNode did) leaves exploit and attack signals without a teardown trigger.

One authorization covers the teardown

The adoption gate is the only authorization point. The Case Owner's authorization of a non-owner's P, X or A value, or the Case Owner's own report of it, also authorizes the embargo teardown that the value calls for. No second approval is asked, so the case never settles with public awareness, a public exploit or observed attacks beside an active embargo, which the cross-machine invariants of §8.3 Case State as a Compound Tuple forbid. The invariants are judged when each CASE_MANAGER act commits: inside the adopting act, the adopted status is recorded just before the termination. A policy that must delay a teardown decides at adoption, by not adopting yet. If the teardown fails for another reason, the reference implementation records the contradiction as a diagnostic note on the case rather than leaving it silent.

Where the gate model applies

The adoption gate governs any reported status. Its authorization question matters most for the participant-agnostic PXA values, which any participant may report (§13.4.2 Participant-Agnostic CS Transitions (PXA)) — including reports about other participants.


12. Participant Lifecycle Within a Case [N]

A case is not a fixed set of parties. Actors join, take on roles, hand responsibilities to one another, and leave. This section specifies that lifecycle: how an actor acquires a role, how it is brought into a case, how case ownership moves, and how a participant is removed.

12.1 Role Assignment [N]

A role is granted through the case's authority chain. An actor does not acquire a case role by declaring that it holds one. The reason is that the other participants act on role claims. They send a Vendor the report content and treat a Coordinator's routing decisions as authoritative. A self-declared role would let an actor take on authority the Case Owner never granted.

  1. A case begins with a Case Owner — the actor whose disclosure decision the case exists to serve. Case ownership is not delegated, though it can be transferred (§12.3 Case Ownership Transfer).
  2. The Case Owner can offer an additional role to an actor that is already a participant. The offer is an Offer(CaseParticipantRole) addressed to the case's CASE_MANAGER only, never to the receiving actor. The CASE_MANAGER records the offer and forwards it to the receiving actor, which answers the CASE_MANAGER with Accept or Reject. The CASE_MANAGER records the answer and grants the role on an Accept. The Case Owner makes role offers. A CASE_MANAGER whose policy delegates role offers to it can also make one, under the same checks. The Case Owner and CASE_MANAGER roles cannot be offered. Ownership moves by transfer. How the CASE_MANAGER role is handed to another actor is not yet specified.
  3. The CASE_MANAGER records each actor's roles on that actor's CaseParticipant entry in the case.

Requirements

ID Priority Requirement Related
CM-33-001 MUST A Case Owner offering a role MUST address Offer(CaseParticipantRole) to the case's CASE_MANAGER only, never to the target.

A participant sends case-scoped messages only to the CASE_MANAGER (PCR-08-001). An Offer that goes directly to the target bypasses the CASE_MANAGER. The CASE_MANAGER then cannot check the answer against a recorded Offer, and cannot ledger it.
Refines: PCR-08-001
CM-33-007 MUST When the CASE_MANAGER admits a role Offer, it MUST commit a CaseLedgerEntry for that Offer.

The recorded Offer is what the CASE_MANAGER checks the target's answer against (CM-33-005). An Offer it never ledgered could not be answered.
Extends: CM-33-001
CM-33-008 MUST After it commits an admitted role Offer, the CASE_MANAGER MUST forward the Offer to the target, with inReplyTo set to the recorded Offer's id. The forward's actor is the CASE_MANAGER and its attributed_to the Case Owner (CM-24-001, CM-24-002).

The target takes case messages from the CASE_MANAGER only (PCR-03-001), so it learns of the Offer from the forward. The inReplyTo lets the CASE_MANAGER resolve an answer to the forward back to the Offer it recorded (CM-33-005).
Extends: CM-33-001
Refines: CM-24-001
Refines: CM-24-002
CM-33-009 MUST NOT The CASE_MANAGER MUST NOT grant an offered role when it receives the role Offer. It grants the role when it commits the Accept (CM-02-016).

An Offer is a proposal, not the grant. A role granted on the Offer would hold even if the target declined it.
Extends: CM-33-001
See also: CM-02-016 — context for the reader
CM-33-002 MUST The CASE_MANAGER MUST refuse a received Offer(CaseParticipantRole) whose sender is not the case's Case Owner, committing no ledger entry and sending no forward.

A role grant decides who runs part of the case. That is the decision of the Case Owner, as ownership transfer is (CM-02-005).
Refines: HP-01-006
Refines: CM-02-005
CM-33-010 MAY Where its policy delegates role offers to it, a CASE_MANAGER MAY commit a role Offer on its own case and send it to the target. The checks of CM-33-003 apply to that Offer.

A Case Owner can delegate its decisions to the CASE_MANAGER in advance. The Offer is then the CASE_MANAGER's own, so it has no Case Owner's Offer to forward.
Uses definition from: CM-33-003
CM-33-011 MAY An implementation MAY omit the CASE_MANAGER-originated role Offer path of CM-33-010.

The Case Owner path alone lets every case grant roles. Thus a path that starts at the CASE_MANAGER adds convenience, not capability, and an implementation can omit it.
Uses definition from: CM-33-010
CM-33-003 MUST The CASE_MANAGER MUST refuse a role Offer in any of five cases. In two, the Offer carries no readable CVD role, or it offers CASE_OWNER or CASE_MANAGER. In three, its target is not a participant in the case, already holds the offered role, or is the CASE_MANAGER itself.

A grant only adds a role. Thus an accepted CASE_OWNER or CASE_MANAGER offer would give the case two holders of a role that it has exactly one of (CM-21-001, CM-02-001). Ownership moves by ownership transfer (CM-21). The CASE_MANAGER role moves only by delegation (CM-02-014), never by a role Offer, because it carries ledger authority. The CASE_MANAGER takes no other role by Offer. The forward of CM-33-008 would go to itself (BT-17-008), and the answer of CM-33-004 would also go to itself.
Constrains: CM-02-016
CM-33-012 MUST NOT The CASE_MANAGER MUST NOT commit a ledger entry for a role Offer that it refuses under CM-33-003.

The ledger records what the case admitted. An entry for a refused Offer would read as an open Offer that the target could answer.
Extends: CM-33-003
CM-33-013 MUST NOT The CASE_MANAGER MUST NOT forward a role Offer that it refuses under CM-33-003.

A forward invites the target to answer. A forwarded refused Offer would ask the target about a grant the case will never make.
Extends: CM-33-003
CM-33-014 MUST NOT An actor handling a role Offer MUST NOT read a missing CVD role as any default role.

If a missing role were read as a default, the case would grant a role that nobody offered.
Extends: CM-33-003
CM-33-004 MUST An actor named as the target of a role Offer MUST refuse it, sending no answer, when the CASE_MANAGER did not send it.

A replica takes case changes from the CASE_MANAGER only (PCR-03-001). An Offer from any other actor was never recorded by the CASE_MANAGER, so an answer to it could not be ledgered.
Refines: PCR-03-001
Refines: HP-01-006
CM-33-015 MUST The target of a role Offer MUST address its Accept or Reject to the CASE_MANAGER only, never to the Case Owner that made the Offer.

The answer is a case-scoped message (PCR-08-001). An answer that goes only to the Case Owner is never ledgered.
Refines: PCR-08-001
Extends: CM-33-004
CM-33-005 MUST The CASE_MANAGER MUST act on an answer to a role Offer only when its sender is the target of an open Offer it recorded. An Offer is open until the ledger holds an Accept or Reject entry for it (CLP-11-001).

The answer decides if the role is granted. Thus only the actor that received the Offer can give the answer, and only one time. The check uses the Offer that the CASE_MANAGER recorded, never the copy in the answer. CM-11-017 and CM-21-011 do the same check.
Refines: HP-01-006
Refines: CLP-11-001
CM-33-016 MUST The CASE_MANAGER MUST refuse an answer that CM-33-005 does not let it act on, committing no ledger entry and changing no role.

An entry or a role change made for a refused answer would grant, or record as decided, an Offer its target never answered.
Extends: CM-33-005
CM-33-017 MUST The CASE_MANAGER MUST resolve an answer that names its forward to the recorded role Offer through the forward's inReplyTo.

The target answers the forward it received, which the CASE_MANAGER sent, not the Case Owner's Offer. Only the stored forward's inReplyTo links that answer to the recorded Offer.
Extends: CM-33-005
CM-33-018 MUST The CASE_MANAGER MUST report a redelivery of the answer that closed a role Offer as SKIPPED (HP-01-014).

A redelivery is the same answer again, not a new one. Reporting it REFUSED would tell the target its answer was declined after it was admitted.
Extends: CM-33-005
Refines: HP-01-014
CM-33-006 MUST When the CASE_MANAGER admits an answer to a role Offer under CM-33-005, it MUST commit a CaseLedgerEntry for it (accept_case_participant_role or reject_case_participant_role).

A participant's answer to an Offer is a case event (CLP-02-016), so it is ledgered as all other case events are.
Uses definition from: CLP-02-012
Refines: PCR-08-003
Extends: CM-33-005
CM-33-019 MUST When the CASE_MANAGER commits an answer to a role Offer under CM-33-006, it MUST broadcast Add(CaseLedgerEntry) to the case's participants.

Replicas learn of a granted role only when they replay the announced entry (CM-02-016, RSH-08-004). Thus if the answer is not announced, the roles in every replica are out of date.
Extends: CM-33-006
CM-33-021 MUST NOT The CASE_MANAGER MUST NOT change any role when it commits a Reject of a role Offer.

A Reject declines the Offer, so the target's roles stay as they were.
Extends: CM-33-006

Together these rules mean that an actor holds only a role it accepted, from an offer that the Case Owner made, or that a CASE_MANAGER made where its policy delegates role offers to it. The role an Accept grants is the one the recorded offer names, not one the accepting actor's reply names. Otherwise, an actor could widen its own grant on the way back. An invitee's roles are those its stub Invite names, recorded when the CASE_MANAGER sends that Invite (§12.2 Invitation and Acceptance).

An implementation can check that an actor has the capability prerequisites for a role (§13.3.1 Process Roles) before completing the assignment.

Open question: acquiring a role after joining a case

This specification says how the Case Owner offers a role to a participant, and how the participant accepts or declines the offer. It does not say how a participant already in a case asks for an additional one.

A participant admitted as a Vendor that later also needs the Coordinator role has no protocol path to request it. In practice the request is made out of band, or as an Add(Note) on the case, and the Case Owner then issues a role offer. Neither is a specified mechanism.

Open: whether the protocol should define a role-request activity, whether a participant may give up a role it already holds, and how a role that is removed rather than added is represented in the case history.

12.2 Invitation and Acceptance [N]

Bringing a new actor into a case has a problem to solve. The actor cannot decide whether to join until it knows something about the case. However, until it is an active participant it receives no case content. Being in the case's participant list does not make it one (§9.7 Gating Full Case Delivery).

Requirements

ID Priority Requirement Related
CM-10-004 MUST The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).

Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122).
Uses definition from: CM-14-001
Uses definition from: CM-18-001
Uses definition from: CM-31-001
CM-17-005 MUST NOT Presence in the case participant list MUST NOT be treated as acceptance of the invitation or as entitlement to case content. An invitee is in the list from the stub Invite onward (CM-11-006); only an active participant (CM-10-004) is entitled to case content.

The CASE_MANAGER tracks every invitee from the moment it is invited, including one that declines, so the participant list holds inert participants. Any consumer that reads membership as "accepted" would hand case content to an actor that has not consented.
Uses definition from: CM-10-004
See also: CM-11-006 — context for the reader

The protocol solves this with a case stub: the case's preview, which carries enough for the invitee to decide, and no vulnerability detail. The invitation names the case by a typed reference: an object with the case's id, the type VulnerabilityCase, and the stub as its preview. The stub is an object of its own type, CasePreview, and is not the case. A sender's stub carries exactly the required fields and, while an embargo is in force, the embargo fields.

Every stub carries these required fields:

  • id: the stub's own identifier. It names only the stub; the reference that carries the stub names the case.
  • type: CasePreview. A receiver tells a stub from a case by its type alone.
  • summary: required human-readable context saying what the invitee is being asked to join. The sender chooses it. It may be the case name, or a deliberately less revealing string. The case name itself can be sensitive to share with an actor not yet bound by the embargo. A receiver refuses a stub without a summary (MV-10-001).

A stub carries these fields only while an embargo is in force:

  • activeEmbargo and caseStatus: present whenever an embargo is in force, that is, while the embargo state is ACTIVE or REVISE. They state the embargo terms the invitee would agree to by accepting: the embargo in force and the case's embargo state. The sender gives the caseStatus its published time, as every case status has one. A receiver reads the status as sent, with or without that time, because it sits inside the stub (MV-12-006, CLP-15-010). During a revision the stub carries the embargo in force, never the open revision, which the invitee receives after joining. The stub may carry the embargo inline or name it by an identifier the invitee can ask the inviter to resolve. The reference implementation always carries the full embargo inline, because it does not build that lookup.

The sender sets no other field. On receipt, the stub accepts any field the case has, under the case's name, all optional, and reads it as sent (MV-12-006). Any value in the stub, at any depth, may be a Redacted marker: a value the sender has but does not show (MV-12-001). The reference implementation sets none of these on a stub it sends.

Requirements

ID Priority Requirement Related
CM-11-013 MUST The stub Invite's object MUST be a typed reference to the case, naming the case by its own id, whose preview is the case's preview, of its own wire type CasePreview.

A receiver classifies an activity by its shape. ADR-0205 retires the stub's own type, its own id and its caseId: the case is named by the reference's own id, the preview has a type of its own, and nothing stands in for the case. The reference carrying a preview and the whole case of the full-case Invite differ in form, so a receiver tells the two Invites apart as received (SE-01-009).
CM-11-038 MUST A receiver MUST classify a case stub by its type, never by which fields it carries or by parsing its ID.

A sparse case and an enriched stub can carry the same fields, so only the type tells them apart. A classifier that read the fields would take a sparse VulnerabilityCase for a stub (ADR-0114).
Depends on: CM-11-013
CM-17-010 MUST A sender's case preview (CasePreview) MUST carry exactly id, type, a non-empty summary (MV-10-001) and, with an embargo in force, the CM-17-002 embargo terms. The JSON-LD @context is not content.

An invitee is not yet entitled to case content (CM-10-004, CM-17-005). For informed consent, the invitee needs the case's identity, a summary that a person can read of what it is asked to join, and the embargo terms (CM-17-002). The case's identity is the id of the case reference the stub is the preview of (CM-11-013, ADR-0205), so the stub names no case of its own.
Uses definition from: CM-11-013
Refines: MV-10-001
Uses definition from: CM-17-002
CM-17-020 MAY The sender chooses the stub's summary, which MAY be the case name or a deliberately less revealing string.

The case name can be an opsec risk. Thus the sender writes the summary for the invitee, and does not have to copy it from the case.
Uses definition from: CM-17-010
CM-17-021 MUST NOT The sender MUST NOT assume the case name is safe to share with an invitee not yet bound by the embargo.

The case name can reveal what the embargo protects. An invitee that has not joined has not agreed to the embargo, so the sender decides what the stub's summary reveals to it.
Extends: CM-17-020
CM-17-022 MUST NOT A sender MUST NOT put any other case content in a case stub.

An invitee is not yet entitled to case content (CM-10-004, CM-17-005). This constrains what is sent.
Derives from: CM-17-010
CM-17-023 MUST NOT A sender MUST NOT name the case's coordinator or Case Owner in a case stub.

The Invite that carries the stub already identifies the inviter in its actor and attributedTo. If the stub named the coordinator or the Case Owner, it would repeat what the Invite states.
Derives from: CM-17-010
CM-17-002 MUST This rule covers a stub Invite sent while an embargo is in force. Then EM is ACTIVE or REVISE, and the case's embargo register holds an ACTIVE entry. Its case stub MUST carry the active embargo (activeEmbargo), inline or by an ID that the invitee can ask the inviter to resolve.

The invite-accept cycle is the only consent signal for a late joiner. An Accept without the embargo terms is not informed consent (CM-11-001). The invitee has only the invitation, so the invitation must let it learn the terms before it accepts: inline in the stub, or by the ID that the stub names. CM-17-011 says which form this prototype sends. In EM REVISE, the prior embargo stays in force (EP-05-002), so the invitee needs its terms then too.
Extends: CM-17-001
Derives from: CM-11-001
CM-17-013 MUST When an embargo is in force as the CASE_MANAGER sends a stub Invite, the case stub MUST carry the case's EM state (caseStatus.emState).

The EM state tells the invitee whether a revision of the embargo is open. In EM REVISE, the invitee learns from it that a proposal is pending, which it receives after it joins (EP-09-011). The caseStatus is a CaseStatus, so it also carries the published time every status carries (CLP-15-010).
Extends: CM-17-002
CM-17-014 MUST NOT A case stub MUST NOT carry an open embargo revision proposal. The invitee learns of the proposal from caseStatus.emState and receives it after joining (EP-09-011).

The revision is not yet binding, and CM-17-022 keeps other case content out of the stub. When the joiner holds the case, EP-09-011 relays to it each open proposal that it has not answered.
Extends: CM-17-002
See also: EP-09-011 — context for the reader
EP-09-011 MUST When the CASE_MANAGER admits a participant (Accept(Invite(VulnerabilityCase preview)[target=Actor])) while an embargo proposal is open, it MUST relay an Invite(EmbargoEvent) for every open proposal to the joiner and commit each as a ledger entry, after the joiner holds the case and the prior ledger. Each Invite has actor set to the CASE_MANAGER's ID and attributedTo set to the proposal's original proposer (EP-09-002). A proposal whose consent row for the joiner has already left UNINVITED is not relayed again. Every participant holds a row for every register entry (CM-18-001). The row's state, not its presence, says whether the joiner was asked. The joiner's row for the active embargo is unchanged (EP-09-004), so a joiner that accepts the revision is a signatory of it at activation and one that does not lapses (ADR-0093, EP-05-001).

A joiner is seated after the relay of a proposal (EP-09-002), so it was never on the roster when the Invite went out, and nothing else would ask it. A new participant becomes a signatory to the embargo in effect when it joins, and is asked about a revision on the table exactly like the participants who were present when it was proposed.
Uses definition from: EP-09-002
Uses definition from: CM-18-001
See also: EP-05-001 — context for the reader
See also: EP-09-004 — context for the reader
MV-10-001 MUST A stub object, the case's preview (MV-10-012), MUST carry at minimum an id field (full URI), a type field and a non-empty summary field that gives human-readable context.

The stub form has one narrow purpose. It is not a replacement for a full object. An invitee must decide whether to join a case before it can receive the case (MV-10-005). The stub previews the case until the participant is active (CM-10-004): it is the preview of the case reference the stub Invite carries as its object (ADR-0205). The summary tells the invitee which case it is asked to join. The sender decides what the summary says (CM-17-020).
See also: MV-10-012 — the case reference whose preview the stub is

The stub does not name the case's coordinator or Case Owner. The Invite that carries the stub already identifies who is asking: its actor is the CASE_MANAGER, and its attributedTo can name the Case Owner, with inReplyTo naming the Case Owner's request. Full content follows only after the invitee accepts.

Two paths bring an actor into a case, and they differ in who initiates.

Direct invitation. The CASE_MANAGER sends Invite(VulnerabilityCase preview)[target=Actor] to the actor: the object is the case's reference carrying the stub as its preview, and the target is the actor invited. At the same time, it records the invitee in the case as an inert participant at RM Received. The CASE_MANAGER commits the record's creation to the case ledger, and a replica applying that entry creates the same inert record. The record is not yet an active participant: it does not receive case content and is not included in embargo fan-out.

Requirements

ID Priority Requirement Related
CM-11-006 MUST When the CASE_MANAGER sends a stub Invite (Invite(VulnerabilityCase preview)[target=Actor]), it MUST create the invitee's CaseParticipant in the same step. The participant is inert (CM-10-004).

The CASE_MANAGER needs to track every invitee from the moment it is invited — whether it has been told and how it answered — including the invitees that decline (ADR-0114).
Uses definition from: CM-10-004
CM-11-026 MUST The CaseParticipant a stub Invite creates MUST hold the Invite's roles, RM RECEIVED, VF v (VENDOR), and an INVITED row for an active embargo.

The invitee has been told of the case and has decided nothing. RM RECEIVED and VF v record exactly that. The INVITED row records that it was asked about the embargo in force and has not answered (CM-18-001).
Extends: CM-11-006
CM-11-023 MUST When it sends a stub Invite, the CASE_MANAGER MUST commit its own add_case_participant_to_case entry, Add(CaseParticipant) with the case as its target and context (CLP-07-021), separate from the Invite's invite_actor_to_case entry.

The ledger holds the wire messages that the actors exchanged, and every state change has a message. The Invite is one message. Creating the invitee's record is the CASE_MANAGER's own act, so it is a second message with its own entry (ADR-0114, ADR-0124).
Extends: CM-11-006
Refines: CLP-07-021
CM-11-024 MUST The add_case_participant_to_case entry MUST carry the whole participant record as stored: its statuses and consent rows, with their ids and times.

A replica copies the record from the entry and derives nothing (CM-11-025, ADR-0124). The entry must therefore carry every field the CASE_MANAGER holds, or the replica's record differs from the CASE_MANAGER's.
Extends: CM-11-023
CM-11-025 MUST A replica MUST store an invitee's record exactly as the add_case_participant_to_case entry carries it, in the case its target names, and derive none of it from the Invite's entry.

Replicas copy; they never mint ids, read clocks or run lifecycle logic (ADR-0124). A record a replica derived could differ from the CASE_MANAGER's in an id or a time, and the copies of the case would then disagree.
Depends on: CM-11-024

The actor answers Accept(Invite) or Reject(Invite). Accept(Invite) joins the actor to the case at RM Received and, where an embargo is in force, records its consent to those terms, unless it had already declined them. A participant that has now agreed to the embargo in force, or joins a case with none, is active, and the CASE_MANAGER delivers the case (§11.1 Admitting a Participant). A participant that had declined the embargo joins but stays inert until it agrees. Reject(Invite) closes the inert record (RM Received → Closed) and keeps it as history, so the CASE_MANAGER can see that the invitation was extended and declined.

Requirements

ID Priority Requirement Related
CM-11-001 MUST When a participant accepts the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.

The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this.
Uses definition from: CM-10-001
Extends: BT-10-005
CM-11-007 MUST A stub Invite has exactly two valid replies, Accept (CM-11-001) and Reject. On Reject(Invite(VulnerabilityCase preview)[target=Actor]), the CASE_MANAGER MUST close the participant and keep its record, which stays inert. Closing it moves its RM state to RM.CLOSED, sets VF V for a VENDOR, and records consent DECLINED when an embargo is active.

A stub reject is a hard no to joining. Keeping the record keeps the history that the actor was told and declined, which is what the early record exists for.
See also: CM-11-001 — context for the reader
CM-11-027 MUST A replica MUST apply a stub Reject from two entries: the invitee's reject_invite_actor_to_case, which carries the DECLINED row, and the CASE_MANAGER's add_participant_status_to_participant closing status.

The invitee's Reject is a message, so it is its own ledger entry, and it is the entry for the DECLINED row. A replica applies that row through the same write the CASE_MANAGER uses. The closing status is the CASE_MANAGER's own act, with an entry of its own that a replica stores. Each replica then holds the record the CASE_MANAGER holds (ADR-0114, ADR-0124).
Extends: CM-11-007
CM-11-028 MUST The CASE_MANAGER MUST refuse TentativeReject(Invite(VulnerabilityCase preview)[target=Actor]).

Accepting the stub is not a judgement of the case, so there is nothing for a tentative reject to say. Only the full-case Invite asks for a judgement (CM-11-011).
Derives from: CM-11-007

Every stub Invite carries a reply deadline. When it passes unanswered, the Invite closes as expired and the record is left unchanged: still inert, at RM Received, with its embargo consent row still INVITED.

Requirements

ID Priority Requirement Related
CM-11-014 MUST A stub Invite MUST carry a reply deadline.

An invitee that never answers must not hold the CASE_MANAGER in an open wait for ever. The deadline tells both sides when the ask ends (ADR-0114).
CM-11-039 MUST When a stub Invite's deadline passes unanswered, the CASE_MANAGER MUST close the Invite as an expired ask.

An expired ask is over. Closing it ends the CASE_MANAGER's wait for an answer, so the case does not wait on an invitee that never replies (ADR-0114).
Extends: CM-11-014
CM-11-040 MUST NOT When a stub Invite expires unanswered, the CASE_MANAGER MUST NOT change the invitee's record, which stays inert at RM.RECEIVED with its consent row INVITED.

RM is the participant's own judgement (ADR-0121), so a timeout cannot stand in for one. The CM-18-002 time-out to TIMED_OUT applies to an Invite(EmbargoEvent), not to the embargo terms a stub Invite carries, so the consent row stays INVITED.
Extends: CM-11-039
CM-11-041 MUST A case-wide closure check ("all participants closed") MUST count only joined participants: those seated by case initialization (CM-14-001) or that accepted their stub Invite.

An invitee that never answered must not keep the case from closing (ADR-0114). An invitee that has not joined has made no judgement, so it has nothing to close.
Uses definition from: CM-10-004
Uses definition from: CM-14-001

After joining, the participant judges the case by answering the full-case Invite, not the original report Offer.

Requirements

ID Priority Requirement Related
CM-11-011 MUST The CASE_MANAGER MUST record each full-case Invite reply as a move from RM.RECEIVED: RV Accept to RM.VALID, RI TentativeReject to RM.INVALID, RC Reject to RM.CLOSED.

Each reply is the participant's own judgement of the case (ADR-0121). The three replies map to the three RM triage outcomes, so every replica records the judgement the participant made.
CM-11-034 MUST A reply to the full-case Invite MUST carry the replier's own ledger position: the log_index and entry_hash of its tail when it decided.

The position is the reply's ledgerPosition, the property every case activity carries (VAM-04-012..014, SYNC-18-001, ADR-0156), so the CASE_MANAGER judges it against the Invite's floor (CM-11-012) from the one field it reads on every case activity.
Extends: CM-11-011
CM-11-020 MUST NOT A participant that joined a case through an Invite MUST NOT send Accept, TentativeReject or Reject of the original Offer(VulnerabilityReport).

A reply must answer a message sent to the replier. A joined participant was never offered that report.
CM-11-051 MUST NOT A participant that joined a case through an Invite MUST NOT validate, invalidate or reject the case's report. It judges the case by replying to the full-case Invite (CM-11-011).

A joined participant — a late joiner especially — judges the case as it stands, with its history, not the original submission, which may have been far sparser (ADR-0121).
Extends: CM-11-020
See also: CM-11-011 — context for the reader

Suggested actor. An existing participant proposes a third party — "this vendor is also affected" — by sending Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER. The CASE_MANAGER records the suggestion and passes it to the Case Owner as Offer(CaseParticipant)[target=VulnerabilityCase]. The suggestion is a recommendation, not an invitation: the Case Owner decides whether to act on it. If the Case Owner accepts, the CASE_MANAGER then sends the stub Invite above. The CASE_MANAGER takes the actor to invite and its roles from the offer it recorded, never from the Case Owner's reply.

Requirements

ID Priority Requirement Related
CM-16-001 MUST A participant wishing to suggest that another actor be invited to the case MUST send Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER's inbox, not directly to the Case Owner's inbox.

All case-scoped protocol messages MUST route through the CASE_MANAGER so the event can be recorded in the canonical case ledger before any downstream action is taken (ADR-0021, PCR-08-001).
Refines: PCR-08-001
CM-16-004 MUST The CASE_MANAGER MUST transform the received Offer(Actor) into Offer(CaseParticipant)[target=VulnerabilityCase], whose CaseParticipant has attributed_to set to the actor and case_roles set to the roles, and send it to the Case Owner's inbox, with inReplyTo set to the ID of the original recommender's Offer activity and no origin.

The Case Owner makes a membership decision about a CaseParticipant (actor + roles), not about a bare Actor identity. The forward answers the recommender's Offer, and AS2 inReplyTo names the entities an object responds to, so it preserves the causal chain without a side-channel data store. origin names where an object comes from or leaves, so it is not the link to an answered activity.
CM-16-006 MUST After it receives Accept(Offer(CaseParticipant)) from the Case Owner, the CASE_MANAGER MUST take four steps. (1) It commits a ledger entry for the Accept. (2) It fans out the ledger entry. (3) It sends the original recommender an Accept of its Offer(Actor)[target=VulnerabilityCase], with in_reply_to set to that Offer's ID. (4) It sends the suggested actor the stub Invite (Invite(VulnerabilityCase preview)[target=Actor], CM-11-013) per CM-17.

The ledger records the Case Owner's decision before any step acts on it (CLP-10-006). Thus every replica sees the cause before its effects. The recommender waits for an answer to its Offer, and in_reply_to tells it which suggestion the answer closes.
Uses definition from: CM-17-001
See also: CM-11-013 — context for the reader
CM-16-021 MUST When the suggested actor has joined or is at RM.CLOSED, the CASE_MANAGER MUST refuse the Accept(Offer(CaseParticipant)) before committing or sending anything, with a reported reason.

The CASE_MANAGER refuses an Accept for an actor that joined or is at RM.CLOSED. This keeps one participant record for each actor, and keeps RM.CLOSED terminal (CM-11-043). The refusal comes first, so nothing of the Accept is recorded or sent.
Supersedes: CM-16-006
CM-16-018 MUST When the CASE_MANAGER processes Accept(Offer(CaseParticipant)) from the Case Owner, the roles assigned to the new participant MUST be read from the stored outgoing Offer(CaseParticipant) that the CASE_MANAGER constructed and sent — not from the embedded CaseParticipant object inside the received Accept.

The received Accept is untrusted: the accepting actor may have modified or omitted roles, or sent only a bare ID reference. Reading roles from the received Accept would allow a malicious or minimally-conformant acceptor to substitute unauthorized roles. The stored Offer is the CASE_MANAGER's own record of the intended participant roles and is the authoritative source of truth.
Constrains: CM-16-006
CM-16-019 MUST The CASE_MANAGER MUST refuse Accept(Offer(CaseParticipant)) or Reject(Offer(CaseParticipant)) from any sender but the case's Case Owner, and then invite no one and notify no recommender.

The Case Owner decides about a recommendation (CM-16-006). If any sender could answer it, any actor that knows a recommendation id could accept it, and the CASE_MANAGER would invite whoever that actor chose (HP-01-006).
Refines: HP-01-006
Constrains: CM-16-006
CM-16-023 MUST The CASE_MANAGER MUST take the actor to invite from the Offer(CaseParticipant) it recorded, never from the Case Owner's reply.

The reply carries a copy of the Offer, and the copy is the sender's claim. Assume that the CASE_MANAGER checked only that the recommendation is recorded, and read the invitee from the reply. Then the reply could choose the invitee. The recorded Offer is the CASE_MANAGER's own record (CM-16-018).
Extends: CM-16-019

Both paths converge on Accept(Invite). The suggested-actor path adds one round-trip, because the Case Owner's decision sits between the proposal and the invitation.

Recall: report management states

State Meaning
Start No report has been received
Received A report has arrived; triage is not yet complete
Invalid This participant assessed the report as invalid
Valid This participant assessed the report as valid
Deferred This participant is deferring further action
Accepted This participant accepted the report for active work
Closed This participant closed the report

Full definitions are in §6.1 States.

12.3 Case Ownership Transfer [N]

The Case Owner can transfer ownership to another participant through an Offer(VulnerabilityCase) / Accept handshake routed through the CASE_MANAGER. The Case Owner proposes the transfer to the CASE_MANAGER as Offer(Offer(VulnerabilityCase)), and the CASE_MANAGER makes the one Offer(VulnerabilityCase) the receiving actor answers. The receiving actor is one already entitled to the case's content and holding the case, which the Offer names by reference: an active participant. An owner that means to transfer a case to any other actor invites that actor first.

Requirements

ID Priority Requirement Related
CM-21-005 MUST A Case Owner MUST propose an ownership transfer by sending Offer(Offer(VulnerabilityCase)), with the case as context, to the CASE_MANAGER only, never to the transferee (PCR-08-001).

Routing the transfer through the CASE_MANAGER lets it ledger the offer in flight and broadcast it to every active participant (CM-10-004), so no participant is unaware a transfer is being negotiated. The CASE_MANAGER cannot be the transferee: its Offer would have itself as its only recipient, which BT-17-008 forbids, the same ground on which CM-33-003 refuses a role offer to it.
Refines: PCR-08-001
CM-21-025 MUST The inner Offer of an ownership-transfer proposal MUST name the case as its object and the transferee as its target. It optionally carries the deadline to answer as its end_time (CM-21-016).

The inner Offer says what the owner asks the CASE_MANAGER to offer and to whom. Without the case and the transferee in it, the CASE_MANAGER cannot make the Offer the owner asked for (CM-21-028).
Extends: CM-21-005
Uses definition from: CM-21-016
CM-21-026 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal, with no ledger commit and no outbound Offer, unless its inner Offer passes two checks. The inner Offer's object is the proposal's case. Its target is an actor the CASE_MANAGER can address (present, neither itself nor the proposer) and an active participant of the case (CM-21-021).

A proposal is a request the CASE_MANAGER acts on. An inner Offer that names another case, or a transferee the CASE_MANAGER cannot address, would make an Offer nobody can answer, or one about a case the proposal did not concern.
Extends: CM-21-005
Uses definition from: CM-21-021
CM-21-027 MUST When it admits an ownership-transfer proposal, the CASE_MANAGER MUST ignore any id, actor or to inside the inner Offer.

The CASE_MANAGER makes the Offer itself (CM-21-028). An id, actor or recipient list that the owner wrote into the inner Offer would let the owner choose fields that only the CASE_MANAGER sets, such as an id that collides with a stored object.
Extends: CM-21-005
CM-21-028 MUST On admitting a proposal, the CASE_MANAGER MUST make the single ownership-transfer Offer(VulnerabilityCase) itself, under an id it derives from the proposal, addressed to the transferee. The Offer's actor is the CASE_MANAGER, its attributed_to the owner and its in_reply_to the proposal (CM-24-001, CM-24-002, CM-24-020).

Making the Offer itself rather than forwarding the owner's gives a transfer one Offer, under an id no other party chose, told apart from the proposal by its shape (ADR-0148, DL-06-006).
Extends: CM-21-005
Refines: CM-24-001
Refines: CM-24-002
Refines: CM-24-020
CM-21-029 MUST The CASE_MANAGER MUST ledger the Offer it made from a proposal once that Offer is in its outbox (SYNC-09-002). That Offer is the one that is ledgered, answered, closed and expired.

Ledgering the Offer after it is queued keeps the ledger from recording an Offer that was never sent. One ledgered Offer gives every reader one transfer to answer, close or expire (CM-21-014).
Extends: CM-21-028
Refines: SYNC-09-002
CM-21-021 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal (CM-21-005) whose transferee may not act on the case, with no ledger commit and no Offer made. A transferee may act when it is an active participant (CM-10-004) whose closure the case's ledger does not record (CM-23-018). An owner that means to transfer a case to an actor not active in it invites that actor first.

The new owner administers the case, its active embargo included, so it must first have agreed to that embargo and be entitled to the case content, as joining requires. An active participant holds the case, which is also what lets the Offer name the case by reference rather than carry it (ADR-0165). CASE_OWNER is held on a participant record (CM-21-002), so only a transferee with one can end the transfer as the single owner CM-21-001 requires. A closed participant stays active by CM-10-004, but it receives no further case content (CM-23-004) and may not act on the case (CM-23-018), so it cannot take the case on. The test is the one every sender guard and case-content selection uses, may_act_on_case in vultron/core/participants/recipients/sender_standing.py.
Extends: CM-21-005
Uses definition from: CM-10-004
Uses definition from: CM-23-018
CM-21-022 MUST The CASE_MANAGER MUST refuse, with ownership unchanged, the transferee's Accept(Offer(VulnerabilityCase)) (CM-21-011) when the transferee may no longer act on the case (CM-21-021) as the Accept is processed. Ownership unchanged means the case's attributed_to and every participant's CASE_OWNER role stay as they were.

The proposal check (CM-21-021) runs when the Offer is made. A participant can be removed, lapse by an embargo revision, or close between the Offer and its answer, so the Accept is checked again with the same test, may_act_on_case. A closed transferee's Accept is also refused by its sender check (CM-23-018).
Extends: CM-21-011
Uses definition from: CM-21-021

On acceptance, the receiving actor acquires Case Owner authority and the associated protocol responsibilities. The previous owner loses the Case Owner role, and keeps its other roles and its place in the case.

Requirements

ID Priority Requirement Related
CM-21-011 MUST The CASE_MANAGER MUST refuse an Accept(Offer(VulnerabilityCase)), leaving the owner unchanged, unless its sender is the transferee of an unanswered Offer it recorded for the case. The owner is the case's attributed_to and every participant's CASE_OWNER role.

Without the match to a recorded, unanswered Offer, a receiver takes the sender of the Accept to be the new owner. Then any actor that knows a case id can claim ownership at every receiver that holds the case.
Refines: HP-01-006
Supersedes: CM-21-002
CM-21-031 MUST A participant replica MUST apply an ownership change only when it comes from the CASE_MANAGER (PCR-03-001).

A replica that takes the change only from the CASE_MANAGER keeps one authority for the owner of the case (PCR-03-001). A transferee's Accept sent to a replica would otherwise move ownership there without the CASE_MANAGER.
Refines: PCR-03-001
CM-21-002 MUST When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST add CASE_OWNER to the accepting actor's case_roles.

Role-gated nodes such as CheckIsCaseOwnerNode read Case Owner authority from CaseParticipant.case_roles. A transfer that did not grant the role would leave a new owner whose CASE_OWNER-gated acts are refused, such as embargo teardown and case closure.
CM-21-024 MUST When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST update the case's attributed_to to the accepting actor's ID.

attributed_to is the owner that the case names to every reader (MSM-07-027). A transfer that grants the role (CM-21-002) but leaves attributed_to alone makes the case name an owner that no longer holds the role. Thus a transfer writes both.
Extends: CM-21-002
CM-21-003 MUST When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST remove CASE_OWNER from the previous owner's case_roles.

Transferring ownership does not evict the previous owner from the case; they continue to participate but no longer hold administrative authority. Stripping only CASE_OWNER (and not other roles) preserves their standing as a Coordinator, Vendor, or other role while satisfying the at-most-one invariant (CM-21-001).
Implements: CM-21-001
CM-21-008 MUST When an ownership transfer is processed, the previous owner MUST retain any other roles they held (e.g., COORDINATOR, VENDOR) in their case_roles.

Stripping only CASE_OWNER (and not other roles) preserves the previous owner's standing as a Coordinator, Vendor, or other role while satisfying the at-most-one CASE_OWNER invariant (CM-21-001).
Extends: CM-21-003
CM-21-009 MUST When an ownership transfer is processed, the previous owner MUST remain a participant in the case.

Ownership transfer is not case departure. The previous owner has institutional knowledge of the case and continues to participate; only their administrative authority is transferred.
Extends: CM-21-003

Open: cryptographic identity across a change of CASE_MANAGER

Authority over the canonical ledger follows the CASE_MANAGER role, not any actor's name or Uniform Resource Identifier (URI). Transferring case ownership, or moving the CASE_MANAGER role to a different actor, therefore does not by itself re-key the ledger.

What remains open is key handover. A future case-encryption design needs to define how the keys protecting existing case content pass to the new role holder. It also needs to define what a participant does with ledger entries it can no longer decrypt. This specification states no rule for either.

12.4 Participant Removal [N]

Removing a participant withdraws its entitlement to case content. It does not delete the participant from the case. The participant's record, its status history, and the ledger entries it authored stay in the case, and the record carries a removal fact. A removed participant is inert: it receives no case content, and it has no authority to act on the case.

Requirements

ID Priority Requirement Related
CM-31-001 MUST An actor that applies a participant's removal MUST record a removal fact on the participant's CaseParticipant.

Removal is a decision about entitlement to case content, not about membership. Thus it is a fact on the record that the active check reads (ADR-0116).
CM-31-015 MUST NOT An actor that applies a participant's removal MUST NOT delete the participant's record from case_participants.

If the record is deleted, the case loses the history of who took part. Ledger entries then name an actor that is not on the roster (ADR-0116).
Extends: CM-31-001
CM-31-016 MUST An actor that applies a participant's removal MUST keep the participant's status history and the ledger entries it authored.

The status history and the authored entries are the record of what the participant did in the case. Removal withdraws entitlement from now on; it does not rewrite the past (ADR-0116).
Extends: CM-31-001
CM-31-017 MUST Every actor MUST treat a removed participant as inert (CM-10-004).

A removed participant has lost its entitlement to case content. If any actor still treated it as active, it would keep receiving embargoed content.
Extends: CM-31-001
Uses definition from: CM-10-004

Only the Case Owner requests a removal. It sends Remove(CaseParticipant)[target=VulnerabilityCase] to the CASE_MANAGER, which applies it. The CASE_MANAGER refuses the request in each of these cases:

  • the sender does not hold the Case Owner role;
  • the request names the CASE_MANAGER's or the Case Owner's participant;
  • the request names no participant of the case.

A second removal of an already-removed participant is a no-op, and the CASE_MANAGER reports it as skipped. The CASE_MANAGER never removes a participant on its own initiative. A participant that wants to stop taking part leaves the case with Leave(VulnerabilityCase); that is not removal.

Requirements

ID Priority Requirement Related
CM-31-004 MUST Remove(CaseParticipant)[target=VulnerabilityCase] is the Case Owner's request to the CASE_MANAGER to remove a participant from active participation. The CASE_MANAGER MUST refuse such a request in three cases. The sender does not hold CASE_OWNER, the named participant holds CASE_MANAGER or CASE_OWNER, or the request names no participant of the case.

The Case Owner decides who takes part in the case; the CASE_MANAGER applies case changes and decides none (ADR-0108). The CASE_MANAGER role is never unfilled (CM-02-014), and the Case Owner leaves only by transferring ownership (CM-21). A participant that wants to stop taking part sends Leave(VulnerabilityCase) (CM-23), not Remove.
CM-31-022 MUST The CASE_MANAGER MUST report a removal of an already-removed participant as skipped.

A repeated removal changes nothing, so it is neither applied nor refused. A skipped result tells the Case Owner that the participant is already removed, and the CASE_MANAGER commits no second entry and sends no second notice.
Extends: CM-31-004
CM-31-023 MUST NOT The CASE_MANAGER MUST NOT remove a participant on its own initiative.

The Case Owner decides who takes part in the case; the CASE_MANAGER applies case changes and decides none (ADR-0108).
Extends: CM-31-004

An accepted removal is one ledger entry: the Case Owner's received Remove(CaseParticipant), committed by the CASE_MANAGER as received. The CASE_MANAGER commits no second entry of its own for the same removal. After the commit, the CASE_MANAGER sends the removed participant a direct Remove(CaseParticipant) that names it. The notice has actor set to the CASE_MANAGER, attributedTo set to the Case Owner and inReplyTo set to the Case Owner's Remove. This notice is delivery, not a record, and is not ledgered.

Requirements

ID Priority Requirement Related
CM-31-005 MUST The CASE_MANAGER MUST record an accepted removal by committing the Case Owner's received Remove(CaseParticipant) as its entry, on receipt (CLP-10-006).

The Remove states the change, so it is the change's entry (CLP-07-013), authored by the actor that made it. The ledger therefore shows the removal as the Case Owner's decision rather than the CASE_MANAGER acting alone (ADR-0108).
See also: CLP-10-006 — a pointer for "on receipt"; committing the received Remove does not need the receive-tree commit ordering
CM-31-024 MUST Remove(CaseParticipant) MUST be a ledgered activity, with a canonical ledger signature.

Without the canonical signature a removal cannot be committed, so it never reaches a replica.
Extends: CM-31-005
CM-31-025 MUST NOT The CASE_MANAGER MUST NOT commit a second entry of its own for a removal that it records under CM-31-005.

The Case Owner's Remove is already the change's entry. A second entry would record the same move twice and show it as the CASE_MANAGER's own act.
Extends: CM-31-005
CM-31-006 MUST After a removal commits, the CASE_MANAGER MUST send the removed participant a direct Remove(CaseParticipant) naming it. The notice's actor is the CASE_MANAGER, its attributedTo the Case Owner and its inReplyTo the Case Owner's request (CM-24).

Learning of removal only from silence is indistinguishable from a network fault, and the removed party needs to know it is still bound and how it will hear of the embargo's end.
Extends: CM-31-005
CM-31-026 MUST NOT The CASE_MANAGER MUST NOT ledger its CM-31-006 removal notice.

The notice is delivery, not a second record of the move. The Case Owner's Remove is already the move's entry (CM-31-005).
Extends: CM-31-006
CM-31-027 MUST The CASE_MANAGER MUST include the removed participant in the removal entry's fan-out.

The ledger entry keeps the removed party's replica continuous up to the removal, so that replica records its own removal like every other replica.
Extends: CM-31-005
CM-31-028 MUST The removal entry MUST be the last canonical entry that the CASE_MANAGER sends the removed participant, by fan-out or by replay, until it is reinstated.

A removed participant has lost its entitlement to case content. An entry sent after the removal would leak case content to it.
Extends: CM-31-005

The removal entry's fan-out selects its recipients before the removal is applied, so the removed participant receives that entry too. It is the last ledger entry the removed participant receives, by fan-out or by replay, until it is reinstated. Every replica, the removed participant's own included, applies the removal from that ledger entry. A replica never applies a removal from a directly received Remove(CaseParticipant): it stores the notice and takes the removal from the ledger.

Requirements

ID Priority Requirement Related
CM-31-007 MUST A replica MUST apply a removal from its ledger entry, recording the same removal fact the CASE_MANAGER recorded.

Replicas take case state from the ledger. The entry is what changes every replica, the removed party's included.
CM-31-029 MUST NOT A replica MUST NOT apply a removal from a directly received Remove(CaseParticipant) (RSH-08-003).

The direct notice tells the removed party what happened; it is not the change. A replica that applied it would take case state from outside the ledger.
Extends: CM-31-007
Refines: RSH-08-003

Removal does not change the participant's embargo consent. A removed signatory stays bound by the embargo it accepted. A removed participant receives no Invite of any kind: not a stub Invite, not a full-case Invite, and not an embargo Invite.

Requirements

ID Priority Requirement Related
CM-31-008 MUST Removal MUST NOT change the participant's embargo consent rows. A removed signatory remains bound by the embargo it accepted.

Releasing a removed participant from the embargo would reward the conduct that got it removed. Consent is the participant's own statement (CM-18-005); removal is a separate fact.
Extends: CM-31-001
CM-31-013 MUST NOT The CASE_MANAGER MUST NOT send a removed participant a stub Invite, a full-case Invite or an embargo Invite. The CM-31-009 and CM-31-030 notices are its only exception.

Invites reach inert participants because they ask them to join or consent (CM-10-007). A removed participant was taken out by the Case Owner's decision; inviting it to vote on embargo revisions would undo that decision.
See also: CM-31-009 — context for the reader
See also: CM-31-030 — context for the reader
CM-31-040 MUST When the Case Owner reinstates a participant that has not accepted the case's active embargo, the CASE_MANAGER MUST send it that embargo's Invite.

A reinstated participant that is not a signatory stays inert until it consents, so it must be asked.
Extends: CM-31-011

Removal is reversible. The Case Owner reinstates a removed participant by sending Add(CaseParticipant)[target=VulnerabilityCase] to the CASE_MANAGER. The request follows the removal pipeline:

  • only the Case Owner may send it;
  • the received Add is the one ledger entry;
  • the CASE_MANAGER sends the participant a direct Add(CaseParticipant) notice that names it;
  • every replica applies the reinstatement from the ledger entry.

Reinstatement clears the removal fact. The participant does not accept again, because it never withdrew.

The CASE_MANAGER refuses an Add that names a participant that is not removed or that never joined the case. Add does not seat a new member, and an actor joins only by accepting its stub Invite.

Requirements

ID Priority Requirement Related
CM-31-011 MUST The Case Owner MUST reinstate a removed participant by sending Add(<Actor>, target=VulnerabilityCase) to the CASE_MANAGER only. The Add names the participant's actor as a typed reference, not its CaseParticipant.

Owners make mistakes and disputes resolve, so removal is reversible. The reinstatement is the Case Owner's decision, so it sends the act itself, and the CASE_MANAGER admits or refuses it (ADR-0199). The case holds one record per actor, so the actor names the record, and reinstatement reuses it (CM-31-034).
Uses definition from: CM-31-004
CM-31-034 MUST A reinstatement MUST clear the participant's removal fact.

The removal fact is what makes the participant inert (CM-31-017). Clearing it lets the active check count the participant again.
Extends: CM-31-011
CM-31-035 MUST NOT A reinstatement MUST NOT require the participant to accept again.

The participant never withdrew, so it does not rejoin; Leave remains open to it. A participant reinstated into a case whose embargo it has not accepted stays inert, and its CM-10-006 backfill waits for its consent.
Extends: CM-31-011
CM-31-036 MUST The CASE_MANAGER MUST refuse a CM-31-011 reinstatement naming an actor whose participant is not removed or never joined, or that is not in the case. It sends the Case Owner a refusal notice and commits nothing.

Joining requires accepting a stub Invite (ADR-0114), and a reinstatement must not become a way around that. An actor whose participant is not removed has nothing to reinstate.
Extends: CM-31-011

For the same reason, the CASE_MANAGER does not send Add(CaseParticipant) when an invitee accepts its stub Invite. The ledger holds the messages exchanged: the Invite, the CASE_MANAGER's creation of the inert record, then the invitee's Accept. That Accept is the entry for the invitee's consent and joined mark. Every replica applies what the entries carry.

Requirements

ID Priority Requirement Related
CM-31-012 MUST NOT The CASE_MANAGER MUST NOT emit Add(CaseParticipant), or commit an add_case_participant_to_case ledger entry, when an invitee accepts the stub Invite. The invitee's Accept (accept_invite_actor_to_case) is already the ledger entry for the consent row it signs and the joined mark.

The invitee's record was added to the case when the stub Invite went out (CM-11-023), so the Accept adds no record. CM-17-004 does not call for a second entry, and the Accept message is already the entry for its effects. A second Add would record one move twice.
Constrains: CM-17-004
CM-31-037 MUST A replica MUST apply the stub-Invite Accept entry's consent-row and joined writes as the CASE_MANAGER does, setting updated to the Accept's published as received.

The Accept is the one entry for both writes (CM-31-012), so a replica that applied them differently would hold a participant record that differs from the CASE_MANAGER's. Taking updated from the Accept as received keeps the record equal on every replica (ADR-0103, ADR-0124).
Uses definition from: CM-31-012
CM-31-038 MUST NOT A replica seeded with the case MUST NOT move a record it holds backwards when it replays an older entry over the seed (ADR-0124). Moving backwards means clearing joined, or changing a consent row by a move that CM-18-003 does not allow.

A replica seeded with the case already holds a later state than an older entry describes. Replaying that entry must not undo what the seed holds, or the replica would fall behind the CASE_MANAGER.
Uses definition from: CM-18-003
CM-31-039 MUST When a replica holds no record for the invitee, its apply of the stub-Invite Accept entry MUST fail.

The Accept entry changes an existing record; it does not create one. A replica that created a record from the Accept would hold a participant the CASE_MANAGER never seated.
Extends: CM-31-037
CM-31-041 MUST This rule covers a VENDOR-only invitee that accepts the stub Invite. The CASE_MANAGER MUST commit its VF Vf status entry (CM-11-009) after it announces the case to the invitee and backfills the prior ledger (#2898).

The Accept is not the entry for the VF move, so the CASE_MANAGER records it as its own add_participant_status_to_participant entry. Committing it after the announce and the backfill lets the invitee's replica apply it on top of the case it already holds.
Extends: CM-17-004
Refines: CM-11-009

When the reinstated participant is active again, the CASE_MANAGER sends it every ledger entry committed after its removal entry, in log order. Its copy of the ledger then joins the chain with no gap. A participant reinstated into a case whose active embargo it has not accepted stays inert. The CASE_MANAGER sends it that embargo's Invite, and its catch-up waits until it accepts.

Requirements

ID Priority Requirement Related
CM-10-006 MUST When the CM-10-004 content gate admits a participant whose ledger stream it had paused (CM-10-005) — whenever the active check turns from false to true for that participant, whether because it accepts the active embargo, the embargo ends, or it is reinstated (CM-31-011) — the CASE_MANAGER MUST send that participant every canonical entry it was not sent, in log order starting with the first entry withheld from it, before or together with the entry that records the change admitting it.

A paused participant's replica is a contiguous prefix of the ledger; backfilling the withheld suffix in order restores it to the leader's tip without a gap the catch-up gate (SYNC-10-004) would block on. Ending the embargo lifts the gate for everyone, so a participant that never accepted it is caught up at that point too. The trigger is the active check itself, not any one message (ADR-0116).
Extends: CM-10-005
Uses definition from: CM-10-004
See also: CM-31-011 — context for the reader

13. Conformance [N]

13.1 Conformance Model Overview

Conformance is two-dimensional: capability sets (what protocol machinery an implementation provides) and a role profile (which roles it claims). A conformance claim names capability sets and roles directly:

CapabilitySet [+ CapabilitySet ...] / Role [+ Role ...]

Examples: Case Observer / Reporter, Case Observer / Vendor, Case Observer / Vendor + Deployer, Case Observer + Case Decision + Case Hosting / Coordinator + Case Owner.

Every claim includes the Case Observer capability set, because every case participant provides it (§13.2 Capability Sets). Role obligations are additive and orthogonal: no role subsumes another.

Capability set names and role names come from §13.2 Capability Sets and §13.3 Role Taxonomy respectively.

Roles and capability expectations. The relationship between roles and capabilities goes both ways. A role assumes the capabilities that its obligations need (§13.3.1 Process Roles). Conversely, holding a role in a case creates an expectation that the implementation has those capabilities, and other participants act on that assumption. §12.1 Role Assignment gives the rules for granting a role.

Capability sets are not the same as conformance test layers

This project uses two distinct schemes, and they answer different questions:

  • Capability sets, defined here, describe what an implementation provides — a claim an implementer makes about their software.
  • Conformance test layers (L1–L4), used in the behavioral conformance material, describe what a test verifies — syntax, semantics, behavior, and internal process structure.

These are orthogonal: a Case Observer implementation is tested at layers L1 through L3. A conformance claim names capability sets; a test result names a layer. The two are not interchangeable.

13.2 Capability Sets

A capability set is a named group of the obligations that an implementation takes on. Where an obligation is a protocol requirement, this section renders it as a callout; the others link the section that describes them. Three are defined. Case Observer is the set that every participant provides. Case Decision and Case Hosting add the requirements of deciding for a case and of running one. The Case prefix marks each as a capability set — a property of software — distinct from the similarly-named roles it serves.

Most of what a capability set requires is expressed as maintaining a state machine, so that phrase needs pinning down first.

What 'implement a state machine' means

Implementing a state machine has two components:

  1. Track: maintain a local value for the machine, and update it as incoming messages report transitions.
  2. Drive: cause a transition that the participant's roles authorize, and announce it so the other participants learn of it.

The two are separate obligations. A participant that tracks but does not drive leaves the others to discover its state changes some other way. A participant that drives but does not track acts on case state it does not know. Which transitions a participant can drive depends on its roles (§13.4 Role-Specific Normative Requirements); every participant tracks.

Four dimensions, five state machines

Case State (CS) is a compound of two independent axes, so the protocol realizes four tracked dimensions as five state machines:

This specification says "four dimensions" when describing what is tracked and "five state machines" when describing what the protocol defines. Both counts are correct; they count different things.

The Vultron implementation splits VFD into two machines, so it has six. A vendor path, CS_vf (vf, Vf, VF), holds Vendor Aware and Fix Ready. A deployer path, CS_d (d, D), holds Fix Deployed. The two paths combine into six pairs. The VFD order of §8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed rules out the two pairs with a deployed fix that was never ready, which leaves the same four VFD states (vfd, Vfd, VFd, VFD) and the same 32 compound CS states.

Case Observer capability set

The Case Observer capability set is the participation floor. Every actor that participates in a Vultron case provides it, because the Observer role is the base role and every other role adds to it.

Requirements

ID Priority Requirement Related
CM-25-001 MUST An Observer (OBSERVER) is a Tier-1 case participant: it MUST hold a CaseParticipant record, run the standard RM lifecycle, and satisfy the same embargo-consent gate (MV-10-005) as any other participant. OBSERVER is the base role — the lowest non-null privilege set in the Vultron protocol. All other CVD roles are additive to it.

Defining Observer as a full participant (not a passive consumer or an external T0 actor) ensures it is subject to the same admission and embargo-consent rules as Vendors and Coordinators. The "base role" framing establishes OBSERVER as the correct fallback when no other role applies, rather than leaving CVDRole.OTHER as an unspecified catch-all. See ADR-0057.
Uses definition from: MV-10-005

There is no sub-Observer participation level. An actor that accepts a case invitation has committed to Observer behavior from that point: it tracks state and reports its own transitions.

A Case Observer implementation maintains all five protocol state machines — RM, EM, PEC, VFD, PXA — for itself. It holds a current value for each, and it drives the transitions that its roles authorize.

Requirements

ID Priority Requirement Related
CM-03-001 MUST The system MUST implement the three interacting state machines: RM (Report Management), EM (Embargo Management), and CS (Case State)

Report handling, embargo negotiation, and the public and fix state of a case change for different reasons and at different times. Three interacting machines let an implementation validate each one on its own. The interactions between them stay explicit and do not hide in one combined state.
CM-03-002 MUST RM state MUST be participant-specific

Each participant moves through report handling on its own. One participant can accept a report that another has not yet validated. A single shared RM state cannot show this, and one participant's transition would overwrite the state of another (CM-01-002).
CM-03-005 MUST VFD (Vendor Fix Deployment) state MUST be participant-specific

Fix readiness and deployment are different for each participant. One vendor can ship a fix before another vendor, and a deployer has its own deployment state. A shared VFD state would let the progress of one participant show as the progress of another (ADR-0075).
CM-10-001 MUST CaseParticipant MUST record its consent per embargo: one consent row for every entry in the case's embargo register, naming the embargo and the participant's answer to it, UNINVITED until it is asked (CM-18-001). A participant agrees to an embargo explicitly, by an Accept, as its proposer, by seeding (CM-14-003, CM-14-005), or by containment, when the Case Owner activates a revision that ends no later than terms the participant had agreed to (EP-05-001). Each invitation's RSVP deadline is stored on that invitation's INVITED row (CM-28-013). No other record of embargo consent may exist on the participant.

Consent is per embargo (ADR-0093, ADR-0122), so a revision does not inherit an agreement given to an earlier version (CM-18-001). The CM-10-004 content gate reads the rows, so they must name every embargo that binds the participant, including one that containment carries over: an agreement to N days is an agreement to every shorter period, so no explicit Accept is needed for it. A second record of consent beside the rows can disagree with them, and a reader cannot know which is correct.
Uses definition from: CM-18-001
See also: CM-14-003 — context for the reader
See also: CM-14-005 — context for the reader
See also: CM-28-013 — context for the reader
See also: EP-05-001 — context for the reader

It also tracks the states of the other participants in the case, to inform its own decisions. That is a recommendation rather than a requirement, because the protocol does not depend on any participant holding perfect information about the others.

Requirements

ID Priority Requirement Related
VP-01-001 SHOULD Participants SHOULD track the state of other Participants in a case to inform their own decision making

A participant's next move depends on where the others stand: whether a vendor has a fix, whether anyone has published, whether a coordinator has left. Without tracking their states a participant acts on a stale picture and may, for example, publish before a vendor is ready.
VP-01-002 SHOULD Participants SHOULD track the RM states of the other Participants in the case

RM state says whether each participant is still engaged with the report. Knowing it tells a participant who will still act on the case, whose replies to expect, and when a vendor has stopped work.
VP-01-003 MUST NOT Correct operation of the protocol MUST NOT depend on perfect information across all Participants

Participants in a distributed CVD case never all see the same state at the same moment: messages are delayed, lost, or withheld by embargo scope. A protocol that needed perfect shared information would stall or misbehave in every real case, so each step must be safe on the partial view a participant actually holds.

When its own state changes, the protocol recommends that it send the message for the transition. When it is told of another participant's transition, it updates its local state.

Requirements

ID Priority Requirement Related
VP-03-012 SHOULD Participants whose state changes in the RM, EM, or CVD Case State Models SHOULD send a message for each transition to the case's CASE_MANAGER, which fans it out to the other Participants (PCR-08-001, VP-18-002).

Each participant decides from its picture of the others' states (VP-01-001). Announcing every RM, EM and CS transition keeps those pictures current; an unannounced transition, such as a fix becoming ready, leaves others acting on stale information. Participants never message each other directly, so the CASE_MANAGER's fan-out is how the transition reaches them.
See also: PCR-08-001 — context for the reader
See also: VP-18-002 — context for the reader
CM-04-001 MUST A receiver of a participant-status message MUST record the declared RM state on the sending actor's CaseParticipant, as its model of the sender (SM-10-001).

RM state is self-declared: each participant reports its own report-handling progress (CM-03-002). A participant-status message updates the receiver's model of its sender. A record on any other participant would give one participant the progress of another. Other messages move the receiver's own state instead (SM-10-001). RSH-08-003 says which receiver writes the record directly.
Refines: SM-10-001
Implements: VP-01-002
CM-04-002 MUST A receiver processing a VFD state transition MUST update the VFD state in the participant status of the sending actor's CaseParticipant

VFD state is participant-specific (CM-03-005). A VFD message reports the fix readiness or deployment of the sender. A record on any other participant would claim a fix that this participant did not make.
Refines: SM-10-001
CM-04-004 MUST When the CASE_MANAGER adopts a PXA transition (public disclosure, exploit publication or attack observation), it MUST record the case-level PXA state in the case's CaseStatus. Every other replica takes that state from the CASE_MANAGER's ledger (RSH-08-003).

PXA state is a case-level fact (CM-03-004). A record of a reported disclosure, exploit or attack on the shared CaseStatus makes it visible to all participants at the same time. This is important because each of these events can end an embargo early. Only the CASE_MANAGER writes canonical case state (ADR-0108).
Refines: SM-10-002
See also: RSH-08-003 — context for the reader

It takes part in embargo negotiation: it answers an Invite(EmbargoEvent) addressed to it, and the CASE_MANAGER records its consent or refusal in PEC (§9 Participant Embargo Consent (PEC) State Machine).

Requirements

ID Priority Requirement Related
EP-09-003 MUST NOT A participant that receives an Invite(EmbargoEvent) MUST NOT write case EM state or any participant's consent state on receipt. It stores the Invite and answers it with Accept or Reject addressed to the CASE_MANAGER through its response decision (EMB-15).

Only the CASE_MANAGER turns an announcement into case state and every other participant takes case state from the ledger (ADR-0108, RSH-08-003). Consent is recorded when the CASE_MANAGER commits the answer, and the replica learns it from the ledger.
Refines: RSH-08-003
EP-09-025 MUST NOT A participant MUST NOT treat an Add(CaseLedgerEntry) that carries a proposal or an Invite as an invitation to answer. A participant answers only an Invite addressed to it.

The ledger is a channel for case state, not a protocol interaction. Giving an entry parse-and-respond semantics would let every future entry type become an implicit request, and would fork the negotiation into two paths, one over Invites and one over entries. The interactions the behavioural specs define are the ones that happen; the ledger records them.
EMB-15-004 MUST An actor that rejects an embargo overture MUST answer with the activity that matches what it rejects. The Case Owner deciding a proposal for the case sends ER, its Reject(EmbargoEvent)[target=VulnerabilityCase], which returns the shared EM to NONE (EMB-06, MSM-07-009). A participant answering an embargo Invite sends a Reject of the Invite, which records only its own consent (MSM-07-004). That Reject marks the rejected embargo's row DECLINED. A signatory refusing proposed terms keeps its row for the embargo in force (MSM-07-015).

A proposal and an Invite carry different EM and consent semantics, so the rejection has to match the overture for every participant to read it the same way. The pre-public constraint (EMB-01-002) is a hard protocol rule that overrides any local acceptance policy.

ECA Details

Preconditions

- Inbound overture received; decision resolves to reject, OR CS is public/exploit/attacks forcing rejection (EMB-01-002)

Steps

1. [participant] Answer with the rejection that matches the overture → The Case Owner's decision on a proposal is ER (EM → NONE); an embargo Invite gets a Reject of the Invite, recording DECLINED

Postconditions

- Overture rejected with the activity that matches it

Uses definition from: MSM-07-009
Uses definition from: MSM-07-004
See also: MSM-07-015 — context for the reader

It sends every case-scoped message to the CASE_MANAGER (§10.2 Routing Topology).

Requirements

ID Priority Requirement Related
PCR-08-001 MUST After a case is created and its CASE_MANAGER introduced, a participant MUST address each case-scoped message to that CASE_MANAGER alone, never directly to another participant. Case-scoped messages include notes, status updates, embargo proposals, RM transitions and any other protocol message about the case. The one exception is RK, Read(Offer(VulnerabilityReport)). RK answers the reporter's original Offer outside the case. So an addressee of that Offer sends RK to the reporter, never to the CASE_MANAGER (RMB-08-003, RMB-08-005).

A participant sends each case-scoped message to the CASE_MANAGER, so that the CASE_MANAGER can check the sender, record the change in the case ledger and send it on to the other participants (PCR-08-003). A message sent straight to a peer gets none of these steps, so the peer's replica and the canonical case disagree. RK is not a case message: it answers the reporter's Offer, which the reporter sent to that receiver before the case existed, so the answer goes back to the reporter (RMB-08-003).
See also: RMB-08-005 — context for the reader
PCR-08-005 MUST A participant MUST take the sole to: recipient of a case-scoped message from its case replica. That recipient is the participant holding the CASE_MANAGER role, never the case's full participant list.

The case's full participant list includes actors that are not entitled to every message (CM-10-004), and it reaches peers that the CASE_MANAGER has not yet checked the message for. Taking the CASE_MANAGER from the participant's own replica gives one recipient that the participant already trusts.

It can report PXA observations (§13.4.2 Participant-Agnostic CS Transitions (PXA)). It has no VFD drive obligations unless one of its roles adds them.

Why there is no sub-Observer level

A monitoring-only actor might seem to need message parsing and nothing else. Two things rule that out. An actor that does not track its own PEC state cannot take part in embargo negotiation, and the CASE_MANAGER decides what to send it on the basis of that state — so an untracked participant cannot be reliably served. An actor that does not track RM has no basis for evaluating case status. Meaningful use of Vultron data requires the full Observer set.

The protocol governs what the CASE_MANAGER sends, not what a recipient does with information it already holds. Vultron gates dissemination; it cannot constrain display.

A parse-only tool is not a case Participant: it holds no CaseParticipant record and no case is obliged to deliver anything to it.

Role-specific drive obligations

All Observer participants track all five machines. Which transitions a participant drives depends on its role extension set: a Vendor drives its own fix-ready transition, a Deployer drives its own fix-deployed transition, and any participant can report PXA observations. See §13.3 Role Taxonomy and §13.4 Role-Specific Normative Requirements.

Case Decision capability set

The Case Decision capability set provides what the Case Owner role needs. It is separable from the Case Hosting capability set. It adds these to the Case Observer capability set:

  • The Case Owner's own status reports are adopted without an approval step, because its updates are authoritative (§11.3 Status Adoption: One Authorization Gate).
  • The Case Owner decides the shared embargo: it activates and rejects embargo proposals for the case, and terminates the embargo in force.
  • The Case Owner can transfer case ownership, by a proposal to the CASE_MANAGER (§12.3 Case Ownership Transfer).

Requirements

ID Priority Requirement Related
CM-02-005 MUST CASE_MANAGER MUST restrict the following activities to the Case Owner: case closure, approving an embargo proposal to become active on the case and terminating an active embargo, approving or rejecting participant invitations, case ownership transfer, and offering a participant an additional role (CM-33-002) (see CM-02-006 for the authorisation mechanism).

These actions decide who learns about the vulnerability, under what embargo, and who is responsible for the case. In CVD, the Case Owner makes these decisions. If any participant can start them through the CASE_MANAGER, a participant can close the case, change the embargo, admit a party that nobody checked, or take the case.
See also: CM-02-006 — context for the reader
MSM-07-008 MUST The wire activity ACTIVATE_EMBARGO_ON_CASE (wire form: Add(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST activate the named proposal's embargo register entry and supersede any entry in force in the same step. The derived EM becomes ACTIVE (EA, or EC for a revision).

Giving the owner's decision its own activity retires the two-audience rule: an Accept of an Invite is always the sender's consent (MSM-07-003), and this activity is always the owner's decision for the case, so neither meaning depends on who sent the message (ADR-0122). The activity is an Add because the case gains the embargo, as the Remove that ends it takes it away, so the decision and a consent differ by verb (ADR-0180). When it replaces an embargo in force, the MSM-07-005 consent rule settles the rows.
Uses definition from: VAM-05-008
MSM-07-009 MUST The wire activity REJECT_EMBARGO_PROPOSAL_ON_CASE (wire form: Reject(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST reject the named proposal's embargo register entry. Once no other proposal is open, the derived EM becomes NONE (ER) or stays ACTIVE with the prior terms in force (EJ). It stays PROPOSED or REVISE while another proposal is open (EMB-18-005).

The owner's rejection decides the proposal for the case; whether the owner, as a participant, also refuses those terms is a separate Reject of the Invite (MSM-07-004). The owner's own row does not constrain the rejection: an owner that accepted terms for itself may still reject them for the case (ADR-0180). Keeping the two apart lets the owner keep the prior terms without declining them (ADR-0122).
Uses definition from: VAM-05-009
Uses definition from: EMB-18-005
CM-21-005 MUST A Case Owner MUST propose an ownership transfer by sending Offer(Offer(VulnerabilityCase)), with the case as context, to the CASE_MANAGER only, never to the transferee (PCR-08-001).

Routing the transfer through the CASE_MANAGER lets it ledger the offer in flight and broadcast it to every active participant (CM-10-004), so no participant is unaware a transfer is being negotiated. The CASE_MANAGER cannot be the transferee: its Offer would have itself as its only recipient, which BT-17-008 forbids, the same ground on which CM-33-003 refuses a role offer to it.
Refines: PCR-08-001
CM-21-025 MUST The inner Offer of an ownership-transfer proposal MUST name the case as its object and the transferee as its target. It optionally carries the deadline to answer as its end_time (CM-21-016).

The inner Offer says what the owner asks the CASE_MANAGER to offer and to whom. Without the case and the transferee in it, the CASE_MANAGER cannot make the Offer the owner asked for (CM-21-028).
Extends: CM-21-005
Uses definition from: CM-21-016
CM-21-026 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal, with no ledger commit and no outbound Offer, unless its inner Offer passes two checks. The inner Offer's object is the proposal's case. Its target is an actor the CASE_MANAGER can address (present, neither itself nor the proposer) and an active participant of the case (CM-21-021).

A proposal is a request the CASE_MANAGER acts on. An inner Offer that names another case, or a transferee the CASE_MANAGER cannot address, would make an Offer nobody can answer, or one about a case the proposal did not concern.
Extends: CM-21-005
Uses definition from: CM-21-021
CM-21-027 MUST When it admits an ownership-transfer proposal, the CASE_MANAGER MUST ignore any id, actor or to inside the inner Offer.

The CASE_MANAGER makes the Offer itself (CM-21-028). An id, actor or recipient list that the owner wrote into the inner Offer would let the owner choose fields that only the CASE_MANAGER sets, such as an id that collides with a stored object.
Extends: CM-21-005
CM-21-028 MUST On admitting a proposal, the CASE_MANAGER MUST make the single ownership-transfer Offer(VulnerabilityCase) itself, under an id it derives from the proposal, addressed to the transferee. The Offer's actor is the CASE_MANAGER, its attributed_to the owner and its in_reply_to the proposal (CM-24-001, CM-24-002, CM-24-020).

Making the Offer itself rather than forwarding the owner's gives a transfer one Offer, under an id no other party chose, told apart from the proposal by its shape (ADR-0148, DL-06-006).
Extends: CM-21-005
Refines: CM-24-001
Refines: CM-24-002
Refines: CM-24-020
CM-21-029 MUST The CASE_MANAGER MUST ledger the Offer it made from a proposal once that Offer is in its outbox (SYNC-09-002). That Offer is the one that is ledgered, answered, closed and expired.

Ledgering the Offer after it is queued keeps the ledger from recording an Offer that was never sent. One ledgered Offer gives every reader one transfer to answer, close or expire (CM-21-014).
Extends: CM-21-028
Refines: SYNC-09-002
MSM-07-028 MUST ACTIVATE_EMBARGO_ON_CASE MUST mark the Case Owner's row for the activated embargo AGREED when that row is UNINVITED, INVITED or TIMED_OUT. An AGREED row is left as it is, and an activation from a DECLINED row is refused (MSM-07-037).

The owner that activates terms is bound by them, so its own row has to say so. A row that holds no answer the owner gave, or only a lapsed invitation, contradicts nothing when it becomes AGREED, so the owner need not accept before it activates (ADR-0180).
Extends: MSM-07-008
Uses definition from: CM-18-003
MSM-07-029 MUST The CASE_MANAGER MUST refuse ACTIVATE_EMBARGO_ON_CASE before committing it in two cases. One is a named embargo that is not an open proposal of the case. The other is CS that is public, exploited or attacked (EMB-02-002).

Refusing a doomed activation before the commit keeps the ledger free of an entry that replicas, copying its step, would apply without the CASE_MANAGER's P/X/A check (CM-23-016).
Extends: MSM-07-008
Refines: EMB-02-002
MSM-07-027 MUST The CASE_MANAGER MUST accept ACTIVATE_EMBARGO_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Activating an embargo is the Case Owner's decision for the case (CM-02-005), so no other participant's activity may make it.
Extends: MSM-07-008
Refines: HP-01-006
MSM-07-031 MUST NOT REJECT_EMBARGO_PROPOSAL_ON_CASE MUST NOT change any participant's consent rows, the Case Owner's included.

The owner's decision for the case is not its consent as a participant; that is a Reject of the Invite (MSM-07-004).
Extends: MSM-07-009
MSM-07-032 MUST This rule covers REJECT_EMBARGO_PROPOSAL_ON_CASE of the last open revision while CS is public, exploited or attacked. The CASE_MANAGER MUST also terminate the embargo in the same act (EMB-04-002). It trial-applies both steps before committing either. It commits the Reject's entry carrying the REJECT step, then its own ET Remove(EmbargoEvent) entry carrying the TERMINATE step. A refused termination commits neither.

Reverting to the prior terms is not viable once disclosure has happened, so the rejection ends the embargo. Deciding both steps together means a replica copying both entries ends with the revision REJECTED and EM EXITED, as the CASE_MANAGER does.
Extends: MSM-07-009
Refines: EMB-04-002
MSM-07-033 MUST The CASE_MANAGER MUST refuse REJECT_EMBARGO_PROPOSAL_ON_CASE before committing it when the named embargo is not an open proposal of the case.

There is nothing to decide, and a committed entry naming no open proposal would be applied by every replica that copies it.
Extends: MSM-07-009
MSM-07-030 MUST The CASE_MANAGER MUST accept REJECT_EMBARGO_PROPOSAL_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Deciding a proposal for the case is the Case Owner's authority, so no other participant's activity may reject it for the case.
Extends: MSM-07-009
Refines: HP-01-006

A human Coordinator typically provides the Case Decision capability set while a service actor provides Case Hosting.

Case Hosting capability set

The Case Hosting capability set provides what the CASE_MANAGER role needs. It is separable from the Case Decision capability set. It adds the following to the Case Observer capability set.

It holds the CASE_MANAGER role for each case it hosts, and so it is that case's single writer (§10.1 Single-Writer Authority).

Requirements

ID Priority Requirement Related
CM-02-001 MUST Each VulnerabilityCase MUST have exactly one associated CASE_MANAGER

The CASE_MANAGER is the only writer of canonical case state (CM-02-002). With no CASE_MANAGER, no actor can commit a case change. With two, two actors can commit changes that conflict. The copies of the case then become different, and no rule can make them agree again.
CM-02-002 MUST CASE_MANAGER MUST be the authoritative source of truth for case state

Every participant has its own copy of the case. Without one source of authority, two participants that disagree have no rule to decide which copy is correct, and the copies become different. When the CASE_MANAGER is that source, every replica gets the same state (ADR-0108).
BT-10-003 MUST The actor holding the CASE_MANAGER role for a case MUST process that case's messages. The authority is that role, not any particular actor that enacts it.

When message processing follows the role and not one specific object, any actor that holds the role can do the work. This includes an actor that the Case Owner delegates the role to, and the Case Owner itself. If an obligation names a separate case actor, implementations create one for each case, which BT-10-002 forbids.
Depends on: BT-10-002
BT-10-004 MUST The actor holding the CASE_MANAGER role for a case MUST enforce that case's authorization decisions.

Each authorization decision of a case needs one enforcer that every participant can name. The CASE_MANAGER processes the messages of the case (BT-10-003), so it is the actor that admits or refuses them.

It keeps the canonical case ledger, and replicates each entry to the participants as Add(CaseLedgerEntry).

Requirements

ID Priority Requirement Related
CLP-04-001 MUST The authoritative history of a case MUST be the append-only canonical ledger; every entry in it records a protocol-significant admitted assertion. The ledger contains no refused or locally-scoped entries (see CLP-04-007).

Replicas agree only when they share one source of history. If any other record could also define the case history, two holders could each follow a different source and disagree with no way to decide which is correct.
See also: CLP-04-007 — context for the reader
CLP-04-004 MUST CASE_MANAGER fan-out replication MUST deliver the canonical CaseLedgerEntry content, wrapped in an ActivityStreams transport envelope such as Add

A replica must check the entry hash against the content that the CASE_MANAGER committed. If fan-out sends a rebuilt or summarized form, the replica cannot verify the chain. The envelope only carries the entry, so the entry stays the same for every recipient.
PCR-08-003 MUST The CASE_MANAGER MUST, for every participant message it receives and accepts, commit a CaseLedgerEntry recording the outcome and broadcast Add(CaseLedgerEntry) to the case's active participants (CM-10-004) as the standard cascade. This cascade is the only mechanism by which participants learn of accepted case-state changes.

Participants learn of case changes only from the ledger. If the CASE_MANAGER applied a change without an entry, or recorded an entry without sending it, the other replicas would never learn of the change and would disagree with the canonical case.
Uses definition from: CM-10-004

It runs multi-party case management: participant invitation and acceptance, role assignment and case ownership operations, each under the case's authorization rules.

Requirements

ID Priority Requirement Related
CM-02-006 MUST CASE_MANAGER MUST enforce case-level authorization for all case mutations

The CASE_MANAGER applies every change to canonical case state. Thus it is the one place that can stop an unauthorized change before every replica copies it. If a change path skips the check, any actor that can get to the inbox can change the case.
PCR-08-008 MUST The invitee's Accept of that Invite (PCR-08-007) MUST be addressed to the CASE_MANAGER (not the Case Owner). The CASE_MANAGER is the authoritative recipient and processor of all case-management handshake messages after case creation.

Only the CASE_MANAGER records the invitee's join in the case and in the ledger. When the Case Owner is not the CASE_MANAGER, an Accept addressed to the Case Owner reaches an actor that cannot record the join, so the join is never recorded.
Refines: PCR-08-001
Uses definition from: PCR-08-007
PCR-08-009 MUST The CASE_MANAGER MUST process an invitee's replies and record their effect on its own copy of the case: a reply to the stub Invite as CM-11-001 and CM-11-007 require, and a reply to the full-case Invite as CM-11-011 requires.

The invitee's replies are the only source of its join and its judgment of the case. If the CASE_MANAGER did not record them, the case would show the invitee as not joined, and the invitee would get no case content.
Uses definition from: CM-11-001
Uses definition from: CM-11-007
Uses definition from: CM-11-011

It applies the status adoption model, including the canonical-write-before-side-effects ordering (§11.3 Status Adoption: One Authorization Gate).

It delivers full case content only to a participant that passes the gate of §9.7 Gating Full Case Delivery.

Requirements

ID Priority Requirement Related
CM-10-004 MUST The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).

Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122).
Uses definition from: CM-14-001
Uses definition from: CM-18-001
Uses definition from: CM-31-001
CM-10-005 MUST NOT This rule covers each Add(CaseLedgerEntry) the CASE_MANAGER sends, as fan-out of a new entry or as a replay answering a Reject(CaseLedgerEntry) (SYNC-03-002). While an embargo is active, the CASE_MANAGER MUST NOT send one to a participant that has not accepted that embargo (the CM-10-004 content gate).

The ledger fan-out is how participants learn every accepted case change, and each entry carries its payload verbatim — an added report or note reaches the recipient whole. Fan-out is therefore "sharing case updates" in CM-10-004's sense. An entry cannot be redacted per recipient without breaking the hash chain. Skipping a single entry does not work either: the replica buffers the next one as a forward gap and Rejects to request the missing entry (SYNC-14-002), so the replay would deliver the withheld content anyway. The gate therefore pauses the participant's whole stream, replay included, rather than filtering entries; the replica stays at the last entry it was sent.
Refines: CM-10-004
Uses definition from: SYNC-03-002
CM-10-008 MUST While an embargo is active, the CASE_MANAGER MUST still deliver an embargo Invite, and its responses, to a participant that has not accepted the embargo. These are embargo meta-protocol activities addressed to the participant directly, not ledger fan-out.

These activities are not ledger fan-out, so the CM-10-005 pause does not cover them. A participant that never receives the embargo Invite cannot accept the embargo, so its paused stream could never resume.
Extends: CM-10-005

Ledger replication mechanics are specified separately

This specification states what the ledger is and that the CASE_MANAGER replicates it. One CASE_MANAGER holds exclusive write authority, and sends each entry to every participant actor.

The mechanics of that replication — hash-chaining, gap detection and ordering guarantees — are specified in a companion Vultron Ledger Replication Specification, which is still in draft and is not yet published alongside this document. An implementation cannot demonstrate conformance to the replication mechanics from this document alone. The reasoning for splitting them is recorded in ADR-0077.

Distributed consensus among several CASE_MANAGERs is a possible future extension and is out of scope here.

Named configurations

Common combinations of capability sets have names because they appear frequently in real deployments. These names are informative; conformance claims use the full capability set list.

Configuration Capability sets Roles
Hosting Coordinator Case Observer + Case Decision + Case Hosting Coordinator + Case Owner
Self-coordinating Vendor Case Observer + Case Decision + Case Hosting Vendor + Deployer + Case Owner
Bug Bounty Platform Case Observer + Case Hosting CASE_MANAGER (Case Decision optional)

A Hosting Coordinator is a type:service actor that holds both CASE_OWNER and CASE_MANAGER roles. It decides and executes without a separate human approval step for its own status updates.

13.3 Role Taxonomy

13.3.1 Process Roles

Process roles define what an actor does within a case and which protocol transitions it is authorized to drive. An actor can hold several process roles, and what it may do is the union of what its roles permit.

Role Protocol capability
Reporter Initiates cases; drives RS; authoritative source of the original report
Vendor Drives its own VFD transition f→F (fix ready, CF)
Deployer Drives its own VFD transition d→D (fix deployed, CD)
Coordinator Coordinates multi-party disclosure; holds no independent protocol authority. Participant management is a CASE_MANAGER and Case Owner function
CVE Numbering Authority (CNA) Can assign CVE IDs directly; a participant without the role delegates assignment. Orthogonal to the other roles, and typically co-held with Coordinator or Vendor
Observer Holds no drive obligations for VFD; can report PXA observations (§13.4.2 Participant-Agnostic CS Transitions (PXA))

Requirements

ID Priority Requirement Related
CM-26-001 MUST Each actor MUST judge a participant's permitted and obligated actions by the union of what its case roles permit. A MUST NOT attached to one role gives way when another of its case_roles carries a MAY, SHOULD or MUST for the same action class.

CVD roles represent orthogonal functions a participant may perform. When a participant holds more than one function (e.g., a security researcher who is also a Deployer for an affected product), restricting them based on their least-capable role would incorrectly limit their protocol participation. The union model prevents role restrictions from blocking obligations that exist under a co-role.
CSB-15-001 MUST A participant MUST hold the VENDOR role in the case to report its own fix-ready transition (f → F).

Fix readiness (F event) represents that the actor has produced a fix. Only actors who develop or maintain the affected product (Vendors) can produce a fix; Deployers operate existing deployments and do not produce fixes. Finders, Reporters, and Coordinators likewise MUST NOT self-report fix readiness.

ECA Details

Preconditions

- A participant is about to report its own f → F transition

Steps

1. [participant] Check that the participant holds the VENDOR role in the case → The check passes for a Vendor; the transition is refused otherwise
2. [participant] If the check passes, report its vf state as F → The report goes to the CASE_MANAGER

Postconditions

- Only a VENDOR participant reports F

CSB-15-007 MUST NOT A participant without the VENDOR role in the case MUST NOT record its own fix-ready transition (f → F). Such a participant has no vendor-fix (vf) path.

Only a Vendor can produce a fix (CSB-15-001). A recorded F from any other participant would claim a fix it cannot have produced, and every reader of its status would believe it.

ECA Details

Postconditions

- Only a VENDOR participant records F

Extends: CSB-15-001
CSB-15-002 MUST A participant MUST hold the DEPLOYER role in the case to report its own fix-deployed transition (d → D).

Fix deployment (D event) represents applying a fix in one's own environment. Only actors who are responsible for operating deployed instances (Deployers) can perform this action. A shipping-product Vendor who does not control downstream deployment holds only the VENDOR role, not DEPLOYER, and has no deployer path.

ECA Details

Preconditions

- A participant is about to report its own d → D transition

Steps

1. [participant] Check that the participant holds the DEPLOYER role in the case → The check passes for a Deployer; the transition is refused for a VENDOR-only or any other non-DEPLOYER participant
2. [participant] If the check passes, report its d state as D → The report goes to the CASE_MANAGER

Postconditions

- Only a DEPLOYER participant reports D

CSB-15-009 MUST NOT A participant without the DEPLOYER role in the case MUST NOT record its own fix-deployed transition (d → D). Such a participant has no deployer (d) path.

Only a Deployer operates the deployed instances (CSB-15-002). A recorded D from any other participant would claim a deployment it cannot have done.

ECA Details

Postconditions

- Only a DEPLOYER participant records D

Extends: CSB-15-002
CM-25-005 MUST NOT A participant whose only case role is OBSERVER MUST NOT emit VFD state-transition messages (CV, CF, or CD). An Observer has no vendor-fix-deployment obligations and no authority to advance the VFD dimension on behalf of a product or service.

An Observer joined the case to monitor it, not to own a fix path. Permitting VFD emissions from a role with no fix obligations would corrupt the VFD state machine for the case (e.g., a monitoring actor falsely claiming fix deployment).

Capability prerequisites. Every case Participant, whatever its roles, provides the Case Observer capability set (§13.2 Capability Sets, §13.3.3 Roles and Capability Sets Are Independent). Role extension sets add obligations on top of that floor; they do not substitute for it. An implementation can check that an actor has the capability prerequisites for a role before it completes a role assignment (§12.1 Role Assignment).

This specification states the per-role obligations in §13.4 Role-Specific Normative Requirements. It does not yet state a complete capability prerequisite for every role.

Note on Reporter

Reporters are most often also the discoverer of the vulnerability, but the protocol is concerned with who reported it, not who found it. The identity of the original discoverer can be recorded in the report itself or in case Notes, but nothing in the technical protocol hinges on that distinction. Reporter is the protocol-salient role from first contact.

13.3.2 Protocol Coordination Roles (protocol authority)

These roles confer specific protocol-layer authority and are distinct from process roles. They describe what an actor controls within the protocol machinery, not what it does in the world.

Role Protocol authority
Case Owner Authoritative decision-maker for a case; status updates are treated as authoritative without requiring approval; drives shared EM transitions
CASE_MANAGER Holds the case's single-writer authority (§10.1 Single-Writer Authority): writes the canonical case ledger, relays case-scoped messages, and manages the roster on the Case Owner's behalf (§2.2 Roles). Authority follows the role, not the actor that holds it; the role is commonly co-held with Coordinator but need not be (§13.3.3 Roles and Capability Sets Are Independent)

Requirements

ID Priority Requirement Related
CM-21-001 MUST A VulnerabilityCase MUST have at most one participant that holds CASE_OWNER at any point in time.

CASE_OWNER confers exclusive case administration authority (CM-02-004, CM-02-005). Two simultaneous holders would create conflicting authority: both could terminate embargoes, authorise invitations, and mutate case state independently. The invariant must be enforced at the data-layer level, not just assumed by convention.
CM-21-023 MUST When a new owner is designated, the system MUST remove CASE_OWNER from the previous holder before, or atomically with, granting it to the new owner.

A grant made before the strip would leave two holders for a moment, which CM-21-001 forbids. Stripping first, or in the same step, keeps the invariant at every point in time.
Implements: CM-21-001
CM-02-004 MUST CASE_MANAGER MUST know the Case Owner

Only the Case Owner can do some case actions (CM-02-005). The CASE_MANAGER can enforce this only if it knows the Case Owner. The case records the Case Owner in attributed_to.
CM-02-005 MUST CASE_MANAGER MUST restrict the following activities to the Case Owner: case closure, approving an embargo proposal to become active on the case and terminating an active embargo, approving or rejecting participant invitations, case ownership transfer, and offering a participant an additional role (CM-33-002) (see CM-02-006 for the authorisation mechanism).

These actions decide who learns about the vulnerability, under what embargo, and who is responsible for the case. In CVD, the Case Owner makes these decisions. If any participant can start them through the CASE_MANAGER, a participant can close the case, change the embargo, admit a party that nobody checked, or take the case.
See also: CM-02-006 — context for the reader

Delegation scenarios: Protocol responsibilities can transfer during a case lifecycle. For example, a Reporter who initially creates a case can delegate coordination to a Coordinator (reporter → coordinator hand-off), or a primary Vendor can bring in additional Vendors as the case grows. When a Case Owner transfers ownership, through a proposal to the CASE_MANAGER that the transferee accepts (§12.3 Case Ownership Transfer), the receiving actor acquires Case Owner authority and the associated protocol responsibilities.

Open architectural question: key handover

Moving the CASE_MANAGER role to a different actor raises an unresolved key-handover question for future case-encryption designs. The question is stated once, at §12.3 Case Ownership Transfer.

13.3.3 Roles and Capability Sets Are Independent

A role is a position within a case. A capability set is a property of software. Mixing them produces contradictions, so the relationship is stated explicitly:

  • Every case Participant, whatever its roles, provides the Case Observer capability set (§13.2 Capability Sets). Holding a role means having a CaseParticipant record, an RM state, and therefore tracking obligations.
  • A parse-only actor is not a case Participant: it holds no role and no case owes it delivery.
  • An implementation holding the Case Hosting capability set additionally hosts the CASE_MANAGER role and is obliged to run the ledger. Case Hosting is commonly co-held with the Coordinator role. Ledger authority follows the CASE_MANAGER role the implementation holds — not its hosting location, and not any actor name.

Requirements

ID Priority Requirement Related
BT-10-002 MUST Case creation MUST establish the case's CASE_MANAGER by recording a participant that holds the CASE_MANAGER role.

The CASE_MANAGER is a role that a participant holds. It is not a separate entity. When case creation records the role on a participant, any actor can take the role, and every participant finds the CASE_MANAGER in the participant records of the case.
BT-10-003 MUST The actor holding the CASE_MANAGER role for a case MUST process that case's messages. The authority is that role, not any particular actor that enacts it.

When message processing follows the role and not one specific object, any actor that holds the role can do the work. This includes an actor that the Case Owner delegates the role to, and the Case Owner itself. If an obligation names a separate case actor, implementations create one for each case, which BT-10-002 forbids.
Depends on: BT-10-002
BT-10-004 MUST The actor holding the CASE_MANAGER role for a case MUST enforce that case's authorization decisions.

Each authorization decision of a case needs one enforcer that every participant can name. The CASE_MANAGER processes the messages of the case (BT-10-003), so it is the actor that admits or refuses them.

Observer is a participant role, not a passive state

An Observer role holder that is in a case implements the full Case Observer capability set: it has an RM state, it is subject to embargo consent, and it can report PXA observations. The Observer role is distinguished by holding no VFD drive obligations — not by being exempt from state tracking.

Observer role admission follows the standard Invite / Accept(Invite) path.

Requirements

ID Priority Requirement Related
CM-25-002 MUST An Observer MUST be admitted to a case via the standard Invite/Accept flow defined in CM-17.

Requiring a non-empty case_roles value is load-bearing: the participant record created with the stub Invite (CM-11-026) carries the roles that Invite names. A missing or empty list would create an Observer participant with no role — indistinguishable from a defect.
CM-25-006 MUST The Invite activity sent by the CASE_MANAGER for an Observer MUST carry case_roles naming OBSERVER only.

The stub Invite creates the participant record and gives it the roles that the Invite names (CM-11-006). An Invite without CVDRole.OBSERVER would create a participant with an empty role list. Role checks cannot tell that record from a record that lost its roles. An Invite that names other roles would give the Observer obligations or authority that it was not invited to hold.
Extends: CM-25-002
Refines: CM-17-003

13.4 Role-Specific Normative Requirements

13.4.1 Participant-Specific CS Transitions (VFD)

VFD records what a specific participant has done, so authority to cause a VFD transition is scoped to the participant that did it.

Recall: vendor/fix/deploy states

State Vendor Aware Fix Ready Fix Deployed
vfd no no no
Vfd yes no no
VFd yes yes no
VFD yes yes yes

Full definitions are in §8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed.

Participant status is self-declared: each participant reports its own VFD transitions. Each self-reported transition needs the role that owns it:

  • f→F (VFd, fix ready) needs the Vendor role.
  • d→D (VFD, fix deployed) needs the Deployer role. A Deployer that is not also a Vendor has no fix of its own, so it can deploy only once some Vendor in the case has a fix ready.

A Vendor-only actor therefore cannot advance past VFd. A CASE_MANAGER refuses a received status that states a fix-readiness value from a sender without the Vendor role, or a deployment value from a sender without the Deployer role.

Requirements

ID Priority Requirement Related
PRM-06-001 MUST Participant status is self-declaratory by default: each participant asserts its own RM and VFD state without external approval. This is why they are participant status items (ADR-0121). The one write about a participant that the participant does not make is its birth: the CASE_MANAGER creates the record at RM RECEIVED (and VF vf for a vendor) when it sends the stub Invite (CM-11-006, ADR-0114).

The self-declaratory model keeps state authority with the role holder. Deviations must be narrow, externally evidenced, and explicitly named (ADR-0121).
See also: CM-11-006 — context for the reader
CSB-15-001 MUST A participant MUST hold the VENDOR role in the case to report its own fix-ready transition (f → F).

Fix readiness (F event) represents that the actor has produced a fix. Only actors who develop or maintain the affected product (Vendors) can produce a fix; Deployers operate existing deployments and do not produce fixes. Finders, Reporters, and Coordinators likewise MUST NOT self-report fix readiness.

ECA Details

Preconditions

- A participant is about to report its own f → F transition

Steps

1. [participant] Check that the participant holds the VENDOR role in the case → The check passes for a Vendor; the transition is refused otherwise
2. [participant] If the check passes, report its vf state as F → The report goes to the CASE_MANAGER

Postconditions

- Only a VENDOR participant reports F

CSB-15-007 MUST NOT A participant without the VENDOR role in the case MUST NOT record its own fix-ready transition (f → F). Such a participant has no vendor-fix (vf) path.

Only a Vendor can produce a fix (CSB-15-001). A recorded F from any other participant would claim a fix it cannot have produced, and every reader of its status would believe it.

ECA Details

Postconditions

- Only a VENDOR participant records F

Extends: CSB-15-001
CSB-15-002 MUST A participant MUST hold the DEPLOYER role in the case to report its own fix-deployed transition (d → D).

Fix deployment (D event) represents applying a fix in one's own environment. Only actors who are responsible for operating deployed instances (Deployers) can perform this action. A shipping-product Vendor who does not control downstream deployment holds only the VENDOR role, not DEPLOYER, and has no deployer path.

ECA Details

Preconditions

- A participant is about to report its own d → D transition

Steps

1. [participant] Check that the participant holds the DEPLOYER role in the case → The check passes for a Deployer; the transition is refused for a VENDOR-only or any other non-DEPLOYER participant
2. [participant] If the check passes, report its d state as D → The report goes to the CASE_MANAGER

Postconditions

- Only a DEPLOYER participant reports D

CSB-15-009 MUST NOT A participant without the DEPLOYER role in the case MUST NOT record its own fix-deployed transition (d → D). Such a participant has no deployer (d) path.

Only a Deployer operates the deployed instances (CSB-15-002). A recorded D from any other participant would claim a deployment it cannot have done.

ECA Details

Postconditions

- Only a DEPLOYER participant records D

Extends: CSB-15-002
CSB-15-004 MUST A participant that holds the DEPLOYER role but not the VENDOR role MUST be permitted to make the d→D transition only when at least one participant holding the VENDOR role in the same case has reached F (fix ready). Such a participant has no vendor-fix (VF) state of its own and is at d before the transition; the transition moves it to D, recording deployment of a fix another participant produced.

A participant with the DEPLOYER role and no VENDOR role has a deployer path and no vendor path (ADR-0075). It can deploy only a fix that exists, so its d→D move waits until at least one VENDOR participant in the case is at F. Its d dimension starts at d and moves to D when that gate passes. The gate asks only that some VENDOR is at F, because the protocol does not record which vendor a deployer depends on, and a rule that named the vendor would need that record.

ECA Details

Preconditions

- The participant holds the DEPLOYER role but not VENDOR in the case (no vendor path; deployer path at d); at least one other participant holds the VENDOR role and is at F

Steps

1. [participant] Check that the participant holds DEPLOYER and not VENDOR, and that at least one participant in the case holds VENDOR and is at F (causal gate) → All checks pass; d → D transition allowed
2. [participant] Record its d state as D and report it → d is D (it was d); the participant still has no vendor path; the report goes to the CASE_MANAGER

Postconditions

- The DEPLOYER-only participant records D with no vendor path throughout; at least one VENDOR participant is at F in the same case

Extends: CSB-15-002 — CSB-15-002 gates d→D on the DEPLOYER role; CSB-15-004 adds the causal precondition requiring at least one VENDOR participant to be at F first
RSH-09-003 MUST A received ParticipantStatus MUST be refused when any of these holds: the participant's recorded RM state is CLOSED, which is terminal; its RM state moves backwards (RSH-06-002); it states a fix-readiness value but the sender does not hold the VENDOR role, or a deployment value but the sender does not hold the DEPLOYER role; a stated fix-readiness, deployment or public-state (P/X/A) value is neither the participant's most recent recorded value nor a forward move from it. A dimension the sender omits is not refused, and does not reset the recorded value a later status is judged against. Every status states an RM state: one that leaves rmState out states the initial START. The embargo state the status embeds is not judged against the case: the case derives EM from its embargo register.

Each rule refuses a claim no sequence of events could produce from the participant's recorded state. A non-adjacent forward move is accepted (RSH-06-001, CSB-16-001): a peer may have advanced several steps between messages. EM belongs to the embargo register (ADR-0122), and the report's P/X/A reaches the case only through the adoption gate (RSH-01-003).
Extends: RSH-09-001

Two transitions can also be asserted on another participant's behalf, by the CASE_MANAGER or the Case Owner. Vendor awareness (v→V) is the usual case: the party that notified the vendor knows that the vendor has the information. The protocol expects evidence of the notification to ground the assertion — for example, the vendor's acknowledgment of its Invite. The reference implementation does not check this evidence. It checks only that the asserter holds the CASE_MANAGER or Case Owner role and that the target is already a participant holding the Vendor or Deployer role. A Deployer's fix deployment (d→D) can be asserted the same way, which is expected to be rare: deployment is normally the Deployer's own report. Fix readiness is never asserted on a vendor's behalf, because only the vendor can know it.

Requirements

ID Priority Requirement Related
PRM-06-003 MAY A CASE_MANAGER or Case Owner MAY assert v→V (Vf) on behalf of a Vendor-role participant when the notification or invite is evidenced. Any vendor acknowledgement, including Read(Invite(VulnerabilityCase preview)[target=Actor]), is evidence. The target is typically an inert invitee that has not yet replied, and it must already be a participant (PRM-06-006). This move is the whole of what the status asserts: it cannot be asserted in the same status as the d→D of PRM-06-004.

Without this path, the case cannot record that an invited vendor is aware until the vendor replies to the Invite. A vendor acknowledgement already shows that the vendor is aware. The stub Invite creates the record (ADR-0114), so the assertion has a target. RM stays the same, so the assertion does not speak for the report decisions of the vendor. The pair with d→D is excluded: together they are VfD, which CSB-17-001 does not enumerate, and PRM-06-008 already has the entailments refuse it.
PRM-06-007 MUST NOT An on-behalf v→V write by a CASE_MANAGER or Case Owner MUST NOT change the target's RM state (ADR-0121).

RM records the vendor's own report decisions. The on-behalf assertion speaks only for the vendor's awareness, which its acknowledgement shows, so it leaves RM where the vendor put it. This holds for an inert invitee written before it replies (CM-11-029): awareness of the case is not a decision about it.
Extends: PRM-06-003
PRM-06-004 MAY A CASE_MANAGER or Case Owner MAY assert d→D (D) on behalf of a Deployer-role participant, under the same externally-evidenced pattern as PRM-06-003. The target must already be a participant (PRM-06-006). This move is the whole of what the status asserts: it cannot be asserted in the same status as the v→V of PRM-06-003.

Usually the deployer reports its own deployment. But a deployer that joined and has since gone quiet can leave the case unable to record a deployment the case has evidence of. The on-behalf limit keeps this narrow exception from becoming a general proxy capability, and a deployer that did not join is not in the case at all. The pair with v→V is excluded: together they are VfD, which CSB-17-001 does not enumerate, and PRM-06-008 already has the entailments refuse it.
Uses definition from: PRM-06-003
PRM-06-008 MUST The actor processing an on-behalf d→D assertion MUST apply the cross-machine entailments, so it succeeds only for a deployer whose RM state fits deployment.

The on-behalf path is an exception to self-declaration, not a way around the rules every status write obeys. Without the entailments, it could record a deployment for a deployer that never accepted the report.
Extends: PRM-06-004
PRM-06-005 MUST NOT The f→F transition (fix ready, VF) MUST NOT be asserted by any actor other than the Vendor-role holder. Fix readiness is not externally knowable; no on-behalf assertion is ever permitted for this transition (ADR-0121).

Allowing a non-vendor to assert fix-readiness would let the CASE_MANAGER fabricate protocol-visible fix state, undermining the meaning of the F event.
PRM-06-006 MUST An actor processing an on-behalf status assertion MUST refuse it before any write if its target is not a case participant, creating no participant.

A status update is never a way into a case; joining is the Invite flow (CM-11, ADR-0114). If a status update creates the participant that it names, it is a second path into a case. That path skips the Invite flow and its consent and entitlement checks. If the record is created before the status write, and the write is then refused, a stray participant stays. For example, the RM-to-D entailment refuses d to D for a target that did not accept the report.
Constrains: PRM-06-003
Constrains: PRM-06-004

Publishing a fix is not deploying it

A vendor that publishes a patch has made the patch available. It has not deployed it: deployment happens in the systems that run the product, and it is a Deployer's act. Fix Ready and Fix Deployed are therefore distinct protocol facts, and neither is inferred from the other.

The same separation applies to public awareness. A notification that information is public sets Public Aware, which is world state. It does not set Fix Deployed, which is participant state requiring the Deployer role. An implementation that treats publication as deployment produces an unauthorized VFD advance.

Requirements

ID Priority Requirement Related
CSB-15-003 MUST A participant that reports that the vulnerability is public MUST record only the P event (pxa → Pxa) in its participant status.

Conflating P and D transitions causes non-deployer actors (Finders, Reporters, Coordinators) to incorrectly acquire deployment state when they announce public disclosure. The P event is participant-agnostic; the D event is valid only for a DEPLOYER participant that has separately completed deployment (CSB-15-002).

ECA Details

Preconditions

- A participant reports that the vulnerability is public

Steps

1. [participant] Record P (Pxa) in its participant status → Public awareness recorded

Postconditions

- The participant status records P

CSB-15-011 MUST NOT A participant's report of the P event MUST NOT also advance its d dimension.

The D event (fix deployed) is participant-specific and distinct from the P event (public awareness). A participant that reports fix deployment reports it separately, and must hold the DEPLOYER role (CSB-15-002).

ECA Details

Steps

1. [participant] Leave the vf and d dimensions unchanged (do not advance d to D) → vf and d reflect prior state; D event not triggered by P event

Postconditions

- The participant status's vf and d dimensions are unchanged

Refines: CSB-15-003

Open question: disputing an asserted vendor awareness

The first VFD transition — v→V, vendor becomes aware — has two drive paths. The vendor can report it for itself, and the CASE_MANAGER or the Case Owner can assert it on the vendor's behalf (§13.4.1 Participant-Specific CS Transitions (VFD)). The protocol expects evidence of the notification to ground that assertion, and the reference implementation does not check for it.

Open questions: can the subject Vendor dispute an awareness that another party asserted for it? Is transport-level delivery success, a Hypertext Transfer Protocol (HTTP) 200 response, enough evidence for the assertion?

Do not infer a rule from this document's silence.

13.4.2 Participant-Agnostic CS Transitions (PXA)

PXA records the state of the world rather than the state of any participant, so these transitions are not scoped to a role. Anyone can notice that a vulnerability has become public.

Recall: public/exploit/attacks axes

Axis Not yet Set Meaning when set
Public Aware p P The vulnerability is known outside the case participants
Exploit Public x X An exploit for the vulnerability has been published
Attacks Observed a A Attacks exploiting the vulnerability have been seen

Full definitions are in §8.2 PXA — Public Aware, Exploit Public, Attacks Observed.

Because PXA is world state, any participant can report a PXA observation, whatever roles it holds. These transitions are role-ungated: information can become public, exploits can appear, and attacks can be observed independently of anything a case participant does or causes.

  • p→P (publicly aware): any participant can report it
  • x→X (exploit public): any participant can report it
  • a→A (attacks observed): any participant can report it

A participant reports an observation in the case status that its own participant status carries.

Requirements

ID Priority Requirement Related
RSH-09-009 MUST NOT A received ParticipantStatus MUST NOT be refused for the sender's case roles over the public-state (P/X/A) values that its embedded CaseStatus states. A participant holding any role, OBSERVER alone included, can report that the vulnerability is public, that an exploit is public or that attacks are observed. Adoption decides whether a reported value becomes canonical case state (RSH-01-003), not the acceptance rules.

P, X and A record the state of the world, not anything a participant did, so no role owns them. A Vendor cannot be the only party able to say that an exploit is public: an Observer or a monitoring service is often the first to see it. The adoption gate, not a role check, protects canonical case state from a wrong report.
Extends: RSH-09-003
See also: RSH-01-003 — context for the reader
MSM-03-004 MUST Protocol shorthand CP (Public Aware) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes public awareness (P) in its pxaState.

A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001).
Uses definition from: VAM-08-002
Derives from: RSH-04-001
See also: RSH-04-005 — context for the reader
MSM-03-005 MUST Protocol shorthand CX (Exploit Published) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes a published exploit (X) in its pxaState.

A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001).
Uses definition from: VAM-08-002
Derives from: RSH-04-001
See also: RSH-04-005 — context for the reader
MSM-03-006 MUST Protocol shorthand CA (Attacks Observed) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes observed attacks (A) in its pxaState.

A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001).
Uses definition from: VAM-08-002
Derives from: RSH-04-001
See also: RSH-04-005 — context for the reader

Reporting is not adoption. A reported observation is a claim. Whether it becomes canonical case state, and whether it triggers embargo teardown, is decided by the CASE_MANAGER, following §11.3 Status Adoption: One Authorization Gate and subject to Case Owner authorization by default. The role rule here — who can report — is deliberately separate from the authorization rules there — what the CASE_MANAGER does with a report.

Informative: automated observers

An actor can be an automated service that monitors external sources — threat feeds, public disclosures, vulnerability databases — and reports what it finds into a case. Such a service is not a distinct protocol role: it reports PXA observations on the same terms as any other participant, and its reports are adopted through the same authorization as theirs (§11.3 Status Adoption: One Authorization Gate).

13.4.3 CVE ID Assignment

Assigning CVE IDs happens outside the protocol, so this section states no protocol requirement for it. It describes how the CVE Numbering Authority (CNA) role fits into a case.

An actor holding the CNA role can assign CVE IDs. Assignment includes evaluating the vulnerability against the eligibility criteria first.

An actor that does not hold the CNA role delegates ID assignment. It can delegate to an external CNA service, or to another participant in the same case that holds the CNA role. A coordinator or vendor acting as a CNA can do the assignment without the case leaving the protocol.

Eligibility criteria posture. This specification does not cite a specific edition of the CNA Operational Rules, and it does not treat eligibility checks as fully implementation-defined. Instead, the reference implementation follows CNA Operational Rules v4.1.0 as its baseline. Adopting a newer edition means updating the specification and the implementing call-out. This avoids coupling the Request for Comments (RFC) to the release cycle of an independently-versioned external document, while remaining transparent about which edition the reference implementation follows.

Eligibility checking is a single logical capability: the full set of criteria applied as a unit against one rules edition. The protocol treats it as one decision with one outcome, and does not specify how an implementation reaches that decision.

Reference implementation note

The Python reference implementation checks CVE eligibility with one EvaluateCveEligibility Evaluator call-out point, as BTND-05-007 describes. Three named checks come before it as separate call-out points: InScope, ProductInCNAScope and IsMostAppropriateCNA. The publication condition, IsOrWillBePubliclyDisclosed, reads case state directly and is not a call-out point.

13.4.4 Case Owner Authority

Adopting a reported status as canonical case state is the Case Owner's decision. The Case Owner is the party whose disclosure decision the case exists to serve, so it is the party entitled to decide what the case asserts. By default the protocol therefore has the CASE_MANAGER ask for the Case Owner's authorization before it adopts a participant's reported status.

One case is exempt. Where the Case Owner is itself the sender, the CASE_MANAGER adopts the status without asking: asking the Case Owner to approve its own report would be circular.

§11.3 Status Adoption: One Authorization Gate states both rules and the permissive configuration an implementation can choose instead. The reference implementation's main branch does not yet send the authorization request, and Known Gaps lists that request as not yet met, tracked by #2885. Section 11.3 says what main does meanwhile.

13.5 Conformance Testing Approach

Conformance is judged from outside the implementation. A test supplies a sequence of messages and an input state, and checks the messages the implementation emits and the state it reaches. It does not inspect internal structure.

Each test case is therefore a message-sequence scenario paired with the state outcome it expects.

Some capabilities that define a role are not protocol-observable at all. Developing a fix, deploying a fix and publishing an advisory happen outside the protocol. Conformance verifies the protocol messages that this work produces, not the work itself.

Conformance testing is organized in four layers, which describe what a test verifies. Layers are orthogonal to the capability sets of §13.2 Capability Sets, which describe what an implementation provides (see the warning in §13.1 Conformance Model Overview):

Layer Verifies
L1 — Syntax Messages are well-formed against the wire format (§5 Encoding and Transport)
L2 — Semantics Each message drives the correct state transition (§4 Messages, §6 Report Management (RM) State Machine through §12 Participant Lifecycle Within a Case)
L3 — Behavior Correct observable outputs: right messages emitted and states reached, given input state plus received message
L4 — Process Correct internal decision structure (e.g. precondition before state write before side-effect)

L4 is only enforceable against a reference implementation and is therefore outside the scope of independent conformance claims. Some process ordering surfaces at L3 where the output sequence is itself observable — the canonical-write-before-side-effects rule of §11.3 Status Adoption: One Authorization Gate being the clearest case.

See also

  • Process Models — the behavioral material the L2 and L3 layers test against

13.6 Capability Shapes

Capability shapes describe optional, pluggable capabilities that an implementation can connect to its own decision points. They are not part of the Case Observer, Case Decision or Case Hosting capability sets, and a conformance claim does not state which shapes an implementation provides.

A capability shape is a contract between an implementation and the capability it connects, not a protocol rule: other participants cannot observe which shapes an implementation uses. An implementation that provides a shape keeps to that shape's contract. The shapes and their contracts are described in Annex G Capability Shapes.

14. Requirements Catalog [N]

This section holds the normative requirements of the protocol. It lists every requirement of the protocol and foundation tiers once, and the row it gives a requirement is the one every other page links. The sections before it show a requirement as a callout where their text discusses it, and each callout links the requirement's row here.

The protocol tier is the Vultron layer: the rules that bind every implementation, in any language, that takes part in Vultron. It covers the forms Vultron messages take on the wire, including where ActivityStreams 2.0 (AS2) allows several forms and Vultron asks for one. It also covers which messages are sent and when, what a receiver does given its state, including on duplicate delivery, and the state machines underlying those behaviors.

The foundation tier holds the rules Vultron inherits unchanged from the standards beneath it: AS2, ActivityPub, and the Hypertext Transfer Protocol (HTTP). They have a subsection of their own, §14.8 Inherited Requirements, and an implementer reads them together with the protocol tier.

The protocol tier is grouped by theme into seven subsections, from §14.1 Vultron Protocol to §14.7 Transport and Security. Within a subsection, each requirement file has a heading of its own, and its requirements are listed group by group. Each row gives the requirement's ID, its priority, its statement and rationale, and the requirements it relates to.

A requirement can be written ahead of its code in the reference implementation. When every test of such a requirement is held as an expected failure or a skip, its row carries the marker "Not yet in the reference implementation", with links to the issues that track the work, and so does every callout of it. The marker is generated from the tests, and it leaves the row when a test of the requirement runs on main. The marker labels the reference implementation only: the requirement keeps its priority, and the protocol requires it all the same.

14.1 Vultron Protocol

The requirements of the core Vultron protocol: the Report Management (RM), Embargo Management (EM) and Case State (CS) models, the messages that move them, and the rules that couple them.

Vultron Protocol

Requirements extracted from the Vultron Protocol documentation, covering participant state tracking, Report Management (RM), Embargo Management (EM), CVD Case State (CS) messaging, model interactions, and implementation guidance. This is the normative source for protocol behavior requirements that implementations must satisfy.

Participant State Tracking
ID Priority Requirement Related
VP-01-001 SHOULD Participants SHOULD track the state of other Participants in a case to inform their own decision making

A participant's next move depends on where the others stand: whether a vendor has a fix, whether anyone has published, whether a coordinator has left. Without tracking their states a participant acts on a stale picture and may, for example, publish before a vendor is ready.
VP-01-002 SHOULD Participants SHOULD track the RM states of the other Participants in the case

RM state says whether each participant is still engaged with the report. Knowing it tells a participant who will still act on the case, whose replies to expect, and when a vendor has stopped work.
VP-01-003 MUST NOT Correct operation of the protocol MUST NOT depend on perfect information across all Participants

Participants in a distributed CVD case never all see the same state at the same moment: messages are delayed, lost, or withheld by embargo scope. A protocol that needed perfect shared information would stall or misbehave in every real case, so each step must be safe on the partial view a participant actually holds.
Report Management (RM): Receiving Reports
ID Priority Requirement Related
VP-02-001 MUST Coordinators MUST have a formally documented, publicly available mechanism for receiving reports

A reporter can coordinate only with a coordinator it can reach. Taking reports from anyone is the coordinator's role, so an undocumented or private intake path leaves reporters no way in and pushes them toward uncoordinated public disclosure.
VP-02-002 MUST Participants MUST assign Valid cases a higher processing priority than Received (untriaged) cases and Closed cases in their case-management workflow.

Valid reports are the ones known to need work, so effort spent on them is what reduces harm. Received reports are not yet judged and Closed reports need nothing more; letting either crowd out Valid work delays fixes for confirmed vuls.
VP-02-003 MUST Participants initiating CVD with others MUST do so from the Accepted state

Accepted is the RM state in which a participant has committed to work on the report. Drawing others into a case from an earlier state would commit them to coordination the initiator has not itself agreed to pursue.
VP-02-004 MUST NOT Participants MUST NOT close cases or reports from the Valid state

Valid means the report is real and in scope but no engage-or-defer decision has been made. Closing straight from Valid would let a confirmed vul be dropped without that prioritization decision ever being taken or announced, so the report must pass through Accepted or Deferred first.
VP-02-005 SHOULD Vendors SHOULD have a clearly defined and publicly available mechanism for receiving reports

Reporters can disclose privately to a vendor only if they can reach it. Without a known intake channel, reports are lost, sent to the wrong place, or published without coordination.
VP-02-006 SHOULD Participants SHOULD subject each Received report to a validation process resulting in a valid or invalid designation

Not every report describes a real vul in the recipient's scope. Validation separates real reports from noise, so that case creation, embargo commitments and coordination effort go only where they are warranted.
VP-02-007 SHOULD Participants SHOULD have a clearly defined process for validating reports in the Received state

A defined validation process makes valid and invalid decisions consistent and explainable to reporters. It also lets other participants trust what a Valid or Invalid announcement means.
VP-02-008 SHOULD Participants SHOULD have a clearly defined process for transitioning reports from the Received state to the Valid or Invalid states

Other participants read RM transitions as signals. If the move out of Received follows no defined process, those signals carry no reliable meaning and reports can sit in Received indefinitely.
VP-02-009 SHOULD Participants SHOULD proceed only after validating the reports they receive

Acting on an unvalidated report spends embargo commitments, coordination effort and other participants' attention on something that may not be a vul at all.
VP-02-010 SHOULD Participants SHOULD transition all valid reports to the Valid state and all invalid reports to the Invalid state

The RM state is how a participant tells others what it concluded about a report. A report left in Received, or put in the wrong state, misinforms every participant that tracks it (VP-01-002).
VP-02-011 SHOULD Once a Vendor confirms that a reported vulnerability affects one or more of their products or services, the Vendor SHOULD designate the report as Valid

The vendor's confirmation that its product is affected answers the question validation asks. Designating the report Valid then moves it on to prioritization and tells other participants the vendor has a real vul to fix.
VP-02-012 SHOULD Participants SHOULD temporarily hold reports that they cannot validate pending additional information

Many reports cannot be judged on first read because details are missing. Holding them, rather than marking them Invalid, keeps a real vul from being discarded only because the reporter has not yet supplied enough information.
VP-02-013 SHOULD Participants SHOULD provide Reporters an opportunity to update their report with additional information before closing it

Reporters can often supply the missing detail if asked. Closing without giving them that chance throws away real vuls and discourages reporters from using the coordinated channel next time.
VP-02-014 SHOULD For Valid reports, the Participant SHOULD perform a prioritization evaluation to decide whether to accept or defer the report

A valid report still competes with all other work for limited capacity. An explicit prioritization decision turns "this is real" into "we will work on it now" or "later", and gives the participant a decision to announce (VP-02-024).
VP-02-015 SHOULD Participants SHOULD create a case from reports entering the Valid state to track the report's progress through the CVD process

A case is the object that carries participants, embargo and CS state through the rest of the CVD process. Without one, work on a valid report has nothing to record progress against or to coordinate around.
VP-02-016 SHOULD Participants SHOULD have a bias toward accepting rather than deferring Valid cases up to their work capacity limits

Deferring a valid report leaves a known vul unaddressed and its reporter waiting. Accepting when capacity allows keeps real vuls moving toward a fix.
VP-02-017 SHOULD Reports SHOULD exit the Deferred state when work is resumed (to Accepted) or when the Participant has determined no further action will be taken (to Closed)

Deferred is meant as a pause, not a resting place. Leaving reports there indefinitely hides whether work will ever resume, so the participant moves them on once that is known.
VP-02-018 SHOULD Reports SHOULD be moved to the Closed state once a Participant has completed all outstanding work tasks and has determined that no further action will be taken on the report

Closed tells other participants that this participant will do no more on the report. Closing before outstanding work is done, or keeping finished reports open, misinforms the participants who track RM state.
VP-02-019 SHOULD CVD Participants SHOULD announce their RM state transitions to the case's CASE_MANAGER, which fans each one out to the other Participants in the case (PCR-08-001, VP-18-002).

Other participants plan their own work around who is engaged with a case (VP-01-002). Announcing RM transitions is how they learn of them; an unannounced close or defer leaves them expecting work that will not happen. A participant never messages another participant directly, so the announcement reaches them through the CASE_MANAGER's fan-out.
See also: PCR-08-001 — context for the reader
See also: VP-18-002 — context for the reader
VP-02-021 SHOULD Participants SHOULD act in accordance with their own policy and process when deciding when to transition RM states

Organizations differ in capacity, risk tolerance and published disclosure policy, and the protocol cannot know those. Leaving transition decisions to each participant's own policy keeps the protocol usable across them, while other requirements still make the decisions visible.
VP-02-022 SHOULD NOT Participants SHOULD NOT mark duplicate reports as invalid

A duplicate still describes a real vul. Marking it Invalid would tell its reporter, and every participant tracking the state, that the report was wrong, and would discard any new detail it carries.
VP-02-023 SHOULD A Participant SHOULD move a duplicate report through the RM Valid state.

Passing through Valid records that the duplicate describes a real vul, so the duplicate's reporter learns that the report was sound.
VP-02-036 MAY After a duplicate report reaches RM Valid, a Participant MAY defer it in favor of the original report.

Deferring a duplicate in favor of the first report of the same vul avoids working the vul twice, while the duplicate's reporter stays informed.
VP-02-024 SHOULD Vendors SHOULD communicate their prioritization choices when making either a defer or accept transition out of the Valid, Deferred, or Accepted states

Reporters and other participants plan around whether a vendor will act now or later. Stating the prioritization choice lets them adjust, for example by seeking a coordinator or different embargo terms, instead of guessing from silence.
VP-02-025 MAY Participants MAY perform a more technical report validation process before exiting the Received state

Some reports cannot be judged credible without reproducing or examining them. Allowing deeper technical checks before leaving Received keeps the Valid designation meaningful.
VP-02-026 MAY Participants MAY create a case object to track any report in the Received state

Some participants need a record of a report and its correspondence from the moment it arrives, for example to show response times. A case at Received gives them that record without forcing it on everyone.
VP-02-027 MAY Participants MAY set a timer to move reports from Invalid to Closed after a set period of inactivity

Invalid reports that receive no new information need no further work. A timer moves them to Closed so they do not pile up as open items, while still leaving the reporter a window to respond.
VP-02-028 MAY Participants MAY choose to perform a shallow technical analysis on Valid reports to prioritize further effort

Prioritization is better informed when the participant knows roughly how severe or widespread the vul is. A shallow analysis gives that without committing to full work.
VP-02-029 MAY A report MAY enter and exit the Accepted state a number of times as a Participant resumes or pauses work

Work on a report is often paused and resumed as priorities change. Allowing repeated entry into Accepted lets the RM state follow the real work instead of forcing a single pass.
VP-02-030 MAY A report MAY enter and exit the Deferred state a number of times as a Participant pauses or resumes work

Work on a report is often paused and resumed as priorities change. Allowing repeated entry into Deferred lets the RM state follow the real work instead of forcing a single pass.
VP-02-031 MAY CVD Participants MAY set a policy timer on reports in the Deferred state to ensure they are moved to Closed after a set period of inactivity

Deferred reports are easily forgotten. A policy timer moves them to Closed after inactivity, so open work lists reflect reality and other participants learn this participant has stopped work.
VP-02-032 MAY Participants MAY create a case for Invalid reports

A case for an invalid report keeps the decision and correspondence on record. That record helps if the report is later revalidated (VP-02-033) or a duplicate arrives.
VP-02-033 MAY Participants MAY periodically revalidate Invalid reports to determine if they have become Valid

A report judged Invalid may become valid as new information, product versions or exploitation evidence appears. Periodic revalidation stops an early wrong call from becoming permanent.
VP-02-034 MAY Participants MAY re-prioritize Accepted or Deferred cases

Priorities change as information arrives, such as exploitation evidence or newly affected products. Re-prioritizing lets a participant's work, and the RM state it announces, follow that change.
VP-02-035 MAY Participants MAY close Accepted or Deferred cases or Invalid reports

Accepted or deferred work ends, whether fixed, out of scope or abandoned, and invalid reports may need nothing more. Closing marks that end so other participants know no further action is coming from this participant.
RM Messaging
ID Priority Requirement Related
VP-03-001 MUST Participants MUST be in RM Accepted to send a Report Submission (\(RS\)) message to someone else

An \(RS\) hands a report to someone else and draws them into coordination. Requiring Accepted means only a participant that has committed to work on the report can pass it on, so reports are not forwarded by someone who has not judged them worth pursuing.
VP-03-002 MUST Vendor Recipients receiving a new Report Submission MUST transition their CVD Case State to Vendor Aware (\(q^{cs} \xrightarrow{\mathbf{V}} Vfd\cdots\))

Vendor awareness is the first CS event and starts the vendor's response timeline. If receiving a report did not set it, the case would understate what the vendor knows, and every later CS-based decision, including embargo eligibility and fix tracking, would start from a wrong state.
VP-03-003 SHOULD Participants SHOULD send \(RI\) when the report validation process ends in an invalid determination

The reporter and other participants need to know a report was judged invalid, so they can supply more detail or pursue other channels. Without \(RI\) they cannot tell an invalid finding from no response at all.
VP-03-004 SHOULD Participants SHOULD send \(RV\) when the report validation process ends in a valid determination

\(RV\) tells the reporter and other participants that the report is real and in scope. That is what lets them plan the next steps, such as embargo terms and fix timing.
VP-03-005 SHOULD Participants SHOULD send \(RD\) when the report prioritization process ends in a deferred decision

\(RD\) tells others that this participant will not work the report now. They can then adjust embargo expectations or seek another route instead of waiting.
VP-03-006 SHOULD Participants SHOULD send \(RA\) when the report prioritization process ends in an accept decision

\(RA\) tells others that this participant has committed to work on the report, which is what they need to plan fix and publication timing.
VP-03-007 SHOULD Participants SHOULD send \(RC\) when the report is closed

\(RC\) tells others this participant has stopped work. They stop expecting fixes or replies from it and can judge whether its exit affects the embargo.
VP-03-008 SHOULD A Participant that cannot process an \(R*\) message it receives SHOULD answer it with Create(ProcessingFault) (ASK-07-001), whatever its RM state. \(RE\) has no wire activity of its own (MSM-05-001).

A protocol message that cannot be processed otherwise fails silently. A processing fault in any state tells the sender something went wrong, so it can correct or ask instead of assuming the message took effect. Faults are grouped by failure mode, not by state machine, so no RM-specific error message exists. For an authenticated sender, ASK-07-001 makes the fault a MUST.
Refines: ASK-07-001
See also: MSM-05-001 — context for the reader
VP-03-009 SHOULD Recipients SHOULD acknowledge the \(R*\) messages they receive, other than \(RK\) itself. \(RK\) acknowledges only \(RS\): an addressee of the report's Offer sends it to the reporter (RMB-08-003). No other \(R*\) message is acknowledged with \(RK\); once a case exists, its acknowledgment is the CASE_MANAGER's ledger entry for it, fanned out to the participants.

Before a case exists there is no ledger, so the reporter learns that its report arrived only from an \(RK\) (RMB-08-003). Once a case exists, every \(R*\) message goes to the CASE_MANAGER (PCR-08-001), and the ledger entry it commits already tells every participant the message was received; a separate \(RK\) would only add traffic and a second acknowledgment that could disagree with the ledger.
VP-03-010 SHOULD Recipients who receive an \(R*\) message (other than \(RS\) and \(RE\)) while in RM Start (\(q^{rm} \in S\)) SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the recipient holds no report the message could be about. A received fault is never answered with a fault (ASK-07-019). \(RE\) has no wire activity of its own (MSM-05-001).

An \(R*\) message from a party the recipient has no report from means the two disagree about whether a report was sent. A fault lets the sender re-send the report. No \(RE\) message exists, because faults are grouped by failure mode (MSM-05-001). The rule is a SHOULD, not the MUST of ASK-07-001, because a recipient that understands the message can decline it with as:Reject instead (MSM-05-001). It never permits silence: a recipient that cannot process the message falls under ASK-07-001.
Refines: ASK-07-001
See also: MSM-05-001 — context for the reader
See also: ASK-07-019 — keeps a received fault out of this rule
VP-03-011 SHOULD Recipients of Create(ProcessingFault) about an \(R*\) message they sent (\(RE\)) SHOULD inquire (\(GI\)) as to the nature of the error. \(RE\) has no wire activity of its own (MSM-05-001). They do not acknowledge the fault with \(RK\) (VP-03-009).

A fault says something went wrong but not always what, so asking (\(GI\)) is how the two sides find and fix the problem. No \(RK\) is needed: \(RK\) acknowledges only \(RS\) (VP-03-009).
See also: MSM-05-001 — context for the reader
See also: VP-03-009 — context for the reader
VP-03-012 SHOULD Participants whose state changes in the RM, EM, or CVD Case State Models SHOULD send a message for each transition to the case's CASE_MANAGER, which fans it out to the other Participants (PCR-08-001, VP-18-002).

Each participant decides from its picture of the others' states (VP-01-001). Announcing every RM, EM and CS transition keeps those pictures current; an unannounced transition, such as a fix becoming ready, leaves others acting on stale information. Participants never message each other directly, so the CASE_MANAGER's fan-out is how the transition reaches them.
See also: PCR-08-001 — context for the reader
See also: VP-18-002 — context for the reader
VP-03-013 MAY A recipient MAY ignore any message it receives on a Closed case, whatever its class: RM (\(R*\)), EM, CS or general-inquiry (\(GI\)).

A closed case has no further work, so a recipient gains nothing by processing late traffic of any class. For the CASE_MANAGER, owner close is a hard kill switch, not a permission: after its own RM.CLOSED entry is committed it records no later inbound message for the case (CM-23-013). No principled line separates note-like traffic (\(GI\)) from state-changing traffic, so the boundary covers every message (ADR-0085).
Embargo Management (EM) Process
ID Priority Requirement Related
VP-04-001 MUST Every embargo that a Participant accepts MUST specify an end time (endTime).

An embargo with no end time never frees participants to publish, so it can keep a vul secret indefinitely and leave users exposed. A required end time also gives every participant the same date to plan releases around.
Refines: VP-05-001
VP-04-002 MUST A CVD case SHALL NOT have more than one active embargo at a time

Participants must know which terms bind them. Two active embargoes on one case would give conflicting end times, and nobody could say when publication is allowed.
VP-04-003 MAY An embargo MAY be proposed

An embargo is how participants agree to keep a vul private while fixes are prepared. Proposing one is how that agreement starts; without proposals participants could only disclose with no coordination window.
VP-04-004 MAY Once proposed, an embargo MAY be accepted or rejected

An embargo binds only those who agree to it. Letting a proposal be accepted or rejected makes that agreement explicit and lets a participant refuse terms it cannot meet.
VP-04-005 MAY Once an embargo is accepted, a Participant MAY propose a revision of it.

Circumstances change during a case: fixes slip, vendors join, exploitation appears. Revisions let participants change the terms without first ending the embargo and leaving a gap with no terms in force.
VP-04-006 MAY A proposed revision of an accepted embargo MAY be accepted or rejected.

A revision is a proposal like any other, so the case can take the new terms or keep the terms already in force.
Embargo Principles
ID Priority Requirement Related
VP-05-001 MUST An embargo SHALL specify an unambiguous date and time as its endpoint

Participants in different time zones and organizations must all stop withholding at the same moment. A date without a time, or a vague endpoint, lets them read the deadline differently and publish at different times.
VP-05-002 SHOULD NOT An embargo's end time SHOULD NOT fall more than one year (P1Y) after the date the embargo is accepted.

Long embargoes keep users exposed to a vul that attackers may find independently. A one-year ceiling bounds that exposure.
VP-05-021 SHOULD Not yet in the reference implementation (tracked by #5637)

An embargo that lasts more than 90 days (P90D) SHOULD carry a documented justification that all Participants agree to.

Requiring agreed justification beyond 90 days makes a long embargo a deliberate exception rather than a default, since a long embargo keeps users exposed.
VP-05-003 MUST An embargo SHALL begin at the moment it is accepted

Participants need to know from what moment they are bound. Starting the embargo at acceptance leaves no gap in which a participant has agreed but is not yet bound, and no future start that could be read as permission to disclose now.
VP-05-004 MUST Adding Participants to an existing embargo SHALL NOT constitute release or publication so long as those Participants accept the terms of the embargo

Cases often need new vendors or coordinators after an embargo is in place. If telling them counted as release, no one could be added without ending the embargo; requiring that they accept the terms keeps the information inside it.
VP-05-005 MUST Embargo termination SHALL NOT be construed as an obligation to publish

The end of an embargo only removes the duty to withhold. Reading it as a duty to publish would force participants who are not ready, or have nothing to say, to release information.
VP-05-006 SHOULD NOT Embargo Participants SHOULD NOT knowingly release information about an embargoed case until all proposed embargoes have been explicitly rejected, no proposed embargo has been explicitly accepted in a timely manner, the expiration date/time of an accepted embargo has passed, or an accepted embargo has been terminated prior to expiration

Releasing information while an embargo may still form or is still in force undermines the agreement other participants rely on, and can expose users before fixes exist. The listed conditions are the points at which no embargo binds the participant, so they are the only safe times to release knowingly.
VP-05-007 SHOULD Embargo participation SHOULD be limited to the smallest possible set of individuals and organizations needed to adequately address the vulnerability report

Every additional party is another chance of a leak. Keeping participation to those needed to fix or coordinate limits that risk.
VP-05-008 SHOULD Embargo duration SHOULD be limited to the shortest duration possible to adequately address the vulnerability report

While an embargo runs, users remain unaware of a vul that attackers may also find. Keeping it as short as the work allows limits that exposure.
VP-05-009 SHOULD Embargoes SHOULD be of short duration, from a few days to a few months

Long embargoes raise the chance of independent discovery and exploitation while users have no information. Days to months is long enough for most fix work and short enough to bound that risk.
VP-05-010 SHOULD Participants stopping work on a case SHOULD notify remaining Participants of their intent to adhere to or disregard any existing embargo associated with the case

Remaining participants need to know whether a departing participant will keep the information private. That tells them whether the embargo still holds or must be revisited.
VP-05-011 SHOULD Participants SHOULD continue to comply with any active embargoes to which they have been a party, even if they stop work on the case

Information received under an embargo stays sensitive after a participant stops work. If leaving freed it to disclose, any participant could end the embargo for everyone by stepping away.
VP-05-012 SHOULD A Participant that leaves an Active embargo SHOULD be dropped by the CASE_MANAGER from its fan-out of further communication about the case (CM-10-004).

A participant that has left an active embargo is not bound to keep new information private. Continuing to send it case updates would leak information outside the embargo. The other participants send it nothing directly (PCR-08-001, VP-18-002), so only the CASE_MANAGER's fan-out can drop it.
Refines: CM-10-004
VP-05-013 SHOULD Participants SHOULD consider other Participants' history of cooperation when evaluating the terms of a proposed embargo

A participant's record of keeping or breaking past embargoes is the best guide to whether it will keep this one. Considering it lets participants set terms, or decline, according to the actual risk.
VP-05-014 SHOULD NOT Participants SHOULD NOT publish information about the vulnerability when there is an active embargo

Publishing while an embargo is active breaks the agreement other participants rely on and can expose users before fixes are ready.
VP-05-015 MAY Additional Participants MAY be added to an existing embargo upon accepting the terms of that embargo

Affected vendors and needed coordinators are often found after an embargo starts. Letting newcomers join by accepting the terms brings them in without renegotiating or ending the embargo.
VP-05-016 MAY Participants MAY propose a new embargo or revision to an existing embargo at any time within the constraints outlined in the Negotiating Embargoes guidance

Needs change as a case develops. Allowing proposals at any time, within the negotiation guidance, lets participants adjust the embargo when they learn something new.
VP-05-017 MAY Participants MAY reject proposed embargo terms for any reason

An embargo binds only participants who agree. A participant must be free to refuse terms it cannot keep, rather than be held to terms it never accepted.
VP-05-018 MAY Participants in an embargo MAY exit the embargo at any time

Embargo participation is voluntary. A participant that cannot or will not keep an embargo does less harm by saying so and leaving than by staying in and breaking it.
VP-05-019 MAY A Participant's refusal to accept embargo terms MAY result in that Participant being left out of the CVD case entirely

Sharing a vul with someone who has not agreed to keep it private puts the embargo at risk for everyone. Leaving out a participant that refuses the terms protects the others.
VP-05-020 MAY Participants MAY publish information about the vulnerability when there is no active embargo

With no active embargo there is no agreement to withhold, and users benefit from learning about the vul. Participants need clear permission to publish then.
Embargo Negotiation
ID Priority Requirement Related
VP-06-001 MUST NOT CVD Participants MUST NOT propose or accept a new embargo negotiation when information about the vulnerability is already known to the public (\(q^{cs} \in \cdots P \cdots\)), an exploit is publicly available (\(q^{cs} \in \cdots X \cdot\)), or the vulnerability is being actively exploited (\(q^{cs} \in \cdots A\))

Once the vul is public, an exploit is public, or attacks are under way, secrecy protects no one: attackers already have what they need and defenders need the information. An embargo at that point only delays defenders.
VP-06-002 SHOULD NOT CVD Participants SHOULD NOT propose or accept a new embargo when the fix for a vulnerability has already been deployed (\(q^{cs} \in VFDpxa\))

Once the fix is deployed there is nothing left to prepare in private. A new embargo would only delay telling users about a vul they are already protected against.
VP-06-003 SHOULD A Receiver that cannot accept a Reporter's proposed embargo as proposed SHOULD propose terms it can accept (VP-06-011) rather than reject the proposal outright.

Reporters hold the vul and can disclose it on their own. A counter-proposal keeps them in the coordinated process and keeps the negotiation open; an outright refusal risks the reporter publishing without coordination. The Receiver still need not accept terms it cannot keep (VP-06-010), and VP-07-004 already answers a proposal longer than its default with a counter-proposal of that default.
Refines: VP-06-011
VP-06-004 SHOULD Participants SHOULD explicitly accept or reject embargo proposals within the period defined in their VDP or within 14 calendar days of receipt, whichever is shorter.

An open proposal leaves everyone unsure whether information may be shared. A bounded reply time, never more than 14 days, makes the outcome known soon enough for participants to plan.
VP-06-004b SHOULD NOT Embargo agreement or rejection SHOULD NOT be tacit.

Silence can be read as either yes or no, so a tacit answer leaves participants disagreeing about whether an embargo binds them. An explicit answer gives them all the same record.
Derives from: VP-06-004
VP-06-005 SHOULD Participants SHOULD make reasonable attempts to retry embargo negotiations when prior proposals have been rejected or otherwise failed to achieve acceptance

A case without an embargo leaves users exposed and fixes unprepared at disclosure. Retrying after a failed proposal gives coordination another chance before participants fall back to no embargo.
VP-06-006 SHOULD Participants SHOULD remain flexible in adjusting embargo terms as the case evolves

Fix timelines, affected vendors and threat conditions change during a case. Terms that cannot adjust either expire before fixes are ready or keep holding after the need for them has passed.
VP-06-007 MUST Submitting a report when an embargo proposal is pending (\(q^{em} \in P\)) SHALL be construed as the Sender's acceptance of the proposed terms

Sending the report while a proposal is pending shows the sender is willing to share under those terms. Treating the submission as acceptance avoids a report being shared with no embargo in force.
VP-06-008 MAY When \(q^{cs} \in VFdpxa\), CVD Participants MAY propose or accept a new embargo that prepares for timely publication or deployment (VP-06-008b). This is the one exception to VP-14-007.

With a fix ready but not deployed, a short window can still help users by letting participants line up publication and deployment. Fix Ready otherwise ends embargo negotiation (VP-14-007), so this one purpose is named as the exception, allowed here though not required.
Supersedes: VP-14-007
VP-06-008b SHOULD Any embargo accepted when \(q^{cs} \in VFdpxa\) SHOULD be brief and used only to allow Participants to prepare for timely publication or deployment.

At this point only release preparation remains. A long embargo would delay the deployment of a fix that already exists.
Constrains: VP-06-008
VP-06-009 MAY CVD Participants MAY propose or accept an embargo in all other case states (\(q^{cs} \in \cdots pxa\))

Before the fix is ready, and while nothing is public or exploited, an embargo is what gives vendors time to prepare fixes in private. This is the case the EM process exists for.
VP-06-010 MAY Participants MAY accept or reject any proposed embargo as they see fit

An embargo binds only those who agree. Each participant knows its own ability to keep the terms and must be free to accept or refuse.
VP-06-011 MAY Receivers MAY propose embargo terms they find more favorable

The receiver may need more or less time than the reporter suggested. A counter-proposal lets it say so while keeping the negotiation going, rather than rejecting outright.
VP-06-012 MAY Participants MAY withdraw their own unaccepted Proposed embargo

A proposer may learn that its proposal does not fit the case after all. Withdrawing it before acceptance stops others from accepting terms the proposer has stopped supporting.
VP-06-013 MAY Participants MAY interpret another Participant's failure to respond to an embargo proposal in a timely manner as a rejection of that proposal

A proposer cannot wait forever for an answer. Reading silence as rejection lets it move on (VP-06-014) instead of being stuck undecided while the vul stays unaddressed.
VP-06-014 MAY In the absence of an explicit accept or reject response from a Receiver in a timely manner, the Sender MAY proceed consistent with an EM state of None (\(q^{em} \in N\))

Without an answer, no embargo binds the receiver, so the sender may act as if none exists. That stops an unresponsive party from blocking the sender indefinitely.
VP-06-015 MAY In a case where the EM state is None and for which an embargo has been proposed and either explicitly or tacitly rejected, Participants MAY take any action they choose with the report, including immediate publication

When negotiation has failed, there is no agreement to keep the information private. Participants then need to be free to act in users' interest, which may mean publishing.
VP-06-016 MAY Participants MAY withhold a report from a Recipient until an initial embargo has been accepted

A recipient given the report before agreeing to an embargo is free to disclose it. Waiting for acceptance protects the information.
VP-06-017 MAY Participants MAY use short embargoes to cover their report validation process and subsequently revise the embargo terms pending the outcome of their validation or prioritization processes

A recipient often cannot judge how much time it needs until it has validated the report. A short initial embargo protects the report meanwhile and can be revised once the needs are known.
Embargo Default Policies
ID Priority Requirement Related
VP-07-001 MUST If neither Sender nor Receiver proposes an embargo and no actor default applies, the protocol default embargo of EP-04-005 SHALL apply.

A case with no embargo leaves the vul unprotected, and reaching that state only because nobody proposed terms is the least deliberate way to get there. A bounded protocol default gives every eligible case protection.
Uses definition from: EP-04-005
VP-07-014 MUST A case SHALL have no embargo only where it is not embargo-eligible, that is where any of P/X/A is set (EP-04-008).

A case where the vul is already public, exploited or attacked gains nothing from secrecy, so only there does no embargo exist. Every other case has an embargo, if only the protocol default (VP-07-001).
Derives from: VP-07-001
Uses definition from: EP-04-008
VP-07-002 MUST A Receiver's default embargo specified in its vulnerability disclosure policy SHALL be treated as an initial embargo proposal

A published default tells reporters what to expect. Treating it as a proposal makes it a real negotiating position without either side having to send a first message.
VP-07-003 MUST If the Receiver has declared a default embargo in its vulnerability disclosure policy and the Sender proposes nothing to the contrary, the Receiver's default embargo SHALL be considered as an accepted proposal

A sender that knows the receiver's published default and offers nothing else has agreed to it in effect. Treating it as accepted puts an embargo in force at once, rather than leaving the case unprotected while waiting for a formal reply.
VP-07-004 MUST If the Sender proposes an embargo longer than the Receiver's default, the Receiver's default SHALL be taken as accepted and the Sender's proposal taken as a proposed revision

The receiver's shorter default is acceptable to both sides: the receiver published it and the sender asked for at least that much time. Accepting it puts an embargo in force at once, and the longer request stays open as a revision.
VP-07-005 MUST If the Sender proposes an embargo shorter than the Receiver's default, the Sender's proposal SHALL be taken as accepted and the Receiver's default taken as a proposed revision

The sender's shorter proposal is acceptable to both sides: the sender asked for it and the receiver's default allows at least that much time. Accepting it puts an embargo in force at once, and the receiver's longer default stays open as a revision.
VP-07-006 SHOULD Report Recipients SHOULD post a default embargo as part of their Vulnerability Disclosure Policy to set expectations with potential Reporters

Reporters decide how and whether to report based on what they expect. A published default tells them how long they will be asked to wait, and gives VP-07-002 a default to apply.
VP-07-007 SHOULD If the Sender proposes an embargo and the Receiver has no default embargo specified by policy, the Receiver SHOULD accept the Sender's proposal

With no default of its own, the receiver has no stated reason to refuse. Accepting the sender's proposal puts an embargo in force at once and keeps the reporter in the coordinated process.
VP-07-008 SHOULD When two or more embargo proposals are open and no embargo has yet been accepted (\(q^{em} \in P\)), Participants SHOULD accept the shortest one and propose the remainder as revisions

The shortest open proposal is acceptable to every proposer, since each asked for at least that much time. Accepting it puts an embargo in force at once, and treating the rest as revisions keeps the longer requests under discussion.
VP-07-009 SHOULD When two or more embargo revisions are open and an embargo is active (\(q^{em} \in R\)), Participants SHOULD accept or reject them individually in earliest-to-latest expiration order

Open revisions with different end times interact: accepting a later one first can make an earlier one meaningless. Deciding them in expiration order lets each be judged against the terms actually in force.
VP-07-010 MAY Participants MAY include a default embargo as part of a published Vulnerability Disclosure Policy

A published default sets reporters' expectations and lets VP-07-002 apply. Keeping it optional leaves the protocol usable by participants who negotiate case by case.
VP-07-011 MAY When the Receiver has no default, the Receiver MAY propose a revision after accepting the Sender's proposal

Accepting the sender's proposal secures protection at once, but the receiver may need different terms once it knows more. A later revision lets it ask without leaving the case unprotected.
VP-07-012 MAY When the Sender proposes longer than the Receiver's default, the Receiver MAY accept or reject the proposed extension

The sender's longer request is a proposed revision, not an obligation (VP-07-004). The receiver judges whether the extra time is justified.
VP-07-013 MAY When the Sender proposes shorter than the Receiver's default, the Sender MAY accept or reject the Receiver's proposed revision

The receiver's longer default is a proposed revision (VP-07-005), and the sender is not bound by it. The sender judges whether the extra time is acceptable.
Multi-Party Coordination
ID Priority Requirement Related
VP-08-001 MUST When inviting a new Participant to a case with an existing embargo, the inviting Participant SHALL propose the existing embargo to the invited Participant

A newcomer must know which embargo binds the case before it sees case information. Proposing the existing embargo is how it learns the terms and is asked to keep them.
VP-08-002 SHOULD Participants SHOULD attempt to establish an embargo as early in the process of handling the case as possible

Information shared before an embargo is in place is unprotected. Establishing one early limits how much is shared without any agreement.
VP-08-003 SHOULD Participants SHOULD follow consensus agreement to decide embargo terms

In an MPCVD case each participant must be able to keep the terms. Terms set without broad agreement risk being broken by participants who could never meet them.
VP-08-004 SHOULD All known Vendors of affected software SHOULD be included as Participants

A vendor left out of the case cannot prepare a fix, so its users are exposed at publication. Including every known affected vendor lets all fixes be ready together.
VP-08-005 SHOULD A newly invited Participant to a case with an existing embargo SHOULD accept the existing embargo

The existing participants agreed the terms around their own work. A newcomer that accepts them joins without forcing a renegotiation, and can still propose a revision afterwards (VP-08-016).
VP-08-006 SHOULD NOT The inviting Participant SHOULD NOT share the vulnerability report with a newly invited Participant unless the new Participant has accepted the existing embargo

Sharing the report with a participant that has not agreed to keep it private puts the whole case at risk of an uncoordinated release.
VP-08-007 SHOULD Participants with short default embargo policies SHOULD consider accepting longer embargoes in MPCVD cases

In an MPCVD case the slowest vendor sets when all affected users can have a fix. A participant whose own policy is short may need to accept more time so others can finish.
VP-08-008 SHOULD Potential Participants with a longer default policy than an existing case SHOULD accept the embargo terms offered

The existing terms were set around the existing participants' work. A newcomer that insists on its own longer default could hold them up, so it accepts the case's terms and seeks a revision if needed.
VP-08-009 SHOULD Participants in a case with an existing embargo SHOULD notify Vendors with a longer default embargo policy

A vendor with a longer default policy may not be able to meet the existing embargo. Notifying it lets it start work, or ask for a revision, before the deadline instead of being surprised at publication.
VP-08-010 SHOULD Participants known to leak or provide vulnerability information to adversaries as a matter of policy or historical fact SHOULD be treated similar to Participants with brief disclosure policies

A participant known to leak behaves, in effect, like one that will disclose early. Treating it that way keeps others from sharing more with it than they would with a party that publishes quickly.
VP-08-011 MAY When consensus fails to reach agreement on embargo terms, Participants MAY appoint a case lead to resolve conflicts

Consensus can fail, and a case cannot wait indefinitely for terms. A case lead gives the participants a way to reach a decision.
VP-08-012 MAY Participants MAY engage a third-party Coordinator to act as a neutral case lead to resolve conflicts between Participants

When participants disagree, a party with no product at stake can judge the dispute fairly. A third-party Coordinator offers that neutrality.
VP-08-013 MAY Third-party Coordinators MAY be included as Participants

Coordinators bring contacts, experience and neutrality that help complex cases. Allowing them as participants lets them take part directly rather than from outside.
VP-08-014 MAY Other parties MAY be included as Participants when necessary and appropriate

Some cases need parties beyond vendors and reporters, such as service providers, government agencies or large deployers. Allowing them when needed lets the case include everyone who can reduce harm.
VP-08-015 MAY The inviting Participant MAY interpret a potential Participant's default embargo policy in accordance with default acceptance strategies

A potential participant's published default tells the inviter how it is likely to respond. Applying the default acceptance strategies (VP-07) lets the inviter predict the outcome and propose suitable terms.
VP-08-016 MAY A newly invited Participant MAY propose a revision after accepting the existing embargo

Accepting first secures the newcomer's protection and the case's information. A later revision still lets it ask for terms that fit its needs.
VP-08-017 MAY Participants in an MPCVD case MAY delay notifying potential Participants with short default embargo policies until their policy aligns with the agreed embargo

A participant whose policy would end the embargo early could publish before others are ready. Delaying its notification until its policy fits the agreed embargo reduces that risk.
VP-08-018 MAY After accepting an existing embargo, newly invited Participants with a longer default policy MAY propose a revision to accommodate their preferences

The newcomer may need more time than the existing embargo gives. Proposing a revision after accepting lets it ask while the case stays protected.
VP-08-019 MAY Existing Participants MAY accept or reject a proposed revision from a newly invited Participant

The existing terms were set around the existing participants' work. They must be free to decide whether a newcomer's request suits them.
VP-08-020 MAY Participants in a case with an existing embargo MAY choose to extend the embargo to accommodate a newly added Participant

A newly added vendor may need more time to prepare a fix. Extending the embargo lets its users also be protected at publication.
VP-08-021 MAY Participants MAY decline to participate in future CVD cases involving parties with a history of violating previous embargoes

A party that has broken embargoes before is likely to do so again. Declining to work with it protects future cases from that risk.
Embargo Early Termination
ID Priority Requirement Related
VP-09-001 MUST Embargoes SHALL terminate immediately when information about the vulnerability becomes public (\(q^{cs} \in \{\cdots P \cdots, \cdots X \cdot\}\))

Once the vul or its exploit is public, secrecy protects no one: attackers already have the information and defenders need it. Holding to the embargo would only stop participants from helping users respond.
VP-09-002 SHOULD Participants SHOULD be prepared with contingency plans in the event of early embargo termination

Leaks, exploit publication and attacks can end an embargo at any time. A participant with no plan for that moment cannot publish advice or fixes quickly, which leaves users exposed.
VP-09-003 SHOULD Embargoes SHOULD terminate immediately when there is evidence that the vulnerability is being actively exploited by adversaries (\(q^{cs} \in \{\cdots A\}\))

Active exploitation means users are being harmed now and defenders need information to respond. Keeping the embargo, or delaying the teardown, would only preserve the attackers' advantage.
VP-09-004 SHOULD Embargoes SHOULD terminate early when there is evidence that adversaries possess exploit code for the vulnerability

Adversaries holding exploit code can attack at any time. Ending the embargo early lets defenders get information and mitigations before attacks spread.
VP-09-005 SHOULD Participants SHOULD consider the software supply chain when determining an appropriate quorum of Vendors for release

Downstream vendors build on upstream components and often cannot ship fixes until those are released. A quorum that ignores the supply chain could trigger release while many affected users still have no fix available.
VP-09-006 MAY Embargoes MAY terminate early when there is evidence that adversaries are aware of the technical details of the vulnerability

If adversaries already know the technical details, secrecy stops buying defenders time. Participants may then end the embargo so defenders can act.
VP-09-007 MAY Embargoes MAY terminate early when a quorum of Vendor Participants is prepared to release fixes (\(q^{cs} \in VF\cdots\)), even if some Vendors remain unprepared

'Quorum' is intentionally left undefined at the protocol level. Different CVD communities may adopt different decision rules (simple majority by count, weighted by deployed-user impact, unanimity, etc.). This requirement marks an expansion point for future community-specific behavioral norms rather than prescribing a single rule.
Embargo Case Splits and Merges
ID Priority Requirement Related
VP-10-001 MUST If no new embargo has been proposed or agreement has not been reached following a case merge, the earliest of the previously accepted embargo dates SHALL be adopted for the merged case

Each merged case brought an embargo some participants had already agreed to. Adopting the earliest end time breaks no participant's commitment, since none agreed to withhold past its own date, until a new agreement is reached.
VP-10-002 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

If a child case following a case split requires an embargo end time earlier than the inherited date, the CASE_MANAGER of that child case SHALL notify the CASE_MANAGERs of all sibling child cases before the earlier end time takes effect, documenting the rationale in the case ledger.

Child cases from one split share the same vul information, so an earlier end in one child in effect ends the embargo for its siblings too. Notifying the siblings' CASE_MANAGERs before it takes effect, with the reason on the ledger, gives their participants time to prepare and to see why.
VP-10-003 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

Participants in a child case SHALL communicate any subsequently agreed changes from the inherited embargo to the Participants of the other child cases

Child cases share information that came from one parent. A change agreed in one child can change what the others may safely disclose and when, so their participants must learn of it.
VP-10-004 SHOULD A new embargo SHOULD be proposed when any two or more CVD cases are to be merged and multiple parties have agreed to different embargo terms prior to the merger

Participants of the merging cases agreed to different terms, and no single set binds all of them. A new proposal lets everyone agree to one set.
VP-10-005 SHOULD Not yet in the reference implementation (tracked by #4241 and #4242)

When a case is split into two or more parts, any existing embargo SHOULD transfer to the new cases

The information in each new case was shared under the parent's embargo. Carrying the embargo over keeps it protected on terms everyone already agreed to.
VP-10-006 SHOULD If any of the new cases need to renegotiate the embargo inherited from the parent case, any new embargo SHOULD be later than the inherited embargo

The information in a child case is also held in its siblings. An earlier end in one child could expose the others before they are ready, so renegotiated terms should only extend the inherited date.
VP-10-007 MAY Participants MAY propose revisions to the embargo on a merged case as usual

A merged case is still a case, and its work keeps changing. Participants need the usual way to adjust its terms.
VP-10-008 MAY Participants approaching a case split MAY engage a Coordinator to act as a trusted third party to help resolve and coordinate embargo dependencies for the new cases

Splitting a case creates embargo dependencies between the new cases that their participants may not each see. A trusted third party who can see all of them can keep them consistent.
EM Messaging
ID Priority Requirement Related
VP-11-002 MUST When the vulnerability or an exploit is public, the authority to terminate the case-level embargo SHALL belong to the Case Owner (CM-02-005). Public here means \(q^{cs} \in \{\cdots P \cdots, \cdots X \cdot\}\).

Once the vul or an exploit is public, the embargo must end (VP-09-001). Separating who reports the condition (VP-11-003) from who ends the embargo keeps one authoritative decision, made by the Case Owner and recorded by the CASE_MANAGER (VP-11-011), so participants never disagree about whether the embargo still holds.
Refines: CM-02-005
VP-11-003 MUST Participants SHALL initiate embargo termination upon becoming aware of publicly available information about the vulnerability or its exploit code

Other participants may not have seen the public information. Initiating termination makes sure the case learns of it and the embargo ends promptly.
VP-11-004 SHOULD Recipients SHOULD acknowledge the \(E*\) messages they receive. Once a case exists, the acknowledgment (\(EK\)) is the CASE_MANAGER's ledger entry for the message, fanned out to the participants as Add(CaseLedgerEntry); no \(EK\) message exists (EP-09-009).

An embargo message changes what participants may disclose. Acknowledging it tells the sender it arrived, so silence is not mistaken for agreement or for a lost message. Every \(E*\) message goes to the CASE_MANAGER (EP-09), and the ledger entry it commits already tells every participant the message was received; a separate \(EK\) message would only add traffic and a second acknowledgment that could disagree with the ledger.
Uses definition from: EP-09-009
VP-11-005 SHOULD Recipients of Create(ProcessingFault) about an \(E*\) message they sent (\(EE\)) SHOULD inquire (\(GI\)) as to the nature of the error. \(EE\) has no wire activity of its own (MSM-05-001). No \(EK\) message is sent for the fault (EP-09-009).

A fault about an embargo message means the other side could not process it, so the two may now hold different embargo states. Asking what went wrong lets them find and fix the mismatch. No \(EK\) message exists to acknowledge the fault with (EP-09-009).
Uses definition from: EP-09-009
See also: MSM-05-001 — context for the reader
VP-11-006 MUST When attacks are known to have occurred (\(q^{cs} \in \cdots A\)), the authority to terminate the case-level embargo SHALL belong to the Case Owner (CM-02-005).

Known attacks mean the embargo should end (VP-09-003). As with VP-11-002, one party holds the authority to end it, so participants never disagree about whether it still holds. The Case Owner may delegate this decision in advance, for example by configuring CaseOwnerApprovesStatusUpdate to approve reported attacks automatically (RSH-07-003), which then also ends the embargo (ADR-0210). The decision is made ahead of time, and the authority stays with the Case Owner.
Refines: CM-02-005
VP-11-007 SHOULD Participants SHOULD initiate embargo termination upon becoming aware of attacks against an otherwise unpublished vulnerability

Others in the case may not know about the attacks. Initiating termination makes sure the case learns of them and can end the embargo.
VP-11-008 SHOULD If early embargo termination is desired but the termination date/time is in the future, this SHOULD be achieved through an Embargo Revision Proposal and additional communication

Participants must keep the existing terms until the new end time arrives. A revision proposal changes the end time through the usual agreement process, rather than leaving participants unsure whether the embargo still holds.
VP-11-009 MAY Participants MAY begin embargo negotiations before sending the report itself in an \(RS\) message; therefore it is not an error for an \(E*\) message to arrive while the Recipient is unaware of the report (\(q^{rm} \in S\))

Negotiating before sending the report lets the sender protect it from the moment it is shared. Treating an early \(E*\) as an error would block that.
VP-11-010 MAY Participants MAY reject any embargo proposals or revisions for any reason

An embargo binds only those who agree. Participants must be free to refuse proposals or revisions they cannot keep.
VP-11-011 MUST The CASE_MANAGER SHALL effect the teardown of a case-level embargo that the Case Owner terminates (VP-11-002, VP-11-006). It is the single writer of canonical case state (EMB-19-001).

One writer of case state means every participant sees the same teardown in the same place in the ledger. The Case Owner decides; the CASE_MANAGER records and announces the decision.
Extends: VP-11-002
Extends: VP-11-006
See also: EMB-19-001 — context for the reader
VP-11-012 MUST NOT A Participant other than the authorising Case Owner SHALL NOT terminate the case-level embargo itself. It can initiate termination (VP-11-003, VP-11-007) and end its own compliance (VP-13-017).

If any participant could end the case-level embargo, participants could disagree about whether it still holds. Initiating termination and ending one's own compliance let a participant act on what it knows without overriding the Case Owner (VP-11-002).
See also: VP-11-003 — context for the reader
See also: VP-11-007 — context for the reader
See also: VP-13-017 — context for the reader
CVD Case State (CS) Messaging
ID Priority Requirement Related
VP-12-001 SHOULD Vendor Awareness (\(CV\)) messages SHOULD be sent only by Participants with direct knowledge of the notification (i.e., either the Participant who sent the report to the Vendor or the Vendor upon receipt of the report)

Only those who took part in the notification know for certain that the vendor was told. Restricting \(CV\) to them stops second-hand reports from marking a vendor aware when it was not.
Constrains: CSB-09-002
VP-12-002 SHOULD Once attacks are observed (\(q^{cs} \in \cdots A\)), fix development SHOULD accelerate.

Attacks mean users are being harmed while no fix exists. Speeding fix development shortens that harm.
VP-12-002c SHOULD Once attacks are observed (\(q^{cs} \in \cdots A\)), publication and deployment SHOULD follow as soon as is practical.

While attacks continue, every day without published advice or a deployed fix leaves users harmed. Publishing and deploying as soon as practical shortens that harm.
Extends: VP-12-002
RM-EM Interactions
ID Priority Requirement Related
VP-13-001 SHOULD The EM process SHOULD begin when a recipient is in RM Received (\(q^{rm} \in R\)) whenever possible

Received is the earliest point at which the recipient holds the report. Starting embargo work there protects the report before validation, rather than after information may already have been shared.
VP-13-002 SHOULD NOT Embargo Management SHOULD NOT begin in an inactive RM state (\(q^{rm} \in \{I, D, C\}\))

Invalid, Deferred and Closed mean the participant is not working on the report. Starting an embargo from those states would bind others to a timeline nobody is working toward.
VP-13-003 SHOULD NOT Embargo Management SHOULD NOT begin with a proposal from a Participant in RM Invalid (\(q^{rm} \in I\))

A participant that judged the report invalid does not believe there is a real vul to protect. A proposal from it would ask others to withhold information about something it does not think needs fixing.
VP-13-004 SHOULD NOT Embargo Management SHOULD NOT proceed from EM Proposed to EM Accepted when RM is Invalid or Closed (\(q^{rm} \in \{I, C\}\))

An Invalid or Closed participant is not working on the report. Agreeing to an embargo then would commit it to terms it has no intent to work toward.
VP-13-005 SHOULD NOT Participants SHOULD NOT close reports (\(q^{rm} \in \{R,I,D,A\} \xrightarrow{c} C\)) while an embargo is active (\(q^{em} \in \{A, R\}\))

A participant that closes may stop watching the case and lose track of its obligations. Keeping the report open while the embargo runs keeps the participant aware of the embargo until it ends.
Constrains: RMB-11-004
VP-13-006 SHOULD Reports with no further tasks SHOULD be held in Deferred or Invalid (\(q^{rm} \in \{D, I\}\)) until the embargo has terminated (\(q^{em} \in X\))

Holding the report in Deferred or Invalid keeps the participant attached to the case, and aware of the embargo, until the embargo ends, without claiming any further work.
VP-13-007 SHOULD Participants who choose to close a report while an embargo remains in force SHOULD communicate their intent to either continue to adhere to the embargo or terminate their compliance with it

Remaining participants need to know whether someone who closed will still keep the information private. That tells them whether the embargo still holds.
VP-13-008 SHOULD Any changes to a Participant's intention to adhere to an active embargo SHOULD be communicated clearly in addition to any necessary RM or EM state change notifications

An RM or EM state change does not say whether the participant will keep the embargo. Saying so clearly stops others from relying on a commitment that has changed.
VP-13-009 MUST A Participant's closure or deferral (\(q^{rm} \in \{C, D\}\)) of a report while an embargo remains active (\(q^{em} \in \{A, R\}\)) and while other Participants remain engaged SHALL NOT automatically terminate the embargo

One participant's exit must not end protection for those still working on fixes. Otherwise any participant could end the embargo for everyone by closing or deferring.
VP-13-010 MAY The EM process MAY begin prior to the report being sent to a potential Participant (\(q^{rm} \in S\))

Negotiating before sending the report lets the sender protect it from the moment it is shared (VP-11-009).
VP-13-011 MAY Embargo Management MAY begin in any of the active RM states (\(q^{rm} \in \{R, V, A\}\))

In the active RM states the participant is working on the report. Allowing the embargo to start in any of them keeps protection timely without waiting for a later step.
VP-13-012 MAY Embargo Management MAY run in parallel to validation (\(q^{rm} \in \{R,I\} \xrightarrow{\{v,i\}} \{V,I\}\)) and prioritization (\(q^{rm} \in V \xrightarrow{\{a,d\}} \{A,D\}\)) activities

Validation and prioritization can take time. Running embargo work alongside them protects the report while those decisions are made.
VP-13-013 MAY EM revision proposals and acceptance or rejection of those proposals MAY occur during any of the valid yet unclosed RM states (\(q^{rm} \in \{V, A, D\}\))

Valid, Accepted and Deferred participants still have a stake in the report. Allowing revisions then lets the embargo follow changes in the work.
VP-13-014 MAY Outstanding embargo negotiations (\(q^{em} \in P\)) MAY continue in RM Invalid (\(q^{rm} \in I\)) if additional information may be forthcoming to promote the report from Invalid to Valid

An Invalid report may become valid with more information (VP-02-033). Keeping the negotiation open protects the report until that is known.
VP-13-015 MAY Embargo Management MAY proceed from EM Proposed to EM Accepted when RM is neither Invalid nor Closed (\(q^{rm} \in \{R, V, A, D\}\))

In these RM states the participant holds the report and is not done with it, so agreeing to an embargo protects real ongoing work.
VP-13-016 MAY Embargo Management MAY proceed from EM Proposed to EM None (\(q^{em} \in P \xrightarrow{r} N\)) when RM is Invalid or Closed

An Invalid or Closed participant has no ongoing work to protect, so letting the proposal fall back to no embargo matches its position.
VP-13-017 MAY Participants MAY choose to terminate their compliance with an embargo at any time

Embargo participation is voluntary, and a participant may become unable to keep the terms. Ending its own compliance openly does less harm than staying in and breaking them, and does not end the embargo for others (VP-13-009).
VP-13-018 MAY When a Participant receives another Participant's notice that it intends to end its compliance with an embargo, it MAY end its own compliance (VP-13-017).

When one participant will stop keeping the embargo, others may judge that it has stopped protecting them. Letting them end their own compliance lets the case respond without any participant acting beyond its own authority.
Refines: VP-13-017
VP-13-019 MAY When a Participant gives notice that it intends to end its embargo compliance, the Case Owner MAY terminate the case-level embargo (CM-02-005). The CASE_MANAGER then carries out the termination (EMB-19-001).

One participant leaving the embargo may leave it protecting no one. Terminating the case-level embargo is the Case Owner's authority, so the Case Owner decides, and the CASE_MANAGER, the single writer of case state, carries it out.
Refines: CM-02-005
See also: EMB-19-001 — context for the reader
RM-EM-CS Interactions
ID Priority Requirement Related
VP-14-004 MUST Participants MUST treat attacks as an event that could occur at any time and adapt their process as needed in light of available information

Attacks can start before, during or after an embargo, without warning. A process that assumes they will not leaves users unprotected when they do.
VP-14-005 SHOULD Once a case has reached Vendor Aware (\(q^{cs} \in Vfdpxa\)) for at least one Vendor, if the EM process has not started, it SHOULD begin as soon as possible

Once a vendor knows, information about the vul is spreading among parties. Starting the EM process then keeps it from spreading further without an agreement.
VP-14-006 SHOULD Any proposed embargo SHOULD be decided (accept or reject) soon after the first Vendor is notified

An undecided proposal leaves the notified vendor unsure whether it may share the information. A quick decision gives it clear terms to work under.
VP-14-007 SHOULD NOT Once a case reaches Fix Ready (\(q^{cs} \in VF\cdot pxa\)), Participants SHOULD NOT start a new embargo negotiation and SHOULD reject a pending proposal. The one exception is a brief embargo to prepare for publication or deployment (VP-06-008, VP-06-008b).

With a fix ready, the remaining work is release. A new or pending embargo would only delay getting the fix to users, unless it is the short window that lines that release up.
See also: VP-06-008b — names the bound on the exception; the exception itself is VP-06-008, which records supersedes
VP-14-008 SHOULD Existing embargoes (\(q^{em} \in \{Active, Revise\}\)) when Fix Ready is reached SHOULD prepare to terminate soon

With a fix ready, most of the reason for the embargo is gone. Preparing to end it lets participants release quickly.
VP-14-009 SHOULD Participants SHOULD accept reasonable extension proposals to allow trailing Vendors to catch up before publication when possible

Publishing before all vendors are ready leaves the trailing vendors' users exposed. A reasonable extension can let everyone release together.
VP-14-010 SHOULD NOT Once a fix has been deployed (\(q^{cs} \in VFD\cdots\)), a Participant SHOULD NOT seek a new embargo.

After the fix is deployed there is nothing left to protect by secrecy, so a new embargo only delays user awareness.
VP-14-015 SHOULD Once a fix has been deployed (\(q^{cs} \in VFD\cdots\)), any existing embargo SHOULD terminate.

After the fix is deployed there is nothing left to protect by secrecy, so a continuing embargo only delays user awareness.
VP-14-011 SHOULD Exploit Publishers who are Participants in pre-public CVD cases (\(q^{cs} \in \cdots p \cdots\)) SHOULD comply with the protocol, especially when they also fulfill other roles (e.g., Reporter, Coordinator, Vendor)

An Exploit Publisher in a pre-public case knows about the vul before the public. If it ignores the protocol, especially while also acting as Reporter, Coordinator or Vendor, it can make the vul public before fixes are ready.
VP-14-012 SHOULD NOT Exploit Publishers SHOULD NOT release exploit code while an embargo is active (\(q^{em} \in \{A, R\}\))

Released exploit code lets attackers use the vul at once. Releasing it during an embargo exposes users before fixes are ready.
VP-14-014 MAY In MPCVD cases where some Vendors reach Fix Ready before others, Participants MAY propose an embargo extension to allow trailing Vendors to catch up before publication

When some vendors are ready earlier, publishing at once would leave the other vendors' users exposed. An extension proposal lets participants choose to give the trailing vendors time.
Implementation Guidance
ID Priority Requirement Related
VP-15-004 MAY Vultron Protocol implementations MAY use end-to-end encryption to protect sensitive data in transit

Transport encryption protects each hop only, and messages may pass through intermediaries. End-to-end encryption also protects them from those intermediaries.
Embargo Representation Privacy
ID Priority Requirement Related
VP-16-001 MUST NOT Vulnerability details MUST NOT appear in embargo representation data (e.g., embargo scheduling or notification messages)

Embargo data, such as calendar entries and schedule notices, spreads further and with less care than case content. Keeping vul details out of it stops embargo scheduling from leaking the vul.
VP-16-002 SHOULD A case or vulnerability identifier SHOULD appear in embargo representation data along with an indication that it relates to an embargo expiration

Recipients need to know which case an embargo date belongs to and that it is an embargo end. An identifier and an explicit embargo indication give them that without sharing any details.
VP-16-003 SHOULD NOT Case or vulnerability identifiers SHOULD NOT carry any information that reveals potentially sensitive details about the vulnerability

Identifiers travel outside the embargo, for example in embargo notices (VP-16-002). An identifier that hints at the product or the flaw would leak information through that route.
CASE_MANAGER Write Authority
ID Priority Requirement Related
VP-17-001 MUST Every change to the canonical case state MUST go through the CASE_MANAGER, so no participant changes that state directly.

This single-writer axiom prevents concurrent-write races and ensures that all shared state changes flow through the actor's consistency checks and persistence layer. The CS participant-specific axes (RM, VFD) are owned by each participant's CaseParticipant record and are intentionally excluded from this restriction.
VP-17-002 MUST NOT A participant MUST NOT update its local case replica by direct mutation from an inbound protocol message.

Direct mutation from inbound messages (e.g., Add(Note)[target=VulnerabilityCase]) would bypass the ledger ordering guarantees and create divergence from the canonical case state. This path is distinct from VP-17-001 and is not a bypass of the CASE_MANAGER write constraint.
Derives from: VP-17-001
Constrains: SM-10-002
VP-17-003 MUST A participant MUST update its local case replica only by replaying ledger entries from Add(CaseLedgerEntry) fan-out.

Ledger replay is the intended propagation mechanism for keeping participant replicas consistent with canonical case state, in the ledger's order.
Satisfies: VP-17-002
Routing Topology
ID Priority Requirement Related
VP-18-001 MUST Outbound messages from a participant MUST follow the routing path: participant → CASE_MANAGER → CaseLedgerEntry → broadcast → participants. RK, Read(Offer(VulnerabilityReport)), is outside this rule: it answers the reporter's Offer outside the case and goes to the reporter alone (RMB-08-003).

The ledger record provides the audit trail and ordering guarantees for all case activity. Direct peer-to-peer delivery bypasses the ledger and the broadcast idempotency controls.
Refines: PCR-08-001 — participant-case-relationships.yaml — PCR-08 covers ledger-based broadcast
VP-18-002 MUST NOT A participant MUST NOT deliver messages directly to another participant's inbox. The RK that RMB-08-003 requires an addressee of the reporter's Offer to send to the reporter is outside this rule.

Direct peer-to-peer delivery bypasses the case ledger, removing the audit trail and broadcast idempotency guarantees.
Refines: VP-18-001
VP-18-003 MUST Delivery of outbound participant messages MUST be mediated by the CASE_MANAGER and recorded in the case ledger before being fanned out to participants. RK is outside this rule: it goes to the reporter alone (RMB-08-003).

Mediation through the CASE_MANAGER ensures all case activity is ledger-ordered and consistently broadcast to all participants.
Refines: VP-18-001

14.2 Messages and Vocabulary

The requirements on the messages participants exchange: how each protocol message maps onto an ActivityStreams 2.0 (AS2) activity, the vocabulary objects, message validation, semantic extraction, what an actor knows, the wire forms of field values, and which messages share an actor.

Vultron Semantic–AS2 Mapping

Defines the authoritative mapping from each Vultron semantic message type (MessageSemantics enum value) to its ActivityStreams 2.0 wire representation. This is the single source of truth for how Vultron domain semantics are encoded as AS2 activity structures, isolating transport and wire-encoding concerns from the core domain logic and case-state machines.

General Mapping Conventions
ID Priority Requirement Related
VAM-01-008 MUST Inbound activities represent state-change notifications, not commands; the AS2 activity type used for each semantic MUST reflect the completed state transition, not a requested action

Each activity reports an act that the sender has already performed, such as an Offer it made or an Invite it sent, and not an act it asks the receiver to perform. If an activity stated a requested action, the receiver could not know whether the sender's state had changed, and two participants could record different states for the same case. A completed-action type makes each message match the change that it reports.
VAM-01-011 MUST Each of these case records MUST enter a case only by its one attaching message, which carries it inline or by reference. A CaseStatus enters by the Add(CaseStatus) that attaches it (VAM-08-002). A ParticipantStatus enters by the Add(ParticipantStatus) that attaches it (VAM-08-004). A proposed EmbargoEvent enters by the Invite that proposes it (VAM-05-005). A Note enters by the Add(Note) that attaches it (VAM-07-002).

These records mean nothing apart from their case, so a separate Create would add a "created but not attached" state needing its own ledger entry and replica step (CLP-07-013, RSH-08-004) for no gain (ADR-0137). A Create(Note), with or without a case context, is a deferred form recorded as an open question (MS-18-001). These records get one attaching message each. The Create a CASE_MANAGER ledger entry carries as its payload snapshot records a change; it is not a received message.
Constrains: VAM-08-002 — the Add(CaseStatus) is the only way a case status enters a case
Constrains: VAM-08-004 — the Add(ParticipantStatus) is the only way a participant status enters a case
Constrains: VAM-05-005 — the Invite is the only way a proposed embargo event enters a case
Constrains: VAM-07-002 — the Add(Note) is the only way a note enters a case
VAM-01-019 MUST NOT A received Create whose object is a CaseStatus, a ParticipantStatus, an EmbargoEvent, a CaseParticipant or a Note is not a protocol message. Its receiver MUST NOT change the case file because of it.

Each of these records enters a case only by its attaching message (VAM-01-011) or as the CASE_MANAGER's consequence of an act it records (VAM-01-020). A separate Create would add a "created but not attached" state needing its own ledger entry and replica step (CLP-07-013, RSH-08-004) for no gain (ADR-0137).
Derives from: VAM-01-011
VAM-01-020 MUST A CaseParticipant MUST come into existence only as the CASE_MANAGER's consequence of an act that it records.

A participant record means nothing apart from its case, and the CASE_MANAGER records each act that changes the case. A participant made any other way would be a case-file change outside the ledger (CLP-07-013, ADR-0137).
Report Management Messages
ID Priority Requirement Related
VAM-02-001 MUST CREATE_REPORT MUST be represented as Create(VulnerabilityReport)

A report is a new object, and AS2 records a new object with Create. The sender and every receiver must use the same wire form, or a receiver classifies the activity as unknown.
VAM-02-002 MUST SUBMIT_REPORT MUST be represented as Offer(VulnerabilityReport)

To submit a report is to give it to a receiver for a decision, which is what an AS2 Offer means. The receiver answers the same Offer with Read, Accept, TentativeReject or Reject (VAM-02-003 to VAM-02-006), so each answer wraps the submission that it answers.
VAM-02-003 MUST ACK_REPORT MUST be represented as Read(Offer(VulnerabilityReport))

An acknowledgement says only that the receiver has the report, not that it has judged the report. AS2 Read states that an actor has seen an object, so the Reporter gets a receipt that it cannot confuse with a validation.
VAM-02-004 MUST VALIDATE_REPORT MUST be represented as Accept(Offer(VulnerabilityReport)). This is the direct report recipient's RV; a participant that joined through an Invite sends RV as the full-case Invite reply of VAM-04-012.

Validation is the receiver's answer to the submitted Offer, so it wraps that Offer. A participant that joined through an Invite never received the Offer, so it answers the full-case Invite instead (ADR-0121). The two forms differ in their inner object, so a receiver tells them apart by shape.
See also: VAM-04-012 — context for the reader
VAM-02-005 MUST INVALIDATE_REPORT MUST be represented as TentativeReject(Offer(VulnerabilityReport)). This is the direct report recipient's RI; a participant that joined through an Invite sends RI as the full-case Invite reply of VAM-04-013.

TentativeReject says that the receiver does not accept the report now but keeps it open. That matches RM Invalid, from which a report can still become Valid. A Reject would read as final and is the form of the close in VAM-02-006.
See also: VAM-04-013 — context for the reader
VAM-02-006 MUST CLOSE_REPORT MUST be represented as Reject(Offer(VulnerabilityReport)). This is the direct report recipient's RC; a participant that joined through an Invite sends RC as the full-case Invite reply of VAM-04-014.

A close ends the receiver's work on the report, so the answer is a final Reject of the submitted Offer. Its activity type, Reject and not TentativeReject, tells it apart from an invalidation (VAM-02-005).
See also: VAM-04-014 — context for the reader
Case Management Messages
ID Priority Requirement Related
VAM-03-001 MUST CREATE_CASE MUST be represented as Create(VulnerabilityCase)

A case is a new object, and AS2 records a new object with Create. One wire form lets every receiver classify the creation of a case by shape.
VAM-03-003 MUST ENGAGE_CASE MUST be represented as Join(VulnerabilityCase)

Engage and defer are the two answers that a participant gives about its own work on a case. AS2 Join and Ignore (VAM-03-004) state those two answers, and both have the case as their object, so a receiver tells them apart by activity type alone.
VAM-03-004 MUST DEFER_CASE MUST be represented as Ignore(VulnerabilityCase)

A defer says that the participant sets the case aside but stays in it. AS2 Ignore states that. It differs from Leave (VAM-03-006), which ends the participant's part in the case.
VAM-03-005 MUST ADD_REPORT_TO_CASE MUST be represented as Add(VulnerabilityReport)[target=VulnerabilityCase]

A report is attached to a case that already exists, so the message is an Add with the case as its target. The target tells a receiver which case the report goes into.
VAM-03-006 MUST CLOSE_CASE MUST be represented as Leave(VulnerabilityCase)

A close ends the participant's part in the case, which is what AS2 Leave means. Its object, the case and not an EmbargoEvent, tells it apart from a withdrawal from an embargo, which is also a Leave (VAM-05-011).
VAM-03-007 MUST UPDATE_CASE_OWNER MUST be represented as Update(VulnerabilityCase), carrying the case with its new owner in attributedTo. Only the CASE_MANAGER sends it, as its own act on an accepted ownership transfer (CM-21-002), and it is not handled on receipt (SE-05-002, ADR-0140).

An entry's semantic type is the registry's label for its payload (ADR-0140), so the CASE_MANAGER's own case-field change needs a registry entry of its own.
Uses definition from: SE-05-002
See also: CM-21-002 — names the occasion; sending Update(VulnerabilityCase) does not add the role
Actor Suggestion and Invitation Messages
ID Priority Requirement Related
VAM-04-001 MUST OFFER_ACTOR_TO_CASE MUST be represented as Offer(Actor)[target=VulnerabilityCase]

This is the first message of the actor-suggestion exchange: a participant suggests an Actor to the CASE_MANAGER. A suggestion names only an actor (CM-16-001, CM-16-003), so the object is the Actor itself. The pattern names cross: SuggestActorToCasePattern is bound to OFFER_ACTOR_TO_CASE, and OfferActorToCasePattern is bound to OFFER_CASE_PARTICIPANT (VAM-04-010).
VAM-04-002 MUST ACCEPT_OFFER_CASE_PARTICIPANT MUST be represented as Accept(Offer(CaseParticipant)[target=VulnerabilityCase])

The Case Owner decides on the CASE_MANAGER's Offer(CaseParticipant) (VAM-04-010), which carries the proposed roles, so its Accept wraps that offer and not the first Offer(Actor). The inner object type tells this Accept apart from the CASE_MANAGER's answer to the recommender (VAM-04-016). See CM-16-003, CM-16-004 and ADR-0026.
VAM-04-003 MUST REJECT_OFFER_CASE_PARTICIPANT MUST be represented as Reject(Offer(CaseParticipant)[target=VulnerabilityCase])

As in VAM-04-002, the Case Owner's Reject wraps the CASE_MANAGER's Offer(CaseParticipant) and not the first Offer(Actor). The inner object type tells it apart from the CASE_MANAGER's answer to the recommender (VAM-04-017).
VAM-04-004 MUST INVITE_ACTOR_TO_CASE (the stub Invite) MUST be represented as Invite(VulnerabilityCase preview)[target=Actor]: its object is the case's typed reference carrying the case's preview, shaped as CM-11-013 requires, and its target is the invitee.

AS2 puts what one is invited to in object and the invitee in target (ADR-0205). An invitee has not yet joined the case, so the Invite carries the case's preview, not the case (ADR-0114). A receiver tells the stub Invite from the full-case Invite (VAM-04-011) by the form of the object, as received (SE-01-009), with no lookup.
Depends on: CM-11-013
VAM-04-005 MUST ACCEPT_INVITE_ACTOR_TO_CASE MUST be represented as Accept(Invite(VulnerabilityCase preview)[target=Actor])

The invitee answers the Invite that it received, so its Accept wraps that Invite. The form of the nested Invite's object tells this Accept apart from the RV reply to the full-case Invite (VAM-04-012, ADR-0205).
VAM-04-006 MUST REJECT_INVITE_ACTOR_TO_CASE MUST be represented as Reject(Invite(VulnerabilityCase preview)[target=Actor])

A Reject of the stub Invite is the invitee's refusal to join (CM-11-007). The form of the nested Invite's object tells it apart from the RC reply to the full-case Invite (VAM-04-014), which a participant that has already joined sends to close the report.
VAM-04-007 MUST OFFER_CASE_OWNERSHIP_TRANSFER MUST be represented as Offer(VulnerabilityCase): the one Offer of a transfer, which the CASE_MANAGER makes from the Case Owner's proposal (CM-21-005).

The Offer asks the transferee to become the Case Owner, and an AS2 Offer gives an object to a receiver for a decision. The CASE_MANAGER makes the Offer, so the transfer goes through the actor that records it in the case ledger (CM-21-005). An Offer of the case differs by shape from the Case Owner's proposal, an Offer of an Offer (VAM-04-018).
Uses definition from: CM-21-005
VAM-04-008 MUST ACCEPT_CASE_OWNERSHIP_TRANSFER MUST be represented as Accept(Offer(VulnerabilityCase))

The transferee answers the Offer that it received, so its Accept wraps that Offer. The CASE_MANAGER then moves the CASE_OWNER role (CM-21-002 to CM-21-004).
VAM-04-009 MUST REJECT_CASE_OWNERSHIP_TRANSFER MUST be represented as Reject(Offer(VulnerabilityCase))

A Reject of the Offer leaves the current Case Owner in place. It wraps the same Offer as the Accept of VAM-04-008, so a receiver tells the two answers apart by activity type.
VAM-04-010 MUST OFFER_CASE_PARTICIPANT MUST be represented as Offer(CaseParticipant)[target=VulnerabilityCase]

This is the second message of the actor-suggestion exchange. When it has the Offer(Actor) (VAM-04-001), the CASE_MANAGER offers case participation to the Case Owner as a CaseParticipant that carries the proposed roles (CM-16-003). The Case Owner answers this offer (VAM-04-002, VAM-04-003), so the roles that it decides on are in the object that it answers. See CM-16-004 and ADR-0026.
VAM-04-011 MUST The full-case Invite (CM-11-010) MUST be represented as Invite(whole VulnerabilityCase)[target=Actor], with the whole case as its object, the invitee as its target and the CASE_MANAGER's ledger position carried as the Invite's ledgerPosition, the object with logIndex and entryHash every case activity carries (SYNC-18-001), for example "ledgerPosition": {"logIndex": 3, "entryHash": "<hash>"}. The position of an empty ledger is logIndex -1 with the case's genesisHash as entryHash (CLP-08-004). A receiver MUST refuse an Invite whose ledgerPosition is missing or does not parse as a ledger position, naming the activity and writing nothing (SYNC-18-015).

AS2 puts what one is invited to in object and the invitee in target (ADR-0205). The participant has joined, so it is entitled to the whole case, and the whole case and the stub Invite's previewed reference differ in form, so the two Invites are classified without a lookup (SE-01-009). The position is the sender's ledger tail, which every case activity states in the same property (ADR-0156), so the Invite's floor needs no slot of its own.
Uses definition from: CM-11-010
Refines: SYNC-18-001
Refines: SYNC-18-015
See also: CLP-08-004 — context for the reader
VAM-04-012 MUST The RV reply to the full-case Invite MUST be represented as Accept(Invite(whole VulnerabilityCase)[target=Actor]), carrying the replier's ledger position as its ledgerPosition, in the form VAM-04-011 defines (CM-11-011, SYNC-18-001).

The RV reply answers the full-case Invite, so it wraps that Invite. Its ledger position states the replier's ledger tail when it judged the case (ADR-0156). The whole case in the nested Invite's object tells this reply apart from the Accept of a stub Invite (VAM-04-005, ADR-0205).
Uses definition from: VAM-04-011
Refines: SYNC-18-001
See also: CM-11-011 — context for the reader
VAM-04-013 MUST The RI reply to the full-case Invite MUST be represented as TentativeReject(Invite(whole VulnerabilityCase)[target=Actor]), carrying the replier's ledger position as its ledgerPosition, in the form VAM-04-011 defines (CM-11-011, SYNC-18-001).

TentativeReject records RM Invalid, from which the participant's RM state can still become Valid, so it is the same tentative answer as for a direct report (VAM-02-005). A stub Invite has no tentative reply (CM-11-028), so this form exists only for the full-case Invite.
Uses definition from: VAM-04-011
Refines: SYNC-18-001
See also: CM-11-011 — context for the reader
VAM-04-014 MUST The RC reply to the full-case Invite MUST be represented as Reject(Invite(whole VulnerabilityCase)[target=Actor]), carrying the replier's ledger position as its ledgerPosition, in the form VAM-04-011 defines (CM-11-011, SYNC-18-001).

Reject records RM Closed for a participant that has already joined. The whole case in the nested Invite's object tells it apart from a refusal to join, which is the Reject of a stub Invite (VAM-04-006, ADR-0205).
Uses definition from: VAM-04-011
Refines: SYNC-18-001
See also: CM-11-011 — context for the reader
VAM-04-015 MUST UNDO_CASE_OWNERSHIP_TRANSFER MUST be represented as Undo(Offer(Offer(VulnerabilityCase))): the Case Owner's withdrawal of its own proposal, and with it of the open Offer the CASE_MANAGER made from it (CM-21-015).

An actor undoes only an activity that it performed, so the Case Owner withdraws its own proposal with an Undo of that proposal. The withdrawal also ends the Offer that the CASE_MANAGER made from the proposal (CM-21-015), so no transferee can accept an Offer that the Case Owner withdrew.
See also: CM-21-015 — a wire representation is not a narrower case of the withdrawal's ledger commit
VAM-04-016 MUST ACCEPT_ACTOR_RECOMMENDATION MUST be represented as Accept(Offer(Actor)[target=VulnerabilityCase]): the CASE_MANAGER's answer to the recommender, wrapping the recommender's own Offer(Actor) (VAM-04-001), with inReplyTo naming that Offer (CM-16-006, CM-16-009).

This is the third hop of the exchange, addressed back to the recommender. It wraps the first offer, where the Case Owner's decision (VAM-04-002) wraps the second, so the inner object type tells the two Accepts apart.
Uses definition from: VAM-04-001
See also: CM-16-006 — the Accept's shape is not a narrower case of the four-step handling
See also: CM-16-009 — context for the reader
VAM-04-017 MUST REJECT_ACTOR_RECOMMENDATION MUST be represented as Reject(Offer(Actor)[target=VulnerabilityCase]): the CASE_MANAGER's answer to the recommender after the Case Owner declines, with inReplyTo naming the recommender's Offer(Actor) (CM-16-007).

Symmetric with VAM-04-016; the Case Owner's Reject (VAM-04-003) wraps Offer(CaseParticipant) instead.
See also: CM-16-007 — the Accept's shape is not a narrower case of the handling it cites
VAM-04-018 MUST PROPOSE_CASE_OWNERSHIP_TRANSFER MUST be represented as Offer(Offer(VulnerabilityCase)) with the case as the proposal's context: the Case Owner's proposal to the CASE_MANAGER, whose inner Offer is the template of the Offer the CASE_MANAGER makes (CM-21-005).

The proposal and the CASE_MANAGER's Offer(VulnerabilityCase) (VAM-04-007) are told apart by shape, an Offer of an Offer against an Offer of a case, so neither pattern needs a sender check and no new vocabulary type is needed (ADR-0148).
Derives from: CM-21-005
Embargo Management Messages
ID Priority Requirement Related
VAM-05-003 MUST REMOVE_EMBARGO_EVENT_FROM_CASE MUST be represented as Remove(EmbargoEvent)

A removal takes the embargo out of the case, which is what AS2 Remove means. The sender and every receiver must use the same wire form, or a receiver classifies the activity as unknown.
VAM-05-004 MUST ANNOUNCE_EMBARGO_EVENT_TO_CASE MUST be represented as Announce(EmbargoEvent)[context=VulnerabilityCase]

An announcement tells participants about an embargo event and asks for no answer, which is what AS2 Announce means. The case in context names the case that the embargo belongs to.
VAM-05-005 MUST INVITE_TO_EMBARGO_ON_CASE MUST be represented as Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase], whose target is the invitee: the one actor the Invite is addressed to (EP-09-010).

A proposed embargo needs the answer of each invitee, so it is an Invite with the EmbargoEvent as its object. AS2 puts the invitee of an Invite in target, so a generic reader sees who is invited, not only who the Invite is delivered to (ADR-0205). The EmbargoEvent object and the case in context keep this form separate from the Invite of an actor to a case.
Uses definition from: EP-09-010
VAM-05-006 MUST ACCEPT_INVITE_TO_EMBARGO_ON_CASE MUST be represented as Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase])

An invitee consents to the proposed embargo when it accepts the Invite that it received, so the Accept wraps that Invite. Its inner object tells it apart from the Case Owner's activation, which is an Add of the EmbargoEvent itself (VAM-05-008).
VAM-05-007 MUST REJECT_INVITE_TO_EMBARGO_ON_CASE MUST be represented as Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase])

An invitee declines the proposed embargo when it rejects the Invite that it received. Its inner object tells it apart from the Case Owner's rejection of the proposal, which is a Reject of the EmbargoEvent itself (VAM-05-009).
VAM-05-008 MUST ACTIVATE_EMBARGO_ON_CASE MUST be represented as Add(EmbargoEvent)[target=VulnerabilityCase], whose object is the proposed EmbargoEvent itself, carried inline or by reference, and whose inReplyTo names the Invite(EmbargoEvent) that proposed it (ADR-0180).

The Case Owner's activation is a change to the case: the case gains the embargo, as Remove(EmbargoEvent) ends it (VAM-05-003). An Accept of the Invite is each sender's own consent (VAM-05-006), so the two differ by verb, and a receiver tells them apart by type alone. inReplyTo links the decision to the proposal it decides (RF-08-001).
VAM-05-009 MUST REJECT_EMBARGO_PROPOSAL_ON_CASE MUST be represented as Reject(EmbargoEvent)[target=VulnerabilityCase], whose object is the proposed EmbargoEvent itself, carried inline or by reference, and not the Invite that proposed it, which its inReplyTo names (ADR-0122, ADR-0180).

The Case Owner's rejection is a decision about the embargo for the case; a Reject of the Invite is each sender's own consent (VAM-05-007). inReplyTo links the decision to the proposal it decides (RF-08-001).
VAM-05-011 MUST WITHDRAW_FROM_EMBARGO_ON_CASE MUST be represented as Leave(EmbargoEvent)[context=VulnerabilityCase], whose object is the embargo in force, carried inline or by reference, and not an Invite (ADR-0122).

Withdrawal answers no Invite, so it names the embargo itself; it is told apart from Leave(VulnerabilityCase), which leaves the case, by its object (MSM-07-010).
VAM-05-013 MUST UNDO_INVITE_TO_EMBARGO_ON_CASE MUST be represented as Undo(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]), whose object is an Invite(EmbargoEvent) the sender itself sent. Only the CASE_MANAGER sends it, when it abandons an open proposal (EMB-16-001, ADR-0152).

An actor undoes only an activity it performed, so withdrawing an invitation one sent is an Undo and declining one received is a Reject (ADR-0152). The shape is told apart from the ownership-transfer Undo (VAM-04-015) by its object, an embargo Invite.
See also: EMB-16-001 — representing the Undo is not sufficient for abandoning on a CS change
VAM-05-014 MUST CREATE_EMBARGO_CONSENT MUST be represented as Create(EmbargoConsent), carrying the new consent row in full. Only the CASE_MANAGER sends it, as its own act when it brings a consent row into existence (ADR-0122, CLP-07-013), and it is not handled on receipt (SE-05-002, ADR-0140).

An entry's semantic type is the registry's label for its payload (ADR-0140). The record is a case-file change, not a PEC transition (MSM-07-001).
Refines: MSM-07-001
Uses definition from: SE-05-002
See also: CLP-07-013 — context for the reader
VAM-05-015 MUST UPDATE_EMBARGO_CONSENT MUST be represented as Update(EmbargoConsent), carrying the changed consent row in full. Only the CASE_MANAGER sends it, as its own act when it changes a consent row, its own consent included (MSM-07-017, CLP-07-013). It is not handled on receipt (SE-05-002, ADR-0140).

An entry's semantic type is the registry's label for its payload (ADR-0140). An expired invitation is this Update carrying the invitee's TIMED_OUT row (ADR-0140 item 4).
Uses definition from: SE-05-002
See also: CLP-07-013 — context for the reader
VAM-05-016 MUST CREATE_EMBARGO_EVENT MUST be represented as Create(EmbargoEvent), carrying the embargo in full, its start and end times included. Only the CASE_MANAGER commits it, as a ledger entry and never as a sent message, once for each embargo a case's creation writes, such as the default embargo (EP-04-002), right after the case's genesis entry and before the case's other creation entries (CLP-07-013). It is not handled on receipt (SE-05-002, ADR-0140): a replica stores the embargo from the entry.

The genesis entry carries only the case's active embargo inline, and a replica copies each record from its own entry (ADR-0124). No other entry carries a creation-time embargo until the embargo is removed. Without this entry, a replica built from the ledger alone could not read the end time that its embargo decisions need. An entry's semantic type is the registry's label for its payload (ADR-0140).
Refines: CLP-07-013
Uses definition from: SE-05-002
See also: EP-04-002 — context for the reader
Case Participant Management Messages
ID Priority Requirement Related
VAM-06-003 MUST REMOVE_CASE_PARTICIPANT_FROM_CASE MUST be represented as Remove(CaseParticipant)[target=VulnerabilityCase]

The message removes a participant from the case's activeParticipants, not from caseParticipants: the record stays and the participant stops receiving case content (CM-31-001, CM-31-004, ADR-0116).
VAM-06-004 MUST ADD_CASE_PARTICIPANT_TO_CASE MUST be represented as Add(CaseParticipant)[target=VulnerabilityCase], with context the case, carrying the record in full. Only the CASE_MANAGER sends it, as its own act when it brings a participant record into the case (ADR-0114, CLP-07-021), and it is not handled on receipt (SE-05-002, ADR-0140).

An entry's semantic type is the registry's label for its payload (ADR-0140). The record joins the case's participant list, so its entry names the case as target, as the case's other lists do (CLP-07-021), and a replica reads the list from the entry rather than choosing it (CM-23-044). The Case Owner's reinstatement is its own Add naming the actor, not the record (CM-31-011, ADR-0199), so this form has one meaning. A received copy is recognized only so that it is reported, not acted on.
Uses definition from: SE-05-002
Refines: CLP-07-021
VAM-06-005 MUST UPDATE_CASE_PARTICIPANT MUST be represented as Update(CaseParticipant), carrying the changed record in full. Only the CASE_MANAGER sends it, as its own act when it changes a participant record, such as moving the CASE_OWNER role (CM-21-002, CLP-07-013), and it is not handled on receipt (SE-05-002, ADR-0140).

An entry's semantic type is the registry's label for its payload (ADR-0140), so each participant-record change the CASE_MANAGER commits needs a registry entry.
Uses definition from: SE-05-002
See also: CLP-07-013 — context for the reader
See also: CM-21-002 — an example; sending Update(CaseParticipant) is not sufficient for the role change
Note Management Messages
ID Priority Requirement Related
VAM-07-002 MUST ADD_NOTE_TO_CASE MUST be represented as Add(Note)[target=VulnerabilityCase]

A note means nothing apart from its case, so it enters the case only by the Add that attaches it, with the case as target (VAM-01-011, ADR-0137). One attaching message means that a note has no state in which it exists but is not in a case.
VAM-07-003 MUST REMOVE_NOTE_FROM_CASE MUST be represented as Remove(Note)[origin=VulnerabilityCase]

A removal takes the note out of the case named in origin: AS2 Remove names the collection the actor removes the object from in origin (VOC Remove), and target names where something goes. The Note object tells it apart from the other Remove forms, such as the removal of a participant (VAM-06-003).
Status Tracking Messages
ID Priority Requirement Related
VAM-08-002 MUST ADD_CASE_STATUS_TO_CASE MUST be represented as Add(CaseStatus, target=<case>/statuses), with context the case. The target is the case's status history, an ordered collection whose newest item is the case's current status (ADR-0204).

A case status means nothing apart from its case, so it enters the case only by the Add that attaches it (VAM-01-011, ADR-0137). AS2 Add names the collection the object joins in target, so the target is the case's status history and the case is in context (ADR-0204). A status is never updated; the newest one in the history is the case's current status.
VAM-08-004 MUST ADD_PARTICIPANT_STATUS_TO_PARTICIPANT MUST be represented as Add(ParticipantStatus, target=<participant>/statuses), with context the case. The target is the participant's status history, an ordered collection whose newest item is the participant's current status (ADR-0204).

A participant status belongs to one participant in one case, so it joins that participant's status history and not the case's. The Add is the only way the status enters the case (VAM-01-011, ADR-0137), and it names the history in target and the case in context (ADR-0204). A status is never updated; the newest one in the history is the participant's current status.

Protocol Shorthand to MessageSemantics Mapping

Authoritative normative bridge from protocol message shorthand labels (RS, EP, CV, etc.) used in behavioral conformance specs to their MessageSemantics enum values and corresponding AS2 wire-format specifications. Each entry provides one row in the three-hop chain: shorthand to MessageSemantics enum value to AS2 wire form. The correspondence is many-to-many in both directions: several shorthands may collapse onto one wire activity (CV/CF onto vfState, CP/CX/CA onto pxaState, EV onto EP), and one shorthand may expand across several wire activities (GI, ER). Shorthands with no dedicated dispatch value are the protocol-layer error and acknowledgment signals; these are not unimplemented — the purposes they name are served by mechanisms partitioned on a different axis, specified normatively in MSM-05.

RM Protocol Message Shorthands

Normative shorthand-to-semantic mappings for Report Management (RM) protocol messages, covering RS, RI, RV, RD, RA, RC, RE, and RK.

ID Priority Requirement Related
MSM-01-001 MUST Protocol shorthand RS (Report Submission) MUST have the semantic type SUBMIT_REPORT; its AS2 wire form is Offer(VulnerabilityReport) per VAM-02-002.

Report submission opens a CVD exchange, so a recipient on any implementation must recognize it as a report submission and not some other activity. Offer fits because the reporter puts the report before the recipient for a decision, which the recipient's RV, RI or RC then answers by naming that Offer.
Uses definition from: VAM-02-002
MSM-01-002 MUST Protocol shorthand RI (Report Invalid) MUST have the semantic type INVALIDATE_REPORT; its AS2 wire form is TentativeReject(Offer(VulnerabilityReport)) per VAM-02-005. This is the direct report recipient's RI; a participant that joined through an Invite sends RI as the full-case Invite reply of VAM-04-013.

Invalidating a report answers the reporter's Offer, so the reply names it. TentativeReject marks the decision as reversible, since an invalid report can become valid when new information arrives, and keeps RI distinct from the final Reject of RC. A participant that joined through an Invite has no Offer to answer, so its RI rides the Invite reply instead.
Uses definition from: VAM-02-005
Uses definition from: VAM-04-013
MSM-01-003 MUST Protocol shorthand RV (Report Valid) MUST have the semantic type VALIDATE_REPORT; its AS2 wire form is Accept(Offer(VulnerabilityReport)) per VAM-02-004. This is the direct report recipient's RV; a participant that joined through an Invite sends RV as the full-case Invite reply of VAM-04-012.

Validating a report answers the reporter's Offer, so the reply names it, and Accept says the recipient takes the report as a real vul to handle. Report validity is a separate decision from engaging in the case (RA), so RV needs its own form. A participant that joined through an Invite has no Offer to answer, so its RV rides the Invite reply instead.
Uses definition from: VAM-02-004
Uses definition from: VAM-04-012
MSM-01-004 MUST Protocol shorthand RD (Report/Case Deferred) MUST have the semantic type DEFER_CASE; its AS2 wire form is Ignore(VulnerabilityCase) per VAM-03-004.

A deferred report indicates the receiving actor will not engage with the case at this time. The wire representation uses Ignore(VulnerabilityCase) rather than a report-level verb because deferral is a case-participation decision, not a report-validity judgment.
Uses definition from: VAM-03-004
MSM-01-005 MUST Protocol shorthand RA (Report/Case Accepted) MUST have the semantic type ENGAGE_CASE; its AS2 wire form is Join(VulnerabilityCase) per VAM-03-003.

Accepting a report means the receiving actor commits to engaging with the vulnerability case. The wire verb Join captures the case-participation decision, symmetric with Ignore for RD.
Uses definition from: VAM-03-003
MSM-01-006 MUST Protocol shorthand RC (Report Closed) MUST have the semantic type CLOSE_REPORT; its AS2 wire form is Reject(Offer(VulnerabilityReport)) per VAM-02-006. This is the direct report recipient's RC; a participant that joined through an Invite sends RC as the full-case Invite reply of VAM-04-014.

Closing a report answers the reporter's Offer, so the reply names it. Reject is final, which tells the reporter the report will not be reconsidered and keeps RC distinct from the reversible TentativeReject of RI. A participant that joined through an Invite has no Offer to answer, so its RC rides the Invite reply instead.
Uses definition from: VAM-02-006
Uses definition from: VAM-04-014
MSM-01-008 MUST Protocol shorthand RK (Report Management Acknowledgment) MUST have the semantic type ACK_REPORT; its AS2 wire form is Read(Offer(VulnerabilityReport)) per VAM-02-003.

A reporter needs to know its report arrived before any validity decision is made. Read acknowledges receipt of the Offer without judging it. Report submission happens before any case ledger exists, so no hash-chain acknowledgement covers it (MSM-05-002) and it needs this explicit one.
Uses definition from: VAM-02-003
EM Protocol Message Shorthands

Normative shorthand-to-semantic mappings for Embargo Management (EM) protocol messages, covering EP, EA, EV, EJ, EC, ER, ET, EE, and EK. The formal message set models the case's view of the embargo, so an acceptance or rejection shorthand names the Case Owner's decision that makes its EM transition, not each Participant's answer to the Invite. Embargo revision shorthands (EV, EJ, EC) share wire formats with their initial-proposal counterparts (EP, ER, EA); the distinction is contextual rather than structural.

ID Priority Requirement Related
MSM-02-001 MUST Protocol shorthand EP (Embargo Proposed) MUST have the semantic type INVITE_TO_EMBARGO_ON_CASE; its AS2 wire form is Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase] per VAM-05-005.

Proposing an embargo asks each participant to consent to the proposed terms, which is what Invite expresses; the Event is the proposed embargo. The context names the case, so a receiver can tie the proposal to that case's EM state. One wire form lets every implementation recognize a proposal.
Uses definition from: VAM-05-005
MSM-02-002 MUST Protocol shorthand EA (Embargo Accepted) MUST have the semantic type ACTIVATE_EMBARGO_ON_CASE; its AS2 wire form is Add(EmbargoEvent)[target=VulnerabilityCase] per VAM-05-008, the Case Owner's decision that moves EM from PROPOSED to ACTIVE (MSM-07-008).

EA names the EM transition PROPOSED to ACTIVE, and only the Case Owner's decision makes it. A Participant's Accept(Invite(EmbargoEvent)) records that Participant's consent (MSM-07-003) and moves no register entry, so mapping EA to it would name a message that never makes EA's transition. The consent answers are what the Case Owner weighs before it decides (MSM-02-010).
Uses definition from: VAM-05-008
Uses definition from: MSM-07-008
MSM-02-004 MUST Protocol shorthand EJ (Embargo Revision Rejected) MUST have the semantic type REJECT_EMBARGO_PROPOSAL_ON_CASE; its AS2 wire form is Reject(EmbargoEvent)[target=VulnerabilityCase] per VAM-05-009, the Case Owner's decision that returns EM from REVISE to ACTIVE with the prior terms in force (MSM-07-009).

EJ names the EM transition REVISE to ACTIVE, and only the Case Owner's rejection of the revision makes it; a Participant's Reject(Invite(EmbargoEvent)) of the revision declines that Participant's consent row and nothing else (MSM-07-004). EJ shares its wire form with the Case Owner's ER, and the receiver's EM state tells the two apart, as MSM-02-003 does for EV.
Uses definition from: VAM-05-009
Uses definition from: MSM-07-009
MSM-02-005 MUST Protocol shorthand EC (Embargo Revision Accepted) MUST have the semantic type ACTIVATE_EMBARGO_ON_CASE; its AS2 wire form is Add(EmbargoEvent)[target=VulnerabilityCase] per VAM-05-008, the Case Owner's decision that replaces the active embargo with the revision and moves EM from REVISE to ACTIVE (MSM-07-008).

EC names the EM transition REVISE to ACTIVE, and only the Case Owner's activation of the revision makes it; a Participant's Accept(Invite(EmbargoEvent)) of the revision records that Participant's consent and binds it to nothing new (MSM-07-003). EC shares its wire form with EA, and the receiver's EM state tells the two apart, as MSM-02-003 does for EV.
Uses definition from: VAM-05-008
Uses definition from: MSM-07-008
MSM-02-006 MUST Protocol shorthand ER (Embargo Rejected) MUST have the semantic type REJECT_EMBARGO_PROPOSAL_ON_CASE, with AS2 wire form Reject(EmbargoEvent)[target=VulnerabilityCase] per VAM-05-009, for the Case Owner's decision that rejects a proposal, and the semantic type REJECT_INVITE_TO_EMBARGO_ON_CASE, with AS2 wire form Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) per VAM-05-007, for the CASE_MANAGER's abandonment of a proposal (EMB-16-001); either moves EM from PROPOSED to NONE once no other proposal is open.

ER names the EM transition PROPOSED to NONE, and two activities make it: the Case Owner's rejection of the proposal (MSM-07-009) and the CASE_MANAGER's abandonment, which cancels the proposal once the case is public, exploited or attacked. A Participant's Reject(Invite(EmbargoEvent)) declines only that Participant's consent row (MSM-07-004), and a replica tells it from the abandonment by the payload's actor (ADR-0152).
Uses definition from: VAM-05-009
Uses definition from: VAM-05-007
Uses definition from: EMB-16-001
Uses definition from: MSM-07-009
MSM-02-007 MUST Protocol shorthand ET (Embargo Terminated) MUST have the semantic type REMOVE_EMBARGO_EVENT_FROM_CASE; its AS2 wire form is Remove(EmbargoEvent) per VAM-05-003.

Ending an embargo takes the embargo event off the case, which is what Remove expresses. A verb distinct from Reject keeps the end of an active embargo apart from a refusal of a proposal, so every participant knows the embargo has ended and binds no one.
Uses definition from: VAM-05-003
MSM-02-010 MUST NOT An implementation MUST NOT apply the EM transition of EA, EC, ER or EJ on receipt of a Participant's Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) or Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]), because that activity is the sender's consent to one embargo (MSM-07-003, MSM-07-004), and the transition is made only by the activity MSM-02-002, MSM-02-004, MSM-02-005 or MSM-02-006 maps the shorthand to. The CASE_MANAGER's own Reject(Invite(EmbargoEvent)) is not its consent but its abandonment of the proposal, which MSM-02-006 maps to ER (EMB-16-001).

The formal message set models the case's view of the embargo, not each Participant's answer to each proposal: Participant Embargo Consent (PEC) is a finer layer over EM that it does not describe (MSM-07-001). One formal message can take several activities in practice: Participants answer the Invite, and the Case Owner decides for the case in light of those answers. Reading an answer as the case's transition would let one Participant decide for everyone.
Derives from: MSM-07-003
Derives from: MSM-07-004
Uses definition from: MSM-02-002
Uses definition from: MSM-02-004
Uses definition from: MSM-02-005
Uses definition from: MSM-02-006
See also: EMB-16-001 — context for the reader
CS Protocol Message Shorthands

Normative shorthand-to-semantic mappings for CVD Case State (CS) protocol messages, covering CV, CF, CD, CP, CX, CA, CE, and CK. CS status shorthands are split across two semantics by dimension scope, because the CS hypercube mixes participant-scoped and case-scoped dimensions: the participant-scoped V/F/D dimensions (CV, CF, CD) dispatch as ADD_PARTICIPANT_STATUS_TO_PARTICIPANT and are encoded in the ParticipantStatus payload, while the case-scoped P/X/A dimensions (CP, CX, CA) dispatch as ADD_CASE_STATUS_TO_CASE and are encoded in the CaseStatus payload. There are no case-level V/F/D states (ADR-0075). In both groups the specific state transition is encoded in the object payload rather than in the activity type.

ID Priority Requirement Related
MSM-03-001 MUST Protocol shorthand CV (Vendor Aware) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT; its AS2 wire form is Add(ParticipantStatus, target=<participant>/statuses) per VAM-08-004 and ADR-0204. The ParticipantStatus payload encodes vendor awareness in the vfState field, advancing the vendor-path ladder from vf to Vf.

The V dimension is participant-scoped, not case-scoped: it records whether a specific vendor is aware. Per ADR-0075 there is no case-level V/F/D state, and a case-level Add(CaseStatus) cannot express which vendor became aware, which is the purpose of the V dimension in MPCVD.
Uses definition from: VAM-08-004
MSM-03-002 MUST Protocol shorthand CF (Fix Ready) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT; its AS2 wire form is Add(ParticipantStatus, target=<participant>/statuses) per VAM-08-004 and ADR-0204. The ParticipantStatus payload encodes fix readiness in the vfState field, advancing the vendor-path ladder from Vf to VF.

The F dimension shares the participant-scoped vendor-path sub-machine with V (CS_vf: vf → Vf → VF), so fix readiness is recorded against the specific vendor that produced the fix. Same scope reasoning as MSM-03-001.
Uses definition from: VAM-08-004
MSM-03-003 MUST Protocol shorthand CD (Fix Deployed) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT; its AS2 wire form is Add(ParticipantStatus, target=<participant>/statuses) per VAM-08-004 and ADR-0204. The ParticipantStatus payload encodes deployment in the dState field, advancing the deployer-path ladder from d to D.

The D dimension is participant-scoped on the deployer, and ADR-0075 split it into its own sub-machine (CS_d) precisely because its scope differs from the vendor path. as_ParticipantStatus.d is None for non-DEPLOYER participants (structurally enforced).
Uses definition from: VAM-08-004
MSM-03-004 MUST Protocol shorthand CP (Public Aware) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes public awareness (P) in its pxaState.

A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001).
Uses definition from: VAM-08-002
Derives from: RSH-04-001
See also: RSH-04-005 — context for the reader
MSM-03-005 MUST Protocol shorthand CX (Exploit Published) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes a published exploit (X) in its pxaState.

A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001).
Uses definition from: VAM-08-002
Derives from: RSH-04-001
See also: RSH-04-005 — context for the reader
MSM-03-006 MUST Protocol shorthand CA (Attacks Observed) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes observed attacks (A) in its pxaState.

A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001).
Uses definition from: VAM-08-002
Derives from: RSH-04-001
See also: RSH-04-005 — context for the reader
Fault and Acknowledgement Mechanism Evolution

Normative record of how the formal protocol's per-model error and acknowledgement shorthands (RE, EE, CE, GE and RK, EK, CK, GK) are realized in the AS2 wire vocabulary. The formal set partitions both concerns by which state machine the message belonged to; the implementation partitions faults by failure mode and acknowledges replicated state cumulatively. These are orthogonal axes, so the shorthands have no one-to-one wire counterparts even though the behaviours they describe are implemented.

ID Priority Requirement Related
MSM-05-001 MUST Fault reporting MUST be partitioned by failure mode rather than by state machine, using exactly three mechanisms: Create(ProcessingFault) when a message was received but not understood; as:Reject when a message was received and understood but declined; and Add(Note)[target=VulnerabilityCase] when the condition requires narrative explanation. A declined message gets a Reject when its addressee decides against it, and a Refuse, the vultron:Refuse subtype of as:Reject, when the CASE_MANAGER refuses it because a precondition did not hold.

Failure mode is actionable to a receiver in a way that originating state machine is not. Not-understood calls for a format or version fix, declined calls for a protocol-level decision, and needs-explanation calls for a human. A partition by state machine (RE, EE, CE and GE) carries no such signal, so it would tell the sender only where the fault arose, not what to do about it. A Refuse is a Reject, so it adds no fourth mechanism.
MSM-05-002 MUST Acknowledgement of replicated case-ledger state MUST be cumulative and implicit, through hash-chain continuity.

A matching prev_log_hash already proves receipt of every prior entry, so per-message positive acknowledgement would be redundant. This is negative acknowledgement with gap-fill replay, structurally closer to a cumulative ACK or SACK scheme than to the formal per-message EK, CK and GK design. RK remains a real wire activity (MSM-01-008) because report submission is not ledger-replicated.
MSM-05-007 MUST NOT A receiver whose prev_log_hash matches its local tail MUST NOT emit an acknowledgement.

The match already acknowledges every prior entry (MSM-05-002), so a positive acknowledgement would only add traffic.
Refines: MSM-05-002
MSM-05-008 MUST A receiver MUST emit Reject(CaseLedgerEntry) when an entry's prev_log_hash does not match its local tail. Its object is that entry and its inReplyTo the Add(CaseLedgerEntry) that carried it. The CASE_MANAGER then replays all entries after the last accepted hash.

The mismatch is the one event the sender cannot see for itself. The Reject names where the receiver's chain ends, so the replay fills the gap.
Extends: MSM-05-002
MSM-05-009 MUST The Add(CaseLedgerEntry) that commits an act MUST be that act's positive acknowledgement.

MSM-05-002 and MSM-05-007 govern a replica acknowledging the entries it receives, which hash-chain continuity already does. The sender of an act needs the other direction: to learn that its act committed. The commit's own Add, which names the act in inReplyTo (SYNC-02-007), tells it at no extra cost, because the sender is an active participant and receives every commit (SYNC-02-003). A refused act gets the refusal notice instead.
Depends on: SYNC-02-007
MSM-05-010 MUST NOT The CASE_MANAGER MUST NOT send a separate acknowledgement message for a committed act.

The commit's Add already acknowledges the act (MSM-05-009), so a separate acknowledgement would only add a message per act.
Refines: MSM-05-009
MSM-05-005 MUST All protocol-significant activities MUST be committed to the canonical case ledger by the CASE_MANAGER before fan-out to participant actors. No protocol-significant activity bypasses the ledger replication path.

The hash-chain acknowledgement model (MSM-05-002) is only complete if every activity a participant needs to acknowledge reaches them via an Add(CaseLedgerEntry). Activities that bypassed the ledger would have no acknowledgement mechanism. Report submission (RS) is the only activity not carried by the ledger; it uses RK (MSM-01-008) instead, which is the intended exception rather than a gap.
MSM-05-006 MAY A conformant implementation MAY rely solely on Add(CaseLedgerEntry) deliveries for liveness inference, without emitting a dedicated periodic heartbeat. Silence between Add deliveries is therefore an accepted protocol property: a participant that is online but has received all entries is indistinguishable from one that is unreachable. This does not preclude a future revision adding a normative heartbeat requirement.

The hash-chain NAK model (MSM-05-002) provides implicit acknowledgement only when new entries arrive. Between deliveries, silence and unreachability are observationally equivalent. Stating this as a deliberate MAY-level property tells implementers that the silence is expected behavior, not a defect they must detect or repair, while leaving room for a heartbeat mechanism should a deployment, such as a multi-node CASE_MANAGER cluster, need one.
MSM-05-003 MUST NOT Implementations MUST NOT infer error semantics from the as:Reject verb alone, because as:Reject also carries legitimate protocol rejections, including closing a report and declining an embargo invitation, a case invitation, a case proposal or a case-ownership transfer.

as:Reject is overloaded across error reporting and ordinary protocol refusal. A receiver that treats every as:Reject as a fault will misclassify routine protocol traffic as errors.
Participant Embargo Consent (PEC) State Machine Coupling to EM Wire Activities

Normative record of how each EM wire activity drives the per-participant, per-embargo Participant Embargo Consent (PEC) rows as a side-effect, and which consent positions are derived rather than written. PEC is participant-local state tracking each actor's relationship to each embargo in the case's embargo register; its transitions are not independent protocol messages and have no formal shorthands in the 28-shorthand set. A participant's consent to an embargo is one row holding UNINVITED, INVITED, AGREED, DECLINED or TIMED_OUT; whether the participant is bound by the current active embargo is a lookup of the active embargo's row, and a lapse is read from the rows and the register when a longer embargo replaces the one the participant agreed to. Unlike RM state (self-reported by the participant) and VF/D state (self-reported by vendor/deployer), consent rows are set by the CASE_MANAGER (CM-28-003) based on observed participant behavior — incoming Accept/Reject wire activities and timer-enforced invitation expiry — and replayed on each replica. Normative authority: specs/case-management.yaml CM-18. Decisions: ADR-0048, ADR-0091, ADR-0118, ADR-0122.

ID Priority Requirement Related
MSM-07-001 MUST The Participant Embargo Consent (PEC) state machine MUST NOT be assigned any formal shorthand in the 28-shorthand protocol message set; all PEC transitions are either side-effects of EM wire activities (MSM-07-002 through MSM-07-005, MSM-07-008) or timer-based internal events (MSM-07-007) with no dedicated wire message or semantic type of their own. The CASE_MANAGER's Create(EmbargoConsent) and Update(EmbargoConsent), which record a consent row it brings into existence or changes as its own ledger entry (CLP-07-013), are case-file record changes, not PEC transitions: they carry no shorthand, their ledger semantic types are create_embargo_consent and update_embargo_consent, and neither is handled on receipt (ADR-0140).

PEC is participant-local state tracking each actor's relationship to the shared EM state, not a parallel message-driven machine. Extending the formal set with PEC-specific shorthands would imply dedicated wire messages where none exist and none are needed — the EM messages already carry the PEC signal as a side-effect. Documenting PEC as a side-effect is the faithful description of the design. A ledger entry's semantic type is the registry's label for its payload (ADR-0140), so the CASE_MANAGER's consent-row records need registry entries; they name the record, not a PEC trigger, and no receiver dispatches on them.
Uses definition from: CM-18-003
See also: CLP-07-013 — context for the reader
See also: MSM-07-002 — context for the reader
See also: MSM-07-005 — context for the reader
See also: MSM-07-007 — context for the reader
See also: MSM-07-008 — context for the reader
MSM-07-002 MUST The wire activity INVITE_TO_EMBARGO_ON_CASE (EP wire form: Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) MUST apply the PEC INVITE trigger to the invited participant's row for the invited embargo, advancing it from UNINVITED, DECLINED or TIMED_OUT to INVITED.

An embargo proposal is an invitation to consent; the EP wire activity conveys the invitation and the PEC rows record each participant's position on each embargo. A participant whose row is AGREED is unaffected by EP; INVITE is not legal from AGREED (CM-18-003), and a signatory asked about a revision has its row for the revision invited while its row for the active embargo stays AGREED (EP-09-004). The PEC trigger is applied via EmbargoLifecycle.record_embargo_invite() on the CASE_MANAGER as it relays the Invite, and on each replica as it replays the relay's ledger entry (EP-09-007).
Uses definition from: CM-18-003
Uses definition from: MSM-02-001
MSM-07-003 MUST The wire activity ACCEPT_INVITE_TO_EMBARGO_ON_CASE (wire form: Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase])) is always its sender's own consent, the Case Owner's included. An actor applying it MUST apply the PEC AGREE trigger to the sender's row for the accepted embargo. The row advances from UNINVITED, INVITED, DECLINED or TIMED_OUT to AGREED. The accepted embargo may be the active embargo, a first proposal (EM PROPOSED) or a proposed revision of an embargo still in force. Only the accepted embargo's row is marked. A participant is a signatory exactly when its row for the active embargo is AGREED. So accepting a proposed revision binds the participant to nothing new until the owner activates it (MSM-07-008). An Accept from a DECLINED row is the participant changing its answer, so the row moves directly to AGREED with no re-invite first (CM-18-003). An Accept of an embargo that is not available records nothing (CM-18-003): MSM-07-012 refuses it, and MSM-07-039 answers one the register never held.

The Case Owner's decision for the case has its own activity (MSM-07-008, ADR-0122), so an Accept of an Invite means one thing whoever sends it and no handler branches on the sender to learn what it means. The PEC AGREE trigger is valid directly from UNINVITED because consent can be self-determined without an invitation (ADR-0048, ADR-0091, CM-18-003). Consent is per embargo (CM-10-001, ADR-0093, ADR-0122): an Accept is always a statement about the embargo it names, so it always marks that embargo's row and there is no first-proposal versus revision asymmetry to special-case.
Uses definition from: CM-18-003
See also: MSM-07-008 — context for the reader
MSM-07-004 MUST The wire activity REJECT_INVITE_TO_EMBARGO_ON_CASE (wire form: Reject(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase])) is its sender's own consent whenever a participant sends it, the Case Owner included. Unless MSM-07-014 refuses it, an actor applying it MUST apply the PEC DECLINE trigger to the sender's row for the rejected embargo. DECLINE is valid from UNINVITED, INVITED, AGREED or TIMED_OUT. A Reject of the active embargo from any row but AGREED refuses the terms in force and declines that row only. The CASE_MANAGER's own Reject of a proposal is not its consent but its abandonment (MSM-07-016).

Symmetric with MSM-07-003: the Case Owner's rejection of a proposal for the case has its own activity (MSM-07-009, ADR-0122), so a Reject of an Invite is the sender's consent and nothing else. The PEC DECLINE trigger is valid directly from UNINVITED for symmetric reasons to AGREE (ADR-0048, ADR-0091, CM-18-003).
Uses definition from: CM-18-003
MSM-07-005 MUST This rule covers the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] (MSM-07-008) that replaces active embargo A with revision B. The register activates B and supersedes A, so the derived EM goes REVISE → ACTIVE, or stays REVISE while another proposal is open (EMB-18-005). Implementations MUST settle every participant's consent rows against B.

Only the owner's acceptance changes the embargo on the case; other participants' accepts and rejects are recorded per embargo and inform that decision. When it replaces the embargo in force, each participant's standing has to be read again against the new terms (ADR-0093).
Uses definition from: CM-18-003
Uses definition from: MSM-07-008
Uses definition from: EMB-18-005
MSM-07-020 MUST NOT This rule covers the owner's activation of revision B in place of active embargo A, where B ends later than A. Implementations MUST NOT write any consent row to lapse a participant. A participant whose row for B is not AGREED is not a signatory to B, and has lapsed if it had agreed to A (CM-18-001).

Longer terms ask for more than the signatories of A promised, so only those who agreed to B are bound by B, and the rows say so without a write.
Refines: MSM-07-005
Uses definition from: CM-18-001
MSM-07-021 MUST NOT A revision proposal (EV, ACTIVE → REVISE, or a counter-revision REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force.

While a revision is merely proposed the prior embargo is still in force and every signatory to it is still bound by it, so nothing about their consent has changed (ADR-0093).
MSM-07-022 MUST When a participant proposes a revision, implementations MUST mark the proposer's row for the proposed embargo AGREED.

Proposing terms is agreeing to them, so the proposer needs no Invite of its own proposal.
Extends: MSM-07-021
MSM-07-023 MUST The CASE_MANAGER MUST commit each carried-over row as its own CASE_MANAGER Update(EmbargoConsent) ledger entry, after the Accept's entry. The owner's own row is what its Accept states, applied from the Accept's entry.

The CASE_MANAGER decides the carry-over. Committing each carried-over row as its own entry keeps every replica's consent rows in step with the CASE_MANAGER's.
Implements: EP-05-003
MSM-07-024 MUST Every replica MUST copy the CASE_MANAGER's carried-over consent entries rather than run the carry-over itself (ADR-0124, CLP-07-013, CM-23-016).

A replica that ran the containment comparison on its own state could reach a different answer from the CASE_MANAGER's.
Depends on: MSM-07-023
Refines: CM-23-016
See also: CLP-07-013 — context for the reader
MSM-07-006 MUST When an ET / REMOVE_EMBARGO_EVENT_FROM_CASE wire activity terminates the embargo register's ACTIVE entry, implementations MUST leave the case with no active embargo. The same step cancels every open proposal, so the derived EM becomes EXITED. No separate outbound wire activity is emitted; the participant position is derived from the case.

A register with a TERMINATED entry accepts no further change (ADR-0122), so a terminated embargo can never be invited to again. That is a fact about the case, which every replica holds once it replays the teardown.
Uses definition from: MSM-02-007
MSM-07-025 MUST NOT When an ET terminates the embargo register's ACTIVE entry, implementations MUST NOT write any participant's consent rows. With no active embargo no participant is a signatory and no row binds anyone. An Accept or Reject that arrives afterwards records nothing (EMB-17-004).

The termination is a fact about the case, so it does not need copying onto each participant record as a terminal consent state. Leaving the rows as they were also keeps the history of who agreed to what, and every row of a final entry is frozen (CM-18-003).
Extends: MSM-07-006
See also: EMB-17-004 — context for the reader
MSM-07-007 MUST The timer-based pocket-veto transition MUST be enforced lazily, with no outbound wire message for the consent change itself. That transition moves the row of the invitation whose deadline passed from INVITED to TIMED_OUT. A lapse has no timer path (CM-18-002): a lapsed participant is re-invited, and the deadline attaches to that invitation.

Inaction cannot produce an outbound message because there is no actor-observable event to report. The expiry is a derived conclusion from (the row's rsvp_deadline, now). Requiring a wire message would demand the system speak on behalf of a participant who has said nothing, which contradicts the Actor Knowledge Model (AKM).
Implements: CM-18-002
MSM-07-026 MUST The CASE_MANAGER MUST author a case-ledger entry that records a pocket-veto expiry (CM-28-005), so the consent change is visible in the canonical ledger. No other protocol wire activity is required.

The ledger entry is the record of the derived expiry, not a message sent by the silent participant. The entry already reaches every owner entitled to case content, so a second message would only duplicate it.
Refines: CM-28-005
MSM-07-008 MUST The wire activity ACTIVATE_EMBARGO_ON_CASE (wire form: Add(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST activate the named proposal's embargo register entry and supersede any entry in force in the same step. The derived EM becomes ACTIVE (EA, or EC for a revision).

Giving the owner's decision its own activity retires the two-audience rule: an Accept of an Invite is always the sender's consent (MSM-07-003), and this activity is always the owner's decision for the case, so neither meaning depends on who sent the message (ADR-0122). The activity is an Add because the case gains the embargo, as the Remove that ends it takes it away, so the decision and a consent differ by verb (ADR-0180). When it replaces an embargo in force, the MSM-07-005 consent rule settles the rows.
Uses definition from: VAM-05-008
MSM-07-027 MUST The CASE_MANAGER MUST accept ACTIVATE_EMBARGO_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Activating an embargo is the Case Owner's decision for the case (CM-02-005), so no other participant's activity may make it.
Extends: MSM-07-008
Refines: HP-01-006
MSM-07-028 MUST ACTIVATE_EMBARGO_ON_CASE MUST mark the Case Owner's row for the activated embargo AGREED when that row is UNINVITED, INVITED or TIMED_OUT. An AGREED row is left as it is, and an activation from a DECLINED row is refused (MSM-07-037).

The owner that activates terms is bound by them, so its own row has to say so. A row that holds no answer the owner gave, or only a lapsed invitation, contradicts nothing when it becomes AGREED, so the owner need not accept before it activates (ADR-0180).
Extends: MSM-07-008
Uses definition from: CM-18-003
MSM-07-037 MUST The CASE_MANAGER MUST refuse ACTIVATE_EMBARGO_ON_CASE before committing it when the Case Owner's row for the named embargo is DECLINED.

The owner's decline is an answer it sent and the ledger holds. An activation that moved the row to AGREED would make one activity both the case's decision and a change of the owner's own answer, so each would be read off the other (ADR-0180). An owner that changes its mind sends Accept(Invite(EmbargoEvent)) and then activates, and the ledger records each answer as it was given. The refusal's reported reason tells the owner to accept the invitation first (CLP-05-001).
Refines: MSM-07-028
MSM-07-038 MUST The CASE_MANAGER MUST refuse REJECT_INVITE_TO_EMBARGO_ON_CASE before committing it when its sender is the proposer of that embargo.

A proposer's row is AGREED because proposing terms is consenting to them (MSM-07-005), and it receives no invitation to its own proposal, so it has none to decline. An actor undoes an invitation it sent, with Undo(Invite(EmbargoEvent)), and rejects one it received (ADR-0152). Refusing the Reject keeps the proposer's row matching the proposal it still offers, so a Case Owner cannot decline its own proposal and then activate it. The sender-is-invitee check (EP-09-010) is what refuses it.
Refines: MSM-07-004
MSM-07-029 MUST The CASE_MANAGER MUST refuse ACTIVATE_EMBARGO_ON_CASE before committing it in two cases. One is a named embargo that is not an open proposal of the case. The other is CS that is public, exploited or attacked (EMB-02-002).

Refusing a doomed activation before the commit keeps the ledger free of an entry that replicas, copying its step, would apply without the CASE_MANAGER's P/X/A check (CM-23-016).
Extends: MSM-07-008
Refines: EMB-02-002
MSM-07-009 MUST The wire activity REJECT_EMBARGO_PROPOSAL_ON_CASE (wire form: Reject(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST reject the named proposal's embargo register entry. Once no other proposal is open, the derived EM becomes NONE (ER) or stays ACTIVE with the prior terms in force (EJ). It stays PROPOSED or REVISE while another proposal is open (EMB-18-005).

The owner's rejection decides the proposal for the case; whether the owner, as a participant, also refuses those terms is a separate Reject of the Invite (MSM-07-004). The owner's own row does not constrain the rejection: an owner that accepted terms for itself may still reject them for the case (ADR-0180). Keeping the two apart lets the owner keep the prior terms without declining them (ADR-0122).
Uses definition from: VAM-05-009
Uses definition from: EMB-18-005
MSM-07-030 MUST The CASE_MANAGER MUST accept REJECT_EMBARGO_PROPOSAL_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006).

Deciding a proposal for the case is the Case Owner's authority, so no other participant's activity may reject it for the case.
Extends: MSM-07-009
Refines: HP-01-006
MSM-07-031 MUST NOT REJECT_EMBARGO_PROPOSAL_ON_CASE MUST NOT change any participant's consent rows, the Case Owner's included.

The owner's decision for the case is not its consent as a participant; that is a Reject of the Invite (MSM-07-004).
Extends: MSM-07-009
MSM-07-032 MUST This rule covers REJECT_EMBARGO_PROPOSAL_ON_CASE of the last open revision while CS is public, exploited or attacked. The CASE_MANAGER MUST also terminate the embargo in the same act (EMB-04-002). It trial-applies both steps before committing either. It commits the Reject's entry carrying the REJECT step, then its own ET Remove(EmbargoEvent) entry carrying the TERMINATE step. A refused termination commits neither.

Reverting to the prior terms is not viable once disclosure has happened, so the rejection ends the embargo. Deciding both steps together means a replica copying both entries ends with the revision REJECTED and EM EXITED, as the CASE_MANAGER does.
Extends: MSM-07-009
Refines: EMB-04-002
MSM-07-033 MUST The CASE_MANAGER MUST refuse REJECT_EMBARGO_PROPOSAL_ON_CASE before committing it when the named embargo is not an open proposal of the case.

There is nothing to decide, and a committed entry naming no open proposal would be applied by every replica that copies it.
Extends: MSM-07-009
MSM-07-010 MUST The wire activity Leave(EmbargoEvent)[context=VulnerabilityCase] is a participant's withdrawal of its consent to the case's active embargo. For a sender whose row for that embargo is AGREED, the receiver MUST apply the PEC DECLINE trigger to that row. A Leave changes no register entry.

Accept and Reject answer an Invite; leaving an embargo one is bound by is a different act, as Leave(VulnerabilityCase) is for leaving the case. A dedicated activity covers every signatory, including those made signatories with no Invite (CM-14-005, CM-11-001), and keeps a Reject from meaning refusal or withdrawal by the state of the case. The rejected alternatives are recorded in ADR-0122.
Uses definition from: VAM-05-011
Uses definition from: CM-18-003
Implements: VP-13-017
MSM-07-034 MUST On a withdrawal (MSM-07-010), the receiver MUST also decline every open proposal's row that the sender had AGREED to. Every open proposal is a revision of the embargo withdrawn from (EP-08-004).

An agreed revision left in place would make the withdrawer a signatory again as soon as the owner activated it (MSM-07-035).
Implements: MSM-07-035
Extends: MSM-07-010
Derives from: EP-08-004
MSM-07-035 MUST NOT A DECLINED participant MUST NOT hold an AGREED row for an embargo that can become active without re-invitation.

A participant that has withdrawn from an embargo has to be asked again before terms bind it, or its withdrawal would be undone by an activation it took no part in.
MSM-07-036 MUST The receiver MUST refuse a Leave(EmbargoEvent), with a reported reason, in three cases. Its embargo is not the active one, the sender's row for it is not AGREED, or the sender is the Case Owner. The Case Owner ends an embargo by terminating it (CM-02-005).

Only a signatory of the embargo in force can withdraw from it, and the Case Owner holds the termination instead.
Extends: MSM-07-010
See also: CM-02-005 — context for the reader
MSM-07-011 MUST NOT An actor that receives ACCEPT_INVITE_TO_EMBARGO_ON_CASE MUST NOT change any embargo register entry for it, whoever sent it, the Case Owner included.

The Accept is the sender's consent (MSM-07-003), and the Case Owner's decision for the case is a separate activity (MSM-07-008, ADR-0122). If an Accept moved a register entry, one Participant's answer would decide the embargo for everyone (MSM-02-010).
Extends: MSM-07-003
MSM-07-012 MUST An available embargo is the case's Active Embargo or one of its open proposals, before its end time. An Accept, on time or late, may name an embargo the register holds but that is not available. That embargo was replaced, rejected, cancelled or terminated, or it is past its end time. The CASE_MANAGER MUST refuse that Accept before committing it, with the refusal notice that reports the reason (CLP-05-001). When the case holds terms of its own, the fresh Invite of EMB-17-003 goes with the notice.

The embargo the Accept names decides the answer, not the clock: an RSVP deadline says whether the invitation is open, not whether the terms bind (ADR-0065). Terms that can no longer bind record nothing (CM-18-003), and an ACTIVE entry past its end time binds nobody before the clock ends it. Refusing before the commit keeps the Accept off the ledger, and the notice tells the sender its answer is moot.
Supersedes: MSM-07-003 — In the case it names, the refusal replaces the AGREE
Uses definition from: CLP-05-001
MSM-07-039 MUST An Accept, on time or late, may name an embargo the case's register never held. The CASE_MANAGER MUST answer that Accept with Create(ProcessingFault) to its sender, not with the refusal notice (MSM-05-001). Nothing is ledgered for it, the fault included (ASK-07-008).

A sender that names terms the case never held has a wrong view of the case. Its Accept was received but not understood, which MSM-05-001 answers with a processing fault. A refusal notice would tell it that its answer is moot, which presumes the case once held the terms. The fault tells it to resynchronise instead.
Supersedes: MSM-07-003 — In the case it names, the fault replaces the AGREE
Refines: MSM-05-001
See also: ASK-07-008 — the fault is not ledgered
MSM-07-013 MUST NOT An actor that receives REJECT_INVITE_TO_EMBARGO_ON_CASE from any sender but the CASE_MANAGER MUST NOT change any embargo register entry for it, the Case Owner's Reject included.

Symmetric with MSM-07-011: the Reject is the sender's consent (MSM-07-004), and the Case Owner's rejection of a proposal for the case is a separate activity (MSM-07-009, ADR-0122). If a Reject moved a register entry, one Participant's answer would decide the embargo for everyone (MSM-02-010).
Extends: MSM-07-004
MSM-07-014 MUST An actor applying a Reject of the active embargo from the sender's AGREED row MUST refuse it, with a reported reason. That Reject is not consent withdrawal, which is Leave(EmbargoEvent) (MSM-07-010).

Leaving an embargo one is bound by is a different act with its own activity (MSM-07-010, ADR-0122), so a Reject never has to be read against the case's state to tell a refusal from a withdrawal. The reported reason tells the signatory to send Leave(EmbargoEvent) if it means to withdraw (CLP-05-001).
Supersedes: MSM-07-004 — In the case it names, the refusal replaces the DECLINE
See also: MSM-07-010 — context for the reader
MSM-07-015 MUST An actor that applies a Reject of a proposed embargo that is not active MUST leave the sender's row for the active embargo unchanged. A signatory's rejection of a proposed revision refuses those terms; it is not withdrawal from the embargo in force. When no embargo is in force (EM PROPOSED), a Reject of a proposal declines that proposal's row only. It withdraws from nothing, and the participant's AGREED rows for other open proposals stay AGREED.

Consent is per embargo, so a signatory who refuses proposed terms is still bound by, and still consents to, the embargo that remains active; only the Case Owner decides whether the proposal replaces it (MSM-07-009, ADR-0122).
Extends: MSM-07-004
MSM-07-016 MUST The CASE_MANAGER's own Reject of a proposal is its abandonment of the proposal (EMB-16-001). A replica MUST tell it from a participant's Reject by the payload's actor (ADR-0152).

A CASE_MANAGER act with a participant's verb and object carries the participant's semantic type (ADR-0152), so the CASE_MANAGER's abandonment and a participant's refusal share one. The abandonment cancels the proposal, and is ER (MSM-02-006); the refusal declines only the sender's row (MSM-07-004). Only the actor tells them apart.
Extends: MSM-07-004
Uses definition from: EMB-16-001
MSM-07-017 MUST A CASE_MANAGER can hold an embargo stake of its own (EP-09-002). It MUST record a change of its own consent as its Update(EmbargoConsent) of the row. MSM-07-018 bans recording it as a Reject(Invite(EmbargoEvent)).

The CASE_MANAGER's own consent is the row it changes (CLP-07-013). Recording it as an Update keeps every CASE_MANAGER-sent Reject an abandonment (MSM-07-016), so a replica never has to guess which one the CASE_MANAGER meant.
Uses definition from: VAM-05-015
See also: EP-09-002 — context for the reader
MSM-07-018 MUST NOT A CASE_MANAGER MUST NOT send or commit a Reject(Invite(EmbargoEvent)) as a change of its own consent.

Every CASE_MANAGER-sent Reject is its abandonment of the proposal (MSM-07-016, ADR-0152). A Reject sent as its consent would cancel the proposal for everyone.
Extends: MSM-07-017

Vocabulary Model

Requirements governing how ActivityStreams 2.0 vocabulary types are defined, registered, configured, and deserialized in the Vultron wire layer. The vocabulary model is the foundation of the inbound pipeline: every activity must be deserialized into a known vocabulary type before semantic extraction can assign it a domain meaning.

Type Auto-Inference
ID Priority Requirement Related
VM-03-005 MUST A Vultron extension type can refine an ActivityStreams core type. A sender MUST write the type of such an extension as the list [extension type, core type], such as ["Refuse", "Reject"]. Inside the sender, the object still has only the extension type.

The ActivityStreams Core extensibility guidance asks an extension type that overlaps a core type to carry the core type too. A plain ActivityStreams receiver that does not know the extension then still reads the message as the core type. Code that handles the message needs only one type: a list in code would change every type check for no gain (ADR-0196).
VM-03-006 MUST A receiver MUST read a type list, in any order, as the most specific type it knows, and ignore each term it does not know.

ActivityStreams allows type to be a list, and VM-03-005 sends one. The most specific known type is the one the sender meant, and a term the receiver does not know is an extension it cannot read, so ["Foo", "Reject"] is a Reject (ADR-0196).
Extends: VM-03-005
Refines: MV-01-001
VM-03-007 MUST A receiver MUST refuse, as an unknown type, a received type list that names two known types when neither is a subtype of the other.

When two known types are unrelated, the receiver cannot tell which one the sender meant, so it must not choose one (ADR-0196).
Extends: VM-03-006
Static Object Integrity
ID Priority Requirement Related
VM-08-003 MUST The copy of an activity recorded in the case ledger (the entry's payloadSnapshot) MUST be identical to the activity delivered to participants.

Ledger integrity requires that what is recorded and what is delivered are identical. A participant that holds both the delivered activity and the ledger entry can check this through the hash chain, so a ledger that records one form while recipients receive another is visible to them.
Unknown Message Handling
ID Priority Requirement Related
VM-09-001 MAY A receiver MAY keep a message that it cannot parse, or whose semantics are unknown, for human or agent review.

A receiver can get a message that it cannot parse or interpret, for example from a peer that runs a newer version of the protocol. If the receiver drops it, information that may matter to the case is lost and nobody can see that it arrived. Keeping it for human or agent review lets a person decide what it means. This is a MAY because the protocol does not define a meaning for such a message.
Vocabulary Namespace and JSON-LD Context
ID Priority Requirement Related
VM-10-001 MUST Outbound Vultron wire messages MUST set the top-level @context to exactly the list ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld"], AS2 first, or, for a signed message (SIG-01-001), to exactly ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld", "https://w3id.org/security/data-integrity/v2"]: the data-integrity context is the third and final entry, and no other context is added.

Derived from ADR-0069 (docs/adr/0069-vultron-namespace-uri.md). AS2 Core §2.1 asks every producer to reference the ActivityStreams namespace in @context, and an AS2 receiver that does not process JSON-LD, as most ActivityPub software does not, recognizes a message by finding that exact string. The Vultron context declares the CVD-specific types (VulnerabilityCase, EmbargoEvent, etc.) that the ActivityStreams namespace does not. The Vultron context document also imports AS2, but a receiver need not dereference it (VM-10-003), so citing the Vultron URI alone hides the AS2 reference from a plain-JSON receiver.
Uses definition from: SIG-01-001
VM-10-003 MUST NOT A receiver MUST NOT require dereferencing the Vultron JSON-LD context URI (VM-10-001) to process a message.

A receiver reads Vultron's compact JSON form and needs no JSON-LD expansion, so the context URI is an identifier, not an input. A fetch per message would also make processing depend on the network and on the host serving the context. Today the URI does not resolve at all: the context document is withheld until it is served at the wire-versioned path ADR-0106 defines, so a receiver that fetched it would fail on every sender's message.
Uses definition from: VM-10-001
VM-10-004 SHOULD NOT An object nested inside an outbound Vultron message SHOULD NOT restate the message's @context (VM-10-001).

JSON-LD applies a document's context to every object nested in it, so a restated context adds bytes and changes nothing about how a nested term expands. Leaving it out also keeps a reader from taking a restated context for a different one.
Refines: VM-10-001

Message Validation

Requirements for validating ActivityStreams 2.0 activities at the inbox handler boundary, covering ActivityStreams structure and semantic validation. Invalid activities are rejected with appropriate error responses before dispatch.

Required Field Validation
ID Priority Requirement Related
MV-03-001 MUST The system MUST validate required fields based on activity type

Each activity type needs some fields to have a meaning. For example, an Accept with no object accepts nothing. A check for each type refuses such an activity at the edge. Thus handlers do not need to check for a missing field that their activity type requires.
MV-03-002 MUST A receiver MUST report a present but blank required field as an omitted field, and a non-blank unparseable value as a schema fault. A blank value is an empty string or one containing only whitespace.

A blank value has no data, so it is the same omission as a missing key (CS-08-001: if present, then non-empty). One omission must cause one error and one status code, whatever its form. If a guard tests only the key, a blank published goes on to schema validation, which gives a Pydantic error dump in place of the explanation in CLP-15-008. A value that is not blank but does not parse is a different fault, so it stays on the schema path.
Refines: MV-03-001
Object Type Validation
ID Priority Requirement Related
MV-04-001 MUST A receiver MUST refuse at parse an activity whose own type resolves to no wire activity class in the Vultron vocabulary.

The activity type decides which patterns can match an activity. A receiver cannot classify an activity whose type it does not know, so it refuses it before dispatch. An inline object of unknown type is left to its parent field (MV-04-004): a Create of a FooWidget parses as a plain as_Object and, if no pattern matches, is UNKNOWN (VAM-01-007). This keeps the extensibility of MV-11.
MV-04-002 SHOULD For Create-style activities that create sub-objects (e.g., Create(EmbargoEvent)), the activity name field SHOULD be a descriptive human-readable string identifying the actor, created object ID, and context (case ID)

A person who reads a log or a timeline cannot learn much from ids alone. The ids in a Create of a sub-object do not show who created which object in which case. A descriptive name lets an operator read the activity without a lookup of its ids.
URI Validation
ID Priority Requirement Related
MV-05-002 MUST The system MUST treat ActivityStreams object IDs as opaque URIs

An id identifies an object and carries no other meaning, so a receiver that reads structure into it depends on how one sender mints its identifiers. ActivityStreams 2.0 and ActivityPub require an id to be an IRI (MV-05-001) but say nothing about opacity, so the rule is not inherited: it is Vultron's own, binding every implementation that receives another's identifiers. A stub Invite names its case by the id of the case reference that is its object, which is the case's own ID, not an ID a receiver parses (CM-11-003, ADR-0205).
Outbound Activity Object Integrity
ID Priority Requirement Related
MV-09-001 MUST The object of an outbound Vultron activity MUST let its recipient determine the activity's semantic type: it is carried inline as a typed object, or by a reference the recipient can dereference to a typed object (AKM-05-003, AKM-05-004).

A recipient routes an activity by its activity type and the type of its object (SE-01-001). If the recipient cannot read the object inline or get it by its URI, it cannot classify the activity. It then cannot act on the message.
Uses definition from: AKM-05-003
See also: AKM-05-004 — context for the reader
Stub Objects
ID Priority Requirement Related
MV-10-001 MUST A stub object, the case's preview (MV-10-012), MUST carry at minimum an id field (full URI), a type field and a non-empty summary field that gives human-readable context.

The stub form has one narrow purpose. It is not a replacement for a full object. An invitee must decide whether to join a case before it can receive the case (MV-10-005). The stub previews the case until the participant is active (CM-10-004): it is the preview of the case reference the stub Invite carries as its object (ADR-0205). The summary tells the invitee which case it is asked to join. The sender decides what the summary says (CM-17-020).
See also: MV-10-012 — the case reference whose preview the stub is
MV-10-007 MUST A receiver MUST refuse a stub whose summary is absent or blank.

A stub with no summary gives the invitee nothing to decide on, so it cannot do the one job the stub form exists for (MV-10-001).
Derives from: MV-10-001
MV-10-008 MUST A receiver MUST classify a stub by its type. The stub form is permitted only for a case, as the case's preview of the distinct CasePreview type of CM-11-013.

No other type needs the stub form, and no other stub type is implemented. A classification by the fields present would read a sparse case as a stub, or a stub as a case.
Extends: MV-10-001
Uses definition from: CM-11-013
MV-10-009 MUST This rule covers an object type other than a case, when the sender does not inline the full object. The sender MUST reference the object by URI, by an ActivityStreams Link or by a typed reference (MV-10-011), not by a partial inline object. An object inside a preview is exempt: the preview shows as much of it as the sender chooses (MV-12-006).

Only a case has a stub form (MV-10-008). A partial inline object of another type claims to be the object while it lacks fields, so the receiver cannot tell what the sender left out. A typed reference claims only the id and type the sender knows, and its type lets a receiver route the activity. A receiver that needs the object fetches it from its holder (AKM-05-007). The actor reference (AKM-05-017) is the typed reference of an actor (ADR-0198).
Derives from: MV-10-008
MV-10-011 MUST A receiver MUST read an inline object with exactly an id, a type and an optional preview as a typed reference of that type, unless the object sits inside a preview in a field that declares a loose form, which reads it as that form (MV-12-006). It routes the activity by the reference's type. It never reads the reference as the object: a handler uses the object the receiver holds, or fetches it (AKM-05-007), unless the reference carries a preview, which the receiver reads as received (MV-10-013).

A bare URI carries no type, so a receiver must fetch the object before it can classify the activity. A typed reference lets it classify first and fetch only when a handler needs the content. The shape alone tells a reference from a whole object: any other key makes the object a whole object, which is refused when it fails its class (MV-04-003), so a broken object is never read as a reference (ADR-0198).
Extends: MV-10-009
See also: AKM-05-007 — the fetch a handler relies on when the receiver lacks the object
MV-10-012 MUST A receiver MUST refuse a typed reference (MV-10-011) that carries a preview, naming its position, unless the protocol defines a preview for the reference's type and the preview is that preview, carried inline. The case is the one type with a defined preview: a case reference's preview is a CasePreview (CM-17-010).

A preview is a limited view of an object for a recipient that may not hold it (ADR-0193), and what it may carry depends on the type. A preview of a type with no defined preview would be read by no rule, so it is refused rather than carried unchecked (ADR-0198). The case's preview is what an invitee decides on before it may see the case, so the stub Invite carries it (ADR-0205). Its recipient may not hold the case nor be entitled to fetch it, so a preview given by URI tells it nothing.
Extends: MV-10-011
See also: CM-17-010 — the stub's contents, which are the case's preview
MV-10-013 MUST NOT A receiver MUST NOT read a typed reference that carries a preview (MV-10-012) as the object it names. It does not put the object it holds in the reference's place, does not fetch that object (AKM-05-007), and seeds or updates no replica from the reference (PCR-02-003).

A preview is a limited view for a recipient not yet entitled to the object. The stub Invite and the full-case Invite both name the case and differ only in this form (ADR-0205). A CASE_MANAGER that expanded the reference into the case it holds would read an Accept of the stub Invite as an Accept of the full-case Invite. An invitee that fetched the case would ask for what it may not yet see. A replica built from a preview would be a hollow case.
Extends: MV-10-011
See also: MV-10-012 — the previews a receiver accepts, which this rule reads as received
See also: AKM-05-007 — the fetch this rule withholds for a previewed reference
See also: PCR-02-003 — the replica a full case seeds and a preview never does
MV-10-002 MUST A CasePreview object is ONLY permitted as the preview of a case reference (MV-10-012) that is an Invite's object, wherever that Invite is carried inline: for example inside its Accept or Reject, or inside a refusal notice that quotes such a reply. A receiver MUST refuse an activity that carries a stub in any other position, naming each position.

The stub exists so that an invitee can decide whether to join a case before it is entitled to the case (MV-10-001, ADR-0114). The stub Invite is the one message that asks that question, and the stub is the case's preview there (ADR-0205), so that is the stub's one position. Anywhere else the sender names the case by its URI or a Link, or carries it whole. A stub there would stand in for a case the activity needs whole, or show case context to a party that was not asked to join. The stub's former position, an Invite's target, now names the invitee, so a stub there is refused too.
See also: MV-10-012 — the case reference whose preview the stub is
MV-10-005 MUST A participant MUST be active (CM-10-004) before the CASE_MANAGER delivers full case details to it.

Full case details can include embargoed vul information. An active participant has joined the case and has not been removed. When an embargo is active, it has also agreed to that embargo (CM-10-004). Thus no actor gets the details before it joins, or before it agrees to the active embargo.
Uses definition from: CM-10-004
Redaction Marker in Previews
ID Priority Requirement Related
MV-12-001 MUST A receiver MUST read a Redacted marker anywhere inside a preview as a value the sender has but does not show, never as a missing or empty value. A preview is a partial view of an object for a recipient who may not see all of it yet, such as the case stub (MV-10-001).

An invitee decides whether to join a case from the invitation alone (MV-10-005), so it gains from telling "this case has no score yet" from "this case has a score you cannot see yet". Read as None, the marker would say the first when the sender meant the second.
Extends: MV-10-001
MV-12-002 MUST A receiver MUST refuse an activity that carries a Redacted marker outside a preview, naming where the marker is.

A full object validates its required fields at construction, and the CASE_MANAGER's stored case is the authority every replica copies. A marker in a full object would widen every field to "a value or a marker" and could reach the stored case. The shared, hash-chained ledger could not carry a different redaction per recipient in any case, so a field withheld in a full object would be withheld from the whole case.
Constrains: MV-12-001
MV-12-003 MUST A Redacted marker MUST carry type Redacted and no field other than an optional summary, which gives the reason the value is withheld.

A marker that carried the withheld value, or an id naming it, would disclose what it exists to withhold. AS2's own summary carries the reason, so the marker needs no new property.
Refines: MV-12-001
MV-12-004 SHOULD A sender building a preview SHOULD leave a withheld field out unless the recipient needs to know that the field has a value, in which case it marks the field Redacted.

A marker discloses that a value exists, and that is often the sensitive fact, as when a case marks its exploit details withheld. Leaving the field out discloses nothing the sender did not choose to disclose.
Refines: MV-12-001
MV-12-005 MUST NOT A sender MUST NOT put any field other than type and summary in a Redacted marker.

A marker with more fields may carry the very value it stands in for. Only the sender can keep that value out: by the time a receiver sees the marker, the value has already been sent.
Constrains: MV-12-003
MV-12-006 MUST NOT A receiver MUST NOT refuse an activity because an object inside a preview lacks a field that a full object of its type requires.

A preview shows what its sender chose to show. The recipient reads it and decides on the invitation that carries it; what the preview leaves out of an object it shows is not a fault in the message. A vul item shown by its identifiers alone, with no id or published of its own, is read as shown.
Refines: MV-12-001
Supersedes: OID-01-013
Supersedes: CLP-15-011
Supersedes: MV-04-003
Supersedes: CLP-15-010
Supersedes: MV-10-011
Supersedes: MV-10-009

Semantic Extraction

The inbox handler extracts semantic meaning from ActivityStreams activities by matching activity type and object type patterns. This semantic type determines which handler function processes the activity.

Target-Field Discriminators
ID Priority Requirement Related
SE-08-003 SHOULD When two semantics are discriminated only by a target-field value, a dedicated wire object type (e.g. CaseParticipantRole) SHOULD be preferred over target-field discrimination so that the wire shape is unambiguously self-describing without depending on the order in which a receiver tries its patterns.

When patterns use only the target field to tell activities apart, a sender that omits the target causes a silent routing error. This sender can be minimally conformant or have a defect. The pattern order of the receiver is then its only protection. A distinct object type removes this risk, and the wire shape then tells its own meaning (ADR-0039). Offer(CaseParticipantRole)[context=VulnerabilityCase] is the canonical example. See notes/activitystreams-state-update.md § "Patterns Sharing a Verb and Object Need a Strict Discriminator".
Constrains: SE-08-001

Actor Knowledge Model

Defines the Actor Knowledge Model: a Vultron Actor's knowledge of the world is strictly bounded by the ActivityStreams 2.0 activities it has received. Actors must not assume recipients hold objects that were not explicitly included in prior activities; DataLayer access is private and non-shareable, and all inter-Actor communication occurs exclusively through the AS2 wire protocol.

DataLayer Isolation
ID Priority Requirement Related
AKM-01-002 MUST NOT Co-located actors MUST NOT communicate by reading or writing each other's local state, or by calling into each other directly. Co-located actors share a server or a process.

A direct shortcut between co-located actors bypasses the inbox pipeline, so its exchanges skip validation, the addressee and entitlement gates, and the case ledger, and leave nothing a remote participant would receive.
Derives from: PCR-01-003
AKM-01-003 MUST Co-located actors MUST still exchange protocol messages through each other's inboxes. Co-located actors share a server or a process.

Delivery through inboxes makes co-location invisible to the protocol: the same actors behave the same whether or not they share a process.
Extends: AKM-01-002
Knowledge Boundaries
ID Priority Requirement Related
AKM-02-001 MUST NOT An Actor MUST NOT assume that a recipient has knowledge of any object that has not been explicitly included in a prior activity sent to that recipient.

A recipient holds only what it has been sent. An activity that relies on an object the recipient never received cannot be processed, or is processed against a guess, so a sender must reason from what it has actually delivered to that recipient.
AKM-02-002 MUST NOT Actors MUST NOT name an object the recipient cannot be expected to hold already by a reference the recipient cannot dereference (AKM-05-003, AKM-05-004). Such an object is carried inline, or by a reference the recipient can fetch.

A reference the recipient can neither match to an object it holds nor fetch leaves it unable to read what the activity acts on, so it must refuse the activity or guess. Carrying such an object inline, or by a reference the recipient can fetch, keeps every activity processable by its addressee.
Uses definition from: AKM-05-003
See also: AKM-05-004 — context for the reader
AKM-02-003 MUST A case named in an activity's target MUST be the case URI.

A participant or CASE_MANAGER addressed about a case already holds it and needs only its URI. An actor that does not yet hold the case is told of it by the stub Invite, whose object is the case's reference carrying the case's preview (CM-11-013), so no case travels in a target as anything but its URI (ADR-0205).
Uses definition from: CM-11-013
AKM-02-008 MUST NOT An actor MUST NOT send a full case in an activity's target.

A full case in target would either repeat what the recipient holds or hand case contents to an actor that has not joined.
Derives from: AKM-02-003
AKM-02-006 MUST NOT An actor MUST NOT record or send a value it does not know for a field of an object it did not author. It leaves such a field absent. A published or updated time read from its own clock is such a value, as is an inbox or outbox derived from another actor's id.

A receiver cannot tell an invented value from an asserted one, so it records the invention as the object's own claim, and the case ledger then carries it in its snapshots. A value read from the sender's clock also differs on every build, so a rebuild of one activity under the same id does not match the first build (OX-06-002).
Outbound Activity Object Integrity
ID Priority Requirement Related
AKM-03-001 MUST Outbound initiating activities (Create, Offer, Invite, Announce, Add, Remove, Update, Join, Ignore, Leave) MUST carry, as their object, the domain object they act on, inline or by reference.

A receiver identifies what an initiating activity does from its type together with the type of its object. Without the object it cannot select the use case or apply the change. Inline or by reference leaves the form to the implementation (AKM-05-003), except where a rule fixes it, as CBT-01-002 does for the bootstrap.
Actor Addressing and Resolution
ID Priority Requirement Related
AKM-05-003 SHOULD An implementation SHOULD support object dereference: fetching the full object named by a URI through an API call to the actor or service that holds it.

Several rules let a sender name an object by reference instead of inlining it, and each is sound only where the receiver can resolve the reference. The CP-01-009 by-reference actor form is one. A prototype may inline everything and resolve nothing, so the capability is a SHOULD there (AKM-05-004 makes it a MUST in production).
AKM-05-004 MUST A production implementation MUST support object dereference (AKM-05-003). Given a URI it has not seen, it then fetches the object through an API call.

A production deployment exchanges cases with independently built implementations, which may name objects by reference instead of inline. Without dereference it cannot process such an activity, and the refusals that stand in for dereference (AKM-05-003) would block legitimate traffic.
Refines: AKM-05-003
AKM-05-007 MUST A receiver MUST fetch an object it lacks, and needs to process a received activity, from the actor that holds it. A case's object is held by the case's CASE_MANAGER, and an actor's profile by that actor. An object the protocol requires inline, as it does the bootstrap's case and participant records (CBT-01-002, CBT-01-007), is not fetched. A bootstrap missing a participant record is refused (CBT-05-008).

A sender may name by reference an object its receiver is expected to hold (CLP-07-006, AKM-02-002), and a replica that lacks it, through a gap or a lag, would otherwise refuse or drop an activity that was sound. The bootstrap is the exception: its receiver trusts no CASE_MANAGER until it accepts the bootstrap, so it has no trusted source to fetch from, and the bootstrap carries inline what the receiver cannot already hold instead (ADR-0170).
Implements: AKM-05-003
Refines: CLP-07-006
See also: CBT-01-002 — context for the reader
See also: CBT-01-007 — context for the reader
See also: CBT-05-008 — context for the reader
AKM-05-010 MUST While a fetch under AKM-05-007 is open, the receiver MUST defer the activity, held as received. It does not process the activity without the object, and does not drop it.

Deferring keeps the activity, as the inbox keeps one whose case is not yet known (PCR-06-001), so the activity is processed once, with the object, when the fetch settles.
Extends: AKM-05-007
AKM-05-011 MUST A receiver MUST NOT fetch an object from itself, or the entry an Add(CaseLedgerEntry) carries.

The CASE_MANAGER holds the canonical case, so nobody holds a case object it lacks. Replication carries its entries inline (SYNC-02-005), and replay needs no fetch.
Extends: AKM-05-007
AKM-05-012 MUST A receiver MUST keep a fetched case object only when it holds no record under the object's id (MV-10-003).

A fetch answers an object the receiver lacked; a record that arrived meanwhile is the receiver's own, and a fetched copy must not overwrite it (MV-10-003).
Extends: AKM-05-007
Refines: MV-10-003
AKM-05-005 MUST When a sender carries an actor inline in an activity, the inline actor MUST be the sender's held profile of that actor, as held.

A held profile is what the sender knows of the actor. Anything added to it on the way out would be invented (AKM-02-006).
AKM-05-017 MUST When a sender holds nothing more than an actor's URI, it MUST carry an actor reference instead of a profile. An actor reference is an inline object with exactly the actor's id and a type.

A sender may name a peer it knows only by URI (AKM-05-001), and a receiver routes Offer(Actor) by the object's type, so the actor must travel inline with a type even when nothing else is known. Anything beyond the id and type would be invented (AKM-02-006). The reference only gets the activity routed: a receiver that needs the actor's profile fetches it from the actor before it processes the activity (AKM-05-007). The actor reference is the typed reference of an actor (MV-10-011, ADR-0198).
Refines: AKM-05-005
Refines: MV-10-011
AKM-05-018 MUST A receiver MUST read each field that an actor reference lacks as unknown.

A reference says nothing about the fields it lacks. A receiver that read a missing field as empty would record a value nobody asserted.
Uses definition from: AKM-05-017
AKM-05-019 MUST NOT A receiver MUST NOT let an actor reference replace a fuller record of that actor that it holds.

A reference says nothing about the fields it lacks, so it cannot erase a value the receiver already holds.
Uses definition from: AKM-05-017

Code Style Specifications

Defines code formatting, import organization, and coding style standards for Python code in the Vultron project.

Datetime and Timezone Conventions
ID Priority Requirement Related
CS-13-005 MUST A wire timestamp this node generates MUST serialize with a UTC offset (Z or +00:00). A timestamp carried from a peer MUST serialize with the explicit offset it arrived with, which need not be UTC (CLP-15-007).

UTC is the form every node can write without configuration. A carried timestamp is part of an activity that the case ledger records verbatim (CLP-07-011). A change from +05:00 to +00:00 keeps the instant but changes the offset, so replicas then hold different records. What this rule keeps is the offset value, not the spelling a peer chose for it: Z and +00:00 are one offset, and a carried Z serializes as +00:00 because that is the only form format_timestamp writes. This rule picks the offset only; CS-13-006 holds the separate rule that every wire timestamp has an explicit offset, and CS-13-007 fixes its fractional-second digits, which a carried timestamp takes like any other.
Depends on: CLP-15-007
Refines: CS-13-006 — picks which explicit offset a wire timestamp carries
CS-13-007 MUST Every datetime this node serializes MUST be written as an RFC 3339 date-time with exactly six fractional-second digits, whether or not its microseconds are zero.

The case ledger hashes and compares timestamp text, so one instant at one offset needs one string. Whole seconds gave one string but made two acts one actor sends in the same second carry equal times; the fixed six-digit form keeps that one string and keeps the order. It fixes the fraction only: a carried timestamp keeps its own offset (CS-13-005, CLP-15-007), so the same instant at another offset is still another string. The form is what this node writes, not what it requires to receive: a peer may send whole seconds (ADR-0167).
Refines: CS-13-006 — fixes the fractional-second digits of the RFC 3339 form
Constrains: CLP-15-007 — A receiver carries a nested inbound timestamp as received, including at rendering, but writes its fractional digits in this node's one form. The instant and the offset are the peer's; the number of digits is not.

Object ID

Requirements for the format and handling of object identifiers throughout the Vultron system. Establishes full-URI IDs as the canonical form for all ActivityStreams objects and DataLayer records.

ID Format
ID Priority Requirement Related
OID-01-010 MUST A receiver MUST treat two messages whose actor URIs are equal once a trailing slash is removed from each as coming from the same actor.

Actor ids are full URIs (OID-01-001), and two implementations that disagree on which messages share an actor disagree on who did what. The equality is the one a receiver normalises to (OID-01-006). This rule states identity, not trust: whether a message really comes from the actor it names is the signing work (ADR-0164). Revisit it when signing lands, in case identity should follow the signing key.
Uses definition from: OID-01-001
OID-01-013 MUST A receiver MUST refuse a received message that embeds an ActivityStreams Object without an id, at any depth. A Link carries no such requirement, and neither does an object inside a preview (MV-12-006).

ActivityPub requires every object it distributes to carry a unique global identifier. Its one exception, an intentionally transient object, does not fit case data that participants replicate and cite. OID-01-001 states the sender's side of that rule, and this states the receiver's. A Link is not an Object: AS2 names its resource by href.
Refines: OID-01-001
OID-01-014 MUST NOT A receiver MUST NOT mint an id for a received object or Link.

A minted id would present the receiver's own invention as the sender's object, and it would differ on every receiver of the same message. A received Link that omits its id keeps none. An object or Link this process builds is still given a minted id (OID-01-004).
Refines: OID-01-013

CSAF Documents in Reports

Requirements for a Common Security Advisory Framework (CSAF) 2.1 document that travels as an attachment of a VulnerabilityReport: how it is carried and recognized, the one occasion on which a receiver may read it as the sender's statement (the initial Offer of a report), how its fields map onto the inputs of the case created from that report, and how this codebase checks documents against a CSAF 2.1 draft that is still changing. Producing a CSAF document from a case (a projection) is out of scope (#5134).

Carrying a CSAF Document in a Report
ID Priority Requirement Related
CSAF-01-001 MUST A sender that includes a CSAF document with a VulnerabilityReport MUST carry it as a Document object in the report's attachment, with the JSON text of the CSAF document as the content of that Document.

AS2 content is a string, so the report's own content cannot hold a JSON object, and the report's text stays readable by a receiver that does not read CSAF. An attachment list also lets one report carry the CSAF document beside other files, in the way ActivityPub servers attach media to a note. Inline content keeps the document inside the signed activity (SIG-01-003) and inside the copy that the case ledger records.
CSAF-01-002 MUST The Document that carries a CSAF document MUST have the mediaType application/json.

CSAF registers no media type of its own, and the distribution feeds that the CSAF draft defines label each CSAF document application/json. A media type that only Vultron invented would mean nothing to other tools.
Extends: CSAF-01-001
CSAF-01-003 MUST A receiver MUST recognize an attached document as CSAF 2.1 from the document itself, by its $schema value and its document.csaf_version value.

application/json does not tell CSAF apart from other JSON. The CSAF 2.1 schema fixes both values, so they identify the format, and document.category then names the profile.
The Sender's Statement at the Initial Report
ID Priority Requirement Related
CSAF-02-001 MAY A receiver MAY fill a value that an initial Offer(VulnerabilityReport) and its report leave unstated from a CSAF document of category csaf_vulnerability_report attached to that report. The Offer is initial when its report belongs to no case at the receiver.

At the first report the CSAF document is the sender's own account of the report, made for this exchange by the CSAF Vulnerability Report profile, so it can supply what the Vultron fields leave out. Reading it stays optional: a receiver that treats the document as opaque still handles the report.
CSAF-02-002 MUST NOT A receiver MUST NOT change case data from a CSAF document other than the one that CSAF-02-001 names: a document on another activity, on a report that already belongs to a case, in a vulnerability item, or of another category.

Participants produce CSAF documents from their copies of a case and share draft advisories in CSAF. Such a document is a result of the case, so reading it back as a statement would let a projection rewrite the case it describes. The case changes only through Vultron's own activities. A Create(CaseProposal) that carries the initial Offer (CP-01-008) is not another activity in this sense: the proposer and the CASE_MANAGER are two roles of the one coordinating function that received the report, so the CSAF document on that Offer is still the initial report reaching it. The proposer may read it first and state the case inputs on its proposal, and the CASE_MANAGER reads the document only when the proposal states none.
Uses definition from: CSAF-02-001
CSAF-02-003 MUST When the Offer or its report states a value and the attached CSAF document states a value for the same thing, the receiver MUST use the value of the Offer or the report.

The Vultron fields are the sender's statement in the protocol, and the CSAF document is the material the report describes. One rule for every field keeps a receiver from weighing two answers, for example a proposedEmbargo against a disclosure_date.
CSAF-02-004 SHOULD A sender SHOULD give the report's name, its summary and the Offer's proposedEmbargo values that agree with the CSAF document it attaches.

A sender is free to fill the Vultron fields as it chooses, and CSAF-02-003 makes them win. Values that agree with the attachment keep the two accounts of one report from contradicting each other.
CSAF-02-005 MUST NOT A receiver MUST NOT take a value that the CSAF document does not contain as a statement by the sender, including a default that the CSAF schema declares.

An omitted field states nothing, so the case input falls back to what the receiver does for a report with no CSAF document. A schema default, such as the TLP label CLEAR, is filled in by a parser and was never sent.
CSAF-02-006 MUST NOT A receiver MUST NOT refuse an Offer(VulnerabilityReport) because its attached CSAF document cannot be read or fails the CSAF 2.1 schema.

The report is valid or invalid by the receiver's report-validation decision, not by the form of one attachment, and refusing would leave a real vulnerability unreported. The receiver reads what it can (CSAF-04-003).
CSAF-02-007 SHOULD NOT A sender SHOULD NOT attach a CSAF document that fails the CSAF 2.1 schema.

A sender is strict in what it sends and a receiver lenient in what it accepts (CSAF-02-006). A schema-valid document lets every receiver read it the same way.
Case Inputs From the Initial Report
ID Priority Requirement Related
CSAF-03-001 MUST A receiver that fills case inputs from a CSAF document (CSAF-02-001) MUST take a vulnerabilities[].disclosure_date later than the time the case is created as the end of the sender's proposed embargo, when the Offer carries no proposedEmbargo.

The CSAF 2.1 draft says that a future disclosure date indicates the intended date for disclosure, also called the embargo date, and the Vulnerability Report profile uses it to coordinate that date. It then competes with the receiver's own default as any proposed embargo does (EP-04-003).
Uses definition from: CSAF-02-001
CSAF-03-002 MUST When several vulnerabilities in the document have a future disclosure_date, the receiver MUST take the earliest of them as the end of the proposed embargo of CSAF-03-001.

One case has one embargo. The earliest date honors every vulnerability's intended disclosure, in the same way that the shorter term wins between two parties (EP-04-003).
Extends: CSAF-03-001
CSAF-03-003 MUST A receiver that fills case inputs from a CSAF document MUST take a disclosure_date no later than the time the case is created, on any vulnerability, as a statement that the vulnerability is public (P).

The CSAF 2.1 draft defines a past disclosure date as the time the vulnerability was disclosed to the public. A case cannot hold an embargo for one vulnerability while another in the same report is public, so a case created with P set starts with no embargo (EP-04-020).
CSAF-03-004 MUST A receiver that fills case inputs from a CSAF document MUST take an SSVC Exploitation value of PoC, on any vulnerability, as a statement that an exploit is public (X), and a value of Active as a statement that attacks are occurring (A).

The SSVC Exploitation decision point maps onto the CS model in both directions (the SSVC crosswalk): None means neither X nor A, PoC means X without A, and Active means A. None therefore states nothing to set.
CSAF-03-005 MUST A receiver that fills case inputs from a CSAF document MUST take an entry in vulnerabilities[].first_known_exploitation_dates, on any vulnerability, as a statement that attacks are occurring (A).

Each entry records when an exploitation happened, which is an observed attack in the CS model.
CSAF-03-006 SHOULD A case created from a report SHOULD start with the report's name and summary as its own.

The report is the first account of the case, and other CVD tools start a case from the report in the same way. The case can change its name and summary later.
CSAF-03-007 MUST A receiver that fills case inputs from a CSAF document MUST take a name that the report leaves unstated from document.title, and a summary that the report leaves unstated from the document-level note of category summary, or else of category description.

Every CSAF document has a title that names the whole document, and a document-level note describes the whole report, so neither depends on which of several vulnerabilities a reader picks.
Extends: CSAF-03-006
CSAF-03-008 SHOULD A receiver that fills case inputs from a CSAF document SHOULD give the case a vulnerability item for each entry in vulnerabilities[] that has a cve or an ids entry, with the entry's ids, notes and references, its cve as an ids entry whose system_name is CVE, and its title as the item's name.

A vulnerability item takes the identity fields of a CSAF vulnerability entry (CM-05-018), so each entry becomes an item with only its title renamed to the AS2 name that means the same (ADR-0194), and its cve folded into ids, where the item keeps every identifier; a projection back to CSAF returns that entry to cve. The identifiers are what later messages and projections refer to (CM-05-003, ADR-0187), so an entry with no identifier names no vulnerability and makes no item.
CSAF-03-009 SHOULD A receiver filling case inputs from a CSAF document SHOULD give the case one case reference per document.references[] entry. The entry's url is the href of the reference's url Link, and its summary is the reference's name.

A document-level reference is about the whole report, so it belongs to the case; a vulnerability's own references go on its vulnerability item (CSAF-03-008). The profile uses references for evidence of exploitation (CM-05-004, CM-05-005, ADR-0187).

14.3 Report, Embargo and Case State Behavior

The requirements on the state machines and on how a participant behaves in each state: Report Management (RM), Embargo Management (EM), embargo policy, durations, and the Case State (CS) model.

State Machine

Requirements governing how the RM (Report Management), EM (Embargo Management), and CS (CVD Case State: VFD and PXA axes) protocol state machines are defined, represented, and executed at runtime. Each participant maintains its own RM state; the CASE_MANAGER maintains shared EM and Case State. Within CS, the PXA axis is shared across participants while the VFD axis is per-participant.

Wire and DataLayer Compatibility
ID Priority Requirement Related
SM-08-001 MUST State values MUST be transmitted on the wire as the state's bare label string (for example RECEIVED, ACTIVE, Vf, D, pxa), never as an integer or as a qualified form such as RM.RECEIVED.

Other implementations must read the state values in a message. A bare label, such as RECEIVED or pxa, is the value of the state itself, and any implementation can match it. An integer depends on the order of an enum in one implementation, and a qualified form such as RM.RECEIVED depends on its code names. Neither form is part of the protocol.
CS Forced Transitions and Reachable States
ID Priority Requirement Related
SM-09-002 MUST NOT Not yet in the reference implementation (tracked by #3355)

The CS state machine MUST NOT allow a state in pattern vF* (fix ready, vendor unaware) or *fD* (fix deployed, fix not ready).

A vendor cannot have deployed a fix (D) without first having one ready (F); a fix cannot be ready (F) if the vendor is unaware (v) of the vulnerability. Together, SM-09-001 and this rule reduce the theoretical 64-state CS space to the 32 reachable CS states: 4 valid VFD combinations (vfd, Vfd, VFd, VFD) × 8 PXA combinations. See docs/reference/formal_protocol/states.md for the formal derivation. Note: the "40-state" figure in the formal protocol paper refers to the global case state space (8 PXA × 5 EM), not to CS alone.
SM-09-004 MUST Not yet in the reference implementation (tracked by #5636)

A receiver MUST reject a CS state in the vF* or *fD* pattern (SM-09-002) at validation time.

These 32 states are structurally impossible. A receiver that rejects them at validation time keeps them out of every store and replica.
Implements: SM-09-002
State Scoping Rules
ID Priority Requirement Related
SM-10-001 MUST A message that moves a participant-specific machine (RM, VF or D) MUST move it for the participant whose state the message's occasion declares (ADR-0162). For a participant-status message, that participant is the sender (CM-04-001, CM-04-002). For a report's receipt, it is the receiver, whose own RM moves to RM.RECEIVED.

RM and VFD state describe the progress of one participant, so each participant's RM and VFD state evolves independently. A status message reports its sender's state; other messages move the receiver's own. No rule on the machine alone tells which, so each occasion declares it. A record on the wrong participant would give it progress it did not make.
SM-10-002 MUST EM and PXA state transitions MUST update the shared CaseStatus record for the associated VulnerabilityCase. These axes are participant-agnostic: a single shared value covers all participants in the case.

EM and PXA state are facts about the case, not about one participant (CM-04-003, CM-04-004). One shared record gives every participant the same embargo state and the same public state. Separate copies for each participant could disagree on whether an embargo is in force or whether the vul is public.
SM-10-003 MUST NOT A receiver MUST NOT apply a participant-specific axis transition (RM, VFD) to the shared CaseStatus.

Mixing axes is a protocol correctness violation. An RM or VFD move describes the progress of one participant. Written to the shared record, it could change the embargo or public state that every participant of the case sees (CM-04-006).
Refines: CM-04-006
SM-10-004 MUST NOT A receiver MUST NOT record a participant-agnostic axis transition (EM, PXA) in a ParticipantStatus as that participant's own progress. The transition updates the shared CaseStatus (SM-10-002). A participant can still report its own view of the case state in the case_status embedded in its ParticipantStatus. That report is only a claim, and the case owner or CASE_MANAGER decides whether to promote it to the case's CaseStatus.

EM and PXA state are facts about the case, not about one participant. A shared EM or PXA event written as one participant's progress could overwrite that participant's own record (CM-04-010). A participant's view of the case state is still useful input, so it travels as a claim the case's authority adopts or not, and never becomes the case's state by being sent.
Extends: SM-10-003
Refines: CM-04-010
See also: SM-10-002 — context for the reader

Report Management Behavioral Requirements

Event-Condition-Action behavioral requirements for Report Management (RM). Each group is triggered by either a received RM message or a local RM state transition, and specifies typed preconditions, ordered steps, and postconditions that implementations must satisfy.

Receive RS (Report Submission)

Behaviors triggered when a participant receives an RS (Report Submission) message, including RM state transition from Start to Received and vendor CS awareness update.

Trigger: Message Received — RS

ID Priority Requirement Related
RMB-01-001 MUST A Participant in RM Start (q^rm ∈ S) receiving RS MUST transition their RM state to Received (q^rm S → R).

RS is the sole RM message that directly changes the receiver's own RM state. All other RM messages announce sender state only.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Transition RM state from START to RECEIVED → Receiver RM state is RECEIVED
2. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender

Postconditions

- Receiver RM state is RECEIVED; RK emitted to sender

Uses definition from: MSM-01-001 — RS shorthand wire-type mapping
RMB-01-002 MUST A Vendor Participant in RM Start receiving RS that introduces a previously unknown vulnerability (q^cs ∈ vfd···) MUST transition their CS to vendor-aware (q^cs vfd··· → Vfd···) and emit CV to announce the transition.

RS is the event that makes a Vendor aware of the vulnerability. The CS V-transition records this awareness and CV announces it to other Participants.

ECA Details

Preconditions

- Participant is in RM Start; Participant holds the Vendor role; CS matches pattern vfd...
- RM state: START
- Role: vendor
- CS pattern: vfd...

Steps

1. [receiver] Transition RM state from START to RECEIVED → Receiver RM state is RECEIVED
2. [receiver] Transition CS from vfd··· to Vfd··· (V event) → CS vendor-aware bit set to V
3. [receiver] Emit CV to announce the CS vendor-aware transition → CV queued for case participants
4. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender

Postconditions

- Receiver RM state is RECEIVED; CS is vendor-aware; CV and RK emitted

Refines: VP-03-002 — Vendor MUST transition CS to Vfd on new RS
Uses definition from: MSM-01-001 — RS shorthand wire-type mapping
RMB-01-003 SHOULD A Vendor Participant already in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RS for a vulnerability they were previously unaware of (q^cs ∈ vfd···) SHOULD transition CS to Vfd··· and emit CV, even though their RM state does not change.

The CS V-transition captures vendor awareness regardless of when the Vendor first receives RS. A Vendor who joins a case mid-lifecycle must still record their own awareness event.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted); Participant holds the Vendor role; CS matches pattern vfd...
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED
- Role: vendor
- CS pattern: vfd...

Steps

1. [receiver] Transition CS from vfd··· to Vfd··· (V event) → CS vendor-aware bit set to V
2. [receiver] Emit CV to announce the CS vendor-aware transition → CV queued for case participants
3. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender

Postconditions

- CS is vendor-aware; CV and RK emitted; receiver RM state unchanged

Refines: VP-03-002 — Vendor MUST transition CS to Vfd on receiving RS for new vulnerability
Uses definition from: MSM-01-001 — RS shorthand wire-type mapping
RMB-01-004 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving a duplicate RS (already Vendor-aware, q^cs ∈ V···) SHOULD emit RK to acknowledge receipt without changing RM or CS state.

All R messages warrant acknowledgment unless the report is Closed. Duplicate RS does not re-trigger RM or CS transitions.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender

Postconditions*

- RK emitted; RM and CS states unchanged

Refines: VP-03-009 — RK acknowledgment of RS
Uses definition from: MSM-01-001 — RS shorthand wire-type mapping
Receive RI (Report Invalid)

Behaviors triggered when a participant receives an RI (Report Invalid) message, updating the sender's RM state model.

Trigger: Message Received — RI

ID Priority Requirement Related
RMB-02-001 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RI SHOULD update their record of the sender's RM state to Invalid.

RI is a status announcement — it does not change the receiver's own RM state but informs them of the sender's validation result. Maintaining this record supports shared situation awareness.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update local model of sender RM state to INVALID → Sender RM state recorded as INVALID in receiver's model

Postconditions

- Receiver RM state unchanged; sender's recorded RM state is INVALID

Uses definition from: MSM-01-002 — RI shorthand wire-type mapping
RMB-02-002 SHOULD A Participant in RM Start (q^rm ∈ S) receiving RI SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RI could be about. RE has no wire activity of its own (MSM-05-001).

Receiving any R message other than RS while in RM Start means the sender believes the receiver is coordinating a report the receiver has no knowledge of. A processing fault is the protocol's error response (VP-03-010).

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists

Postconditions*

- ProcessingFault emitted; receiver RM state unchanged (START)

Refines: VP-03-010 — Processing fault when R received while in RM Start
Uses definition from: MSM-01-002 — RI shorthand wire-type mapping
See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010
See also*: MSM-05-001 — context for the reader
Receive RV (Report Valid)

Behaviors triggered when a participant receives an RV (Report Valid) message, updating the sender's RM state model.

Trigger: Message Received — RV

ID Priority Requirement Related
RMB-03-001 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RV SHOULD update their record of the sender's RM state to Valid.

RV announces the sender's validation result. Maintaining this record supports shared situation awareness across Participants.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update local model of sender RM state to VALID → Sender RM state recorded as VALID in receiver's model

Postconditions

- Receiver RM state unchanged; sender's recorded RM state is VALID

Uses definition from: MSM-01-003 — RV shorthand wire-type mapping
RMB-03-002 SHOULD A Participant in RM Start (q^rm ∈ S) receiving RV SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RV could be about. RE has no wire activity of its own (MSM-05-001).

Receiving any R message other than RS while in RM Start is an error condition indicating the sender has a mistaken expectation about the receiver's case knowledge.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists

Postconditions*

- ProcessingFault emitted; receiver RM state unchanged (START)

Refines: VP-03-010 — Processing fault when R received while in RM Start
Uses definition from: MSM-01-003 — RV shorthand wire-type mapping
See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010
See also*: MSM-05-001 — context for the reader
Receive RD (Report/Case Deferred)

Behaviors triggered when a participant receives an RD (Report/Case Deferred) message, updating the sender's RM state model.

Trigger: Message Received — RD

ID Priority Requirement Related
RMB-04-001 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RD SHOULD update their record of the sender's RM state to Deferred.

RD announces the sender's deferral decision. Maintaining this record supports shared situation awareness and coordination planning.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update local model of sender RM state to DEFERRED → Sender RM state recorded as DEFERRED in receiver's model

Postconditions

- Receiver RM state unchanged; sender's recorded RM state is DEFERRED

Uses definition from: MSM-01-004 — RD shorthand wire-type mapping
RMB-04-002 SHOULD A Participant in RM Start (q^rm ∈ S) receiving RD SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RD could be about. RE has no wire activity of its own (MSM-05-001).

Receiving any R message other than RS while in RM Start is an error condition.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists

Postconditions*

- ProcessingFault emitted; receiver RM state unchanged (START)

Refines: VP-03-010 — Processing fault when R received while in RM Start
Uses definition from: MSM-01-004 — RD shorthand wire-type mapping
See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010
See also*: MSM-05-001 — context for the reader
Receive RA (Report/Case Accepted)

Behaviors triggered when a participant receives an RA (Report/Case Accepted) message, updating the sender's RM state model to Accepted and acknowledging receipt.

Trigger: Message Received — RA

ID Priority Requirement Related
RMB-05-001 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RA SHOULD update their record of the sender's RM state to Accepted.

RA announces the sender's commitment to work the report. Recording this supports shared situation awareness and helps coordinate timing of follow-on actions such as embargo proposals.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update local model of sender RM state to ACCEPTED → Sender RM state recorded as ACCEPTED in receiver's model

Postconditions

- Receiver RM state unchanged; sender's recorded RM state is ACCEPTED

Uses definition from: MSM-01-005 — RA shorthand wire-type mapping
RMB-05-002 SHOULD A Participant in RM Start (q^rm ∈ S) receiving RA SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RA could be about. RE has no wire activity of its own (MSM-05-001).

Receiving any R message other than RS while in RM Start is an error condition indicating the sender has a mistaken expectation about the receiver's case knowledge.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists

Postconditions*

- ProcessingFault emitted; receiver RM state unchanged (START)

Refines: VP-03-010 — Processing fault when R received while in RM Start
Uses definition from: MSM-01-005 — RA shorthand wire-type mapping
See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010
See also*: MSM-05-001 — context for the reader
Receive RC (Report Closed)

Behaviors triggered when a participant receives an RC (Report Closed) message, updating the sender's RM state model to Closed and acknowledging receipt.

Trigger: Message Received — RC

ID Priority Requirement Related
RMB-06-001 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RC SHOULD update their record of the sender's RM state to Closed.

RC announces that the sender has completed their work on the report. Maintaining this record supports shared situation awareness and potential auto-close evaluation.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update local model of sender RM state to CLOSED → Sender RM state recorded as CLOSED in receiver's model

Postconditions

- Receiver RM state unchanged; sender's recorded RM state is CLOSED

Uses definition from: MSM-01-006 — RC shorthand wire-type mapping
RMB-06-002 MAY After receiving RC from all other active Participants, a Participant MAY evaluate whether local closure criteria are satisfied and, if so, initiate closure of their own RM state.

When all other parties have closed, remaining open is often unnecessary. This auto-close judgment is based on local policy and current EM state.

ECA Details

Preconditions

- Participant is in RM Received/Invalid/Deferred/Accepted
- RM state: RECEIVED, INVALID, DEFERRED, ACCEPTED

Uses definition from: MSM-01-006 — RC shorthand wire-type mapping
RMB-06-003 SHOULD A Participant in RM Start (q^rm ∈ S) receiving RC SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RC could be about. RE has no wire activity of its own (MSM-05-001).

Receiving any R message other than RS while in RM Start is an error condition.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists

Postconditions*

- ProcessingFault emitted; receiver RM state unchanged (START)

Refines: VP-03-010 — Processing fault when R received while in RM Start
Uses definition from: MSM-01-006 — RC shorthand wire-type mapping
See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010
See also*: MSM-05-001 — context for the reader
Receive RE (Report Error)

Behaviors triggered when a participant receives an RE (Report Management Error) signal, which has no dedicated semantic dispatch value and is handled outside the standard AS2 pattern-matching pipeline.

Trigger: Message Received — RE

ID Priority Requirement Related
RMB-07-001 SHOULD A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) that receives Create(ProcessingFault) about an RM activity it sent SHOULD inquire (GI) about the nature of the error when the fault does not say what went wrong. RE has no wire activity of its own (MSM-05-001).

The fault says the sender could not process an RM activity, but not always why. GI opens a dialogue to resolve the problem. No RK is sent: RK acknowledges only a report submission and never goes to the CASE_MANAGER (RMB-08-003).

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Emit GI to inquire about the nature of the error, when the fault does not say what went wrong → GI queued for sender

Postconditions

- GI emitted; receiver RM state unchanged

Refines: VP-03-011 — Inquire about the error with GI; RK is not sent (RMB-08-003)
Uses definition from: MSM-01-007 — RE shorthand wire-type mapping
See also: MSM-05-001 — context for the reader
RMB-07-002 MUST NOT A Participant in RM Start (q^rm ∈ S) that receives Create(ProcessingFault) about an RM activity MUST NOT answer it with Create(ProcessingFault) (ASK-07-019). RE has no wire activity of its own (MSM-05-001).

A fault about a report the receiver does not hold means the two actors disagree about the case, but another fault cannot settle that. If both actors are in RM Start, each answering fault would prompt another without end, because each one is a new activity.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Receive Create(ProcessingFault) about an RM activity and send no fault → No ProcessingFault queued for the sender

Postconditions

- No fault emitted; receiver RM state unchanged (START)

Refines: ASK-07-019 — The RM Start case of the rule that a fault is never answered with a fault
Uses definition from: MSM-01-007 — RE shorthand wire-type mapping
See also: MSM-05-001 — context for the reader
Receive RK (Report Acknowledgment)

Behaviors triggered when a participant receives an RK (Report Management Acknowledgment) message confirming receipt of a prior RM message.

Trigger: Message Received — RK

ID Priority Requirement Related
RMB-08-001 MAY A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RK MAY take no further action; RK is an acknowledgment and requires no response.

RK closes the acknowledgment loop. Emitting RK in response to RK would create an infinite acknowledgment chain. The protocol specifies no mandatory response to RK from an active-state receiver.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Derives from: VP-03-009 — RK itself is never acknowledged with another RK
Uses definition from: MSM-01-008 — RK shorthand wire-type mapping
RMB-08-002 SHOULD A Participant in RM Start (q^rm ∈ S) receiving RK SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RK could be about. RE has no wire activity of its own (MSM-05-001).

RK arriving in START means the sender believes the receiver has already acknowledged a message the receiver has never seen. A processing fault is the protocol's error response for any R message received while in RM Start per VP-03-010.

ECA Details

Preconditions

- Participant is in RM Start
- RM state: START

Steps

1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists

Postconditions*

- ProcessingFault emitted; no RK in reply to RK (RMB-08-001); receiver RM state unchanged (START)

Refines: VP-03-010 — Processing fault when R received while in RM Start
Uses definition from: MSM-01-008 — RK shorthand wire-type mapping
See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010
See also*: MSM-05-001 — context for the reader
RMB-08-003 MUST An actor that an Offer(VulnerabilityReport) was addressed to MUST send the RK that acknowledges it to the reporter, the Offer's actor. It may send the RK at any time after it receives the report, whether or not a case exists for it.

The reporter checks who may acknowledge its Offer against its own record of that Offer (RMB-08-004). The store of each addressee also holds a record. RK answers the reporter's Offer and is outside the case, so it is the stated exception to PCR-08-001 and to the routing topology of VP-18-001, VP-18-002 and VP-18-003.

ECA Details

Steps

1. [receiver of the report] Emit RK addressed to the Offer's actor → RK queued for the reporter only

Postconditions

- The reporter holds the RK

Refines: VP-03-009 — RK acknowledging RS
Supersedes: PCR-08-001 — the stated RK exception to CASE_MANAGER-only addressing
Supersedes: VP-18-001 — the stated RK exception to the CASE_MANAGER routing path
Supersedes: VP-18-002 — the stated RK exception to the no-direct-delivery rule
Supersedes: VP-18-003 — the stated RK exception to CASE_MANAGER-mediated delivery
RMB-08-005 MUST NOT An actor MUST NOT send an RK that acknowledges a report submission to the CASE_MANAGER.

The CASE_MANAGER has no record of the addressees of the Offer, so it cannot check an RK that it receives (RMB-08-004). An RK sent to it can also reach parties that did not receive the report.

ECA Details

Postconditions

- The CASE_MANAGER received no RK

Extends: RMB-08-003
RMB-08-006 MUST NOT A receiver of an RK that acknowledges a report submission MUST NOT forward it.

RK answers the reporter's Offer outside the case. A forwarded RK can reach parties that did not receive the report.

ECA Details

Steps

1. [any receiver of RK] Record the RK at intake → No RK forwarded

Extends: RMB-08-003
RMB-08-007 MUST NOT An actor MUST NOT write a case ledger entry for an RK that acknowledges a report submission.

RK is outside the case, so it is not a case event. A ledgered RK would also replicate to parties that did not receive the report.

ECA Details

Steps

1. [any receiver of RK] Record the RK at intake → No ledger entry written

Extends: RMB-08-003
RMB-08-004 MUST A receiver MUST refuse an RK for a report submission (RMB-08-003, HP-01-006) unless its own record of the Offer names the sender as an addressee. The Offer is the Offer(VulnerabilityReport) that the RK acknowledges.

The reporter sent the Offer, so only its record of the to of the Offer tells correctly who received it. The sender of the RK wrote the copy in the RK, and that copy can name any actor. If the reporter accepts an RK on the word of its sender, any actor can claim that it has the report. A receiver with no record of the Offer cannot find the sender in it, so it refuses too.

ECA Details

Steps

1. [reporter] Check the RK sender against its recorded Offer's addressees → Admitted when the sender is an addressee; REFUSED otherwise

Refines: HP-01-006 — the RK sender clause
Uses definition from: RMB-08-003
RMB-08-008 MUST A receiver that refuses an RK (RMB-08-004) MUST write nothing past intake and send nothing for it.

A refused RK makes no claim the receiver accepts, so any write past intake or any message would act on a claim it refused.

ECA Details

Postconditions

- A refused RK leaves only its intake record

Extends: RMB-08-004
Enter RM Received

Trigger: State Entered — RM.RECEIVED

ID Priority Requirement Related
RMB-09-001 SHOULD A Participant entering RM Received SHOULD initiate a report validation process to determine whether the report is Valid or Invalid. A Participant that joined a case through an Invite validates the case instead, once it has joined, by replying to the full-case Invite (CM-11-011); an invitee that has not joined has nothing to validate.

Received is the intake state that exists specifically to await validation. Failing to validate leaves the report stuck and blocks all subsequent coordination steps that depend on the validation outcome.

ECA Details

Preconditions

- Participant is in RM Received
- RM state: RECEIVED

Steps

1. [participant] Initiate validation process (credibility check followed by validity check) → Validation process underway

Postconditions

- Validation process initiated; report will transition to VALID or INVALID on completion

Refines: VP-02-006 — Subject each Received report to a validation process
Uses definition from: CM-11-011
RMB-09-002 MAY A Participant entering RM Received MAY temporarily hold the report pending additional information if the initial validation cannot be completed with available data.

Reports may arrive with insufficient detail for immediate validation. Holding in Received preserves the option to revalidate when the Reporter provides more information.

ECA Details

Preconditions

- Participant is in RM Received
- RM state: RECEIVED

Refines: VP-02-012 — MAY temporarily hold reports pending additional information
Enter RM Valid

Trigger: State Entered — RM.VALID

ID Priority Requirement Related
RMB-10-001 MUST A Participant entering RM Valid MUST initiate a prioritization evaluation to determine whether to Accept or Defer the report.

A Valid report waits on a decision to Accept or Defer it. Entering Valid without initiating prioritization leaves the report with no path forward.

ECA Details

Preconditions

- Participant is in RM Valid
- RM state: VALID

Steps

1. [participant] Initiate prioritization evaluation (e.g., SSVC scoring) → Prioritization process started; outcome is ACCEPTED or DEFERRED

Postconditions

- Prioritization underway; report will transition to ACCEPTED or DEFERRED

Refines: VP-02-014 — SHOULD perform a prioritization evaluation for Valid reports
RMB-10-002 MUST NOT A Participant in RM Valid MUST NOT close the report directly from the Valid state (q^rm V → C) without first transitioning through Accepted or Deferred (constraint C-03).

Closing directly from Valid skips the mandatory prioritization step. Reports with no further action should be Deferred first and then Closed, preserving the prioritization record.

ECA Details

Preconditions

- Participant is in RM Valid
- RM state: VALID

Refines: VP-02-004 — Participants MUST NOT close cases from the Valid state
RMB-10-003 SHOULD A Participant entering RM Valid SHOULD emit RV to announce the validation result to other Participants.

State-change notifications support shared situation awareness. Other Participants tracking this report depend on RV to update their model of the sender's RM state.

ECA Details

Preconditions

- Participant is in RM Valid
- RM state: VALID

Steps

1. [participant] Emit RV to announce RM Valid transition → RV queued for case participants

Postconditions

- RV emitted; other Participants informed of Valid transition

Refines: VP-03-004 — SHOULD send RV when validation ends in valid determination
Refines: VP-03-012 — SHOULD send a message for each RM state transition
RMB-10-004 SHOULD A Participant entering RM Valid SHOULD create or update a case object to track the report's progress through the CVD process.

Valid reports represent confirmed vulnerability coordination work. A case object enables participant management, embargo coordination, and state tracking across all involved parties.

ECA Details

Preconditions

- Participant is in RM Valid
- RM state: VALID

Refines: VP-02-015 — SHOULD create a case for reports entering the Valid state
Enter RM Invalid

Trigger: State Entered — RM.INVALID

ID Priority Requirement Related
RMB-11-001 SHOULD A Participant entering RM Invalid SHOULD emit RI to announce the invalid determination to other Participants.

State-change notifications support shared situation awareness. Other Participants tracking this report depend on RI to update their model of the sender's validation outcome.

ECA Details

Preconditions

- Participant is in RM Invalid
- RM state: INVALID

Steps

1. [participant] Emit RI to announce RM Invalid transition → RI queued for case participants

Postconditions

- RI emitted; other Participants informed of Invalid transition

Refines: VP-03-003 — SHOULD send RI when validation ends in invalid determination
Refines: VP-03-012 — SHOULD send a message for each RM state transition
RMB-11-003 MAY A Participant in RM Invalid MAY revalidate the report when new information becomes available, transitioning back through the validation process toward RM Valid.

Invalid reports may become valid if additional information is provided by the Reporter or discovered independently. Revalidation preserves coordination options without requiring a new RS.

ECA Details

Preconditions

- Participant is in RM Invalid
- RM state: INVALID

Refines: VP-02-033 — MAY periodically revalidate Invalid reports
RMB-11-004 MAY A Participant in RM Invalid MAY close the report if no further action is expected and no active embargo is in force (q^em ∉ {A,R}).

Invalid reports with no prospect of revalidation should eventually be closed. Active embargo constraints on closure still apply.

ECA Details

Preconditions

- Participant is in RM Invalid
- RM state: INVALID

Refines: VP-02-035 — Participants MAY close Invalid reports
Enter RM Deferred

Trigger: State Entered — RM.DEFERRED

ID Priority Requirement Related
RMB-12-001 SHOULD A Participant entering RM Deferred SHOULD emit RD to announce the deferral decision to other Participants.

State-change notifications support shared situation awareness. Other Participants depend on RD to update their model of the sender's prioritization decision and to calibrate their own coordination plans.

ECA Details

Preconditions

- Participant is in RM Deferred
- RM state: DEFERRED

Steps

1. [participant] Emit RD to announce RM Deferred transition → RD queued for case participants

Postconditions

- RD emitted; other Participants informed of Deferred transition

Refines: VP-03-005 — SHOULD send RD when prioritization ends in deferred decision
Refines: VP-03-012 — SHOULD send a message for each RM state transition
Refines: VP-02-024 — Vendors SHOULD communicate prioritization choices including deferral
RMB-12-002 SHOULD A Participant in RM Deferred SHOULD monitor for new information (updated threat intelligence, exploitation activity, or vendor progress) that could justify reprioritization toward Accepted.

Deferred does not mean permanently shelved. Changed conditions may restore the urgency needed to resume active work on the report.

ECA Details

Preconditions

- Participant is in RM Deferred
- RM state: DEFERRED

RMB-12-003 MAY A Participant in RM Deferred MAY set a policy timer to automatically move the report to Closed after a defined period of inactivity.

Indefinitely deferred reports accumulate as open coordination debt. A timer enforces eventual cleanup consistent with local policy without requiring manual review of every dormant case.

ECA Details

Preconditions

- Participant is in RM Deferred
- RM state: DEFERRED

Refines: VP-02-031 — MAY set a policy timer on Deferred reports
Enter RM Accepted

Trigger: State Entered — RM.ACCEPTED

ID Priority Requirement Related
RMB-13-001 MUST A Participant MUST be in RM Accepted (q^rm ∈ A) before sending RS to another Participant to initiate CVD coordination (constraint C-04). Sending RS from any other RM state is prohibited.

Sending RS from a non-Accepted state would initiate coordination before the sender has committed to working the report. Accepted represents the sender's confirmed engagement and readiness to coordinate.

ECA Details

Preconditions

- Participant is in RM Accepted
- RM state: ACCEPTED

Refines: VP-03-001 — MUST be in RM Accepted to send RS
Refines: VP-02-003 — Participants initiating CVD with others MUST do so from Accepted state
RMB-13-002 SHOULD A Participant entering RM Accepted SHOULD emit RA to announce the accept decision to other Participants.

State-change notifications support shared situation awareness. Other Participants depend on RA to know that the sender has committed to active work and may soon send RS to initiate coordination.

ECA Details

Preconditions

- Participant is in RM Accepted
- RM state: ACCEPTED

Steps

1. [participant] Emit RA to announce RM Accepted transition → RA queued for case participants

Postconditions

- RA emitted; other Participants informed of Accepted transition

Refines: VP-03-006 — SHOULD send RA when prioritization ends in accept decision
Refines: VP-03-012 — SHOULD send a message for each RM state transition
Refines: VP-02-024 — Vendors SHOULD communicate prioritization choices including acceptance
RMB-13-003 SHOULD A Participant in RM Accepted SHOULD perform active work on the report (e.g., fix development, remediation guidance, coordination with other Participants via RS).

Accepted is the active engagement state. Entering Accepted without performing work reduces coordination effectiveness and may violate implicitly agreed timelines within an active embargo.

ECA Details

Preconditions

- Participant is in RM Accepted
- RM state: ACCEPTED

Enter RM Closed

Trigger: State Entered — RM.CLOSED

ID Priority Requirement Related
RMB-14-001 SHOULD A Participant entering RM Closed SHOULD emit RC to announce the closure to other Participants.

State-change notifications support shared situation awareness. Other Participants depend on RC to know the sender has completed their work and to evaluate whether to initiate their own closure.

ECA Details

Preconditions

- Participant is in RM Closed
- RM state: CLOSED

Steps

1. [participant] Emit RC to announce RM Closed transition → RC queued for case participants

Postconditions

- RC emitted; other Participants informed of Closed transition

Refines: VP-03-007 — SHOULD send RC when report is closed
Refines: VP-03-012 — SHOULD send a message for each RM state transition
RMB-14-002 MAY A Participant in RM Closed (q^rm ∈ C) MAY ignore further R messages received on the closed report without sending a response. Non-R traffic (EM, CS, GI) on a closed case is covered by VP-03-013, and the CASE_MANAGER's kill switch once the case is fully closed by CM-23-013.

Closed is a terminal state. A response to more R messages creates work for a report that is complete. The limit for the CASE_MANAGER is wider: after the Case Owner closes the case, it records no message of any class (CM-23-013, ADR-0085). Thus this rule controls only what a closed participant does with the R messages that it continues to receive.

ECA Details

Preconditions

- Participant is in RM Closed
- RM state: CLOSED

Refines: VP-03-013 — Recipients MAY ignore messages received on Closed cases
See also: CM-23-013 — context for the reader
RMB-14-003 SHOULD NOT A Participant SHOULD NOT close a report (q^rm ∈ {R,I,D,A} → C) while an active embargo is in force (q^em ∈ {A,R}) unless they first communicate their closure intent, and whether their Embargo Consent continues, to other Participants.

Closing while an embargo is active may signal withdrawal from the coordinated timeline without proper notification, potentially undermining the agreed disclosure date for all parties.

ECA Details

Preconditions

- Participant is in RM Received/Invalid/Deferred/Accepted; EM state is Active or Revise
- RM state: RECEIVED, INVALID, DEFERRED, ACCEPTED
- EM state: ACTIVE, REVISE

Refines: VP-13-007 — SHOULD communicate intent to adhere or terminate compliance when closing during an active embargo
Supersedes: VP-13-005
RMB-14-004 MUST The RM transition function MUST permit closing from Received (q^rm R → C), as well as I → C, A → C and D → C. A Reject sent from RM Received, of a report Offer, a stub Invite (CM-11-007) or a full-case Invite (CM-11-011), is the R → C transition.

Reject means close and TentativeReject means invalid, so a hard no from Received needs its own edge rather than a bypass of the transition table.
Uses definition from: CM-11-007
Uses definition from: CM-11-011
RMB-14-008 MUST NOT The RM transition function MUST NOT permit closing from Valid (VP-02-004).

Valid keeps no close edge: a participant that found a report valid decides to engage or defer before it leaves (ADR-0114).
Refines: VP-02-004
RMB-14-005 MUST Every RM closure MUST be written as transitions the RM transition function permits, with no closure path that overrides the transition table.

An override that skips the RM transition table lets a closure write a state that no permitted sequence reaches. The write-boundary check (RMB-15-001) and every replica then disagree with that state. R to C is in the table (RMB-14-004), and Valid goes through Deferred (RMB-14-009). Thus every closure is an ordinary transition, and no closure path needs the override (ADR-0114).
RMB-14-009 MUST An actor MUST record a participant at RM Valid that leaves the case (Leave(VulnerabilityCase), CM-23-038) as V → D → C.

V → C is not in the RM transition table (RMB-14-008), so a closure from Valid that keeps to the table (RMB-14-005) goes through Deferred.
Refines: RMB-14-005
Refines: CM-23-038
RMB-14-006 MUST NOT The RM state machine MUST NOT define any transition out of RM.CLOSED to a different RM state. RM.CLOSED is terminal: once a participant's RM state reaches CLOSED, no further RM progression is possible for that participant on that case.

RM.CLOSED being terminal is what gives the closure act finality. A participant that anticipates returning to the case SHOULD instead move to RM.DEFERRED (resumable via DEFERRED → ACCEPTED) rather than close; once closed, the participant has no path back in, because a re-invite to a participant at RM.CLOSED is refused (CM-11-043, ADR-0085). Rejoin mechanics are deferred to a future design; the interim workaround is defer-not-close (RMB-14-007).
RMB-14-007 SHOULD A participant that anticipates returning to active coordination on a case SHOULD move to RM.DEFERRED (the resumable parking state) rather than RM.CLOSED. RM.DEFERRED supports both DEFERRED → ACCEPTED (resume) and DEFERRED → CLOSED (abandon) transitions; RM.CLOSED supports neither.

Because RM.CLOSED is terminal (RMB-14-006), a participant that closes and later wants back in has no protocol path. RM.DEFERRED preserves optionality: the participant can accept the case later or close it once it confirms there is nothing more to do (ADR-0085). Full rejoin mechanics (reactivation via re-invitation, multiple lifecycle arcs per actor) are deferred to a future design Idea.

Embargo Management Behavioral Requirements

Event-Condition-Action behavioral requirements for Embargo Management (EM). Each group is triggered by either a received EM message or a local EM state transition, and specifies typed preconditions, ordered steps, and postconditions that implementations must satisfy.

Receive EP (Embargo Proposed)

Behaviors triggered when a participant receives an EP (Embargo Proposed) message, transitioning EM state to Proposed and acknowledging receipt. Written in the voice of the formal protocol, in which every Participant is a peer. In the CASE_MANAGER topology (PCR-08-001) a participant addresses its proposal to the CASE_MANAGER alone, so the Participant receiving EP is the CASE_MANAGER on receipt; every other participant reaches the same EM state through ledger replay, and is asked for its answer by the Invite the CASE_MANAGER relays to it. "Emit EK" is discharged by the CASE_MANAGER's commit and announcement of the received activity; no EK message exists (EP-09-009). See EP-09 and ADR-0113 as amended.

Trigger: Message Received — EP

ID Priority Requirement Related
EMB-01-001 MUST A Participant in EM None (q^em ∈ N) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EP MUST transition their EM state to Proposed (q^em N → P). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009).

EP is the EM message that initiates embargo negotiation. When no embargo exists and the case is still pre-public, the receiver transitions to Proposed to signal they are evaluating the proposal.

ECA Details

Preconditions

- EM state is None; CS matches pattern ...pxa
- EM state: NONE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from NONE to PROPOSED → Receiver EM state is PROPOSED
2. [receiver] CASE_MANAGER commits the received EP and adds the entry to the ledger (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is PROPOSED; EK discharged by the ledger commit

Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
Uses definition from: EP-09-009
EMB-01-002 MUST The case is at P/X/A when the vulnerability is public (q^cs ∈ ···P··), an exploit is public (q^cs ∈ ····X·), or attacks are observed (q^cs ∈ ·····A). A Participant that receives a new embargo proposal (EP) at P/X/A MUST answer the Invite with its own Reject(Invite(EmbargoEvent)) instead of accepting it. The refusal binds only the proposal's addressee. A receiver the proposal is not addressed to (HP-01-012) holds an unaddressed copy, refuses it (HP-01-005) and answers nothing (ADR-0118); cc addresses nobody (ADR-0109). The Reject names the Invite by id and carries no terms. An Invite that names its terms by URI only is classified as an embargo Invite only once the receiver holds the terms (SE-01-006). Its Reject follows the fetch of those terms (AKM-05-007), and none is sent when the fetch fails (AKM-05-015). A re-delivery of an Invite already answered with a Reject gets no second Reject: the seen-before door refuses it again from its receipt stub (CLP-10-010, HP-01-014).

Embargo negotiation is not viable once public disclosure has occurred. VP-06-001 prohibits new embargo negotiations in these states. The Reject of the Invite tells the proposer that the receiver refuses the terms. It is the receiver's own consent answer (MSM-07-004), not ER: ER is the Case Owner's decision for the case, or the CASE_MANAGER's abandonment of the proposal (MSM-02-006, MSM-02-010). A bare object URI matches no pattern's object type, so a receiver that lacks the terms cannot tell an embargo Invite from an actor Invite until it fetches them (#5266).

ECA Details

Preconditions

- CS matches pattern ...P..
- CS pattern: ...P..
- CS matches pattern ....X.
- CS pattern: ....X.
- CS matches pattern .....A
- CS pattern: .....A

Steps

1. [receiver] Emit a Reject of the Invite to refuse the embargo proposal → Reject(Invite(EmbargoEvent)) queued for the sender; the receiver's EM state does not move to PROPOSED

Postconditions

- Reject(Invite(EmbargoEvent)) emitted; no EM state transition to PROPOSED

Refines: VP-06-001
Uses definition from: CLP-10-010 — MUST NOT propose or accept embargo when public/exploit/attacks
Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
See also: AKM-05-007 — context for the reader
See also: AKM-05-015 — context for the reader
See also: HP-01-005 — context for the reader
See also: HP-01-012 — context for the reader
See also: HP-01-014 — context for the reader
See also: SE-01-006 — context for the reader
EMB-01-003 MUST A Participant already in EM Proposed (q^em ∈ P) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving a second or counter EP MUST stay in Proposed with no additional state transition. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Multiple EP messages can arrive during negotiation. When already in Proposed, no additional state transition is needed. The receiver evaluates the counter-proposal: it may answer the Invite with an Accept or a Reject of it, or counter, and the Case Owner decides the proposal for the case with EA or ER.

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...pxa
- EM state: PROPOSED
- CS pattern: ...pxa

Steps

1. [receiver] CASE_MANAGER commits the counter EP and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists; EM state remains PROPOSED

Postconditions

- EM state remains PROPOSED; counter-proposal terms available for evaluation; EK discharged by the ledger commit

Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-01-004 SHOULD NOT A Participant in RM Invalid (q^rm ∈ I) SHOULD NOT propose or accept an embargo when receiving EP.

VP-13-003 discourages starting embargo management from an Invalid RM state. The report has been assessed as invalid; committing to embargo terms under those conditions is premature and likely to be wasted effort.

ECA Details

Preconditions

- Participant is in RM Invalid
- RM state: INVALID

Refines: VP-13-003 — SHOULD NOT begin EM with a proposal from a Participant in RM Invalid
Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
EMB-01-005 SHOULD NOT A Participant in an inactive RM state (q^rm ∈ {D, C}) SHOULD NOT begin embargo management by accepting an incoming EP.

VP-13-002 discourages starting embargo management in inactive RM states. Deferred or Closed cases indicate the participant has deprioritized or completed their engagement; starting embargo negotiation in these states is unlikely to lead to productive coordinated disclosure.

ECA Details

Preconditions

- Participant is in RM Deferred/Closed
- RM state: DEFERRED, CLOSED

Refines: VP-13-002 — SHOULD NOT begin EM in an inactive RM state
Uses definition from: MSM-02-001 — EP shorthand wire-type mapping
Receive EA (Embargo Accepted)

Behaviors triggered when a participant receives an EA (Embargo Accepted) message, transitioning EM state to Active and acknowledging receipt.

Trigger: Message Received — EA

ID Priority Requirement Related
EMB-02-001 MUST A Participant in EM Proposed (q^em ∈ P) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EA MUST move their EM state along the accept transition of EMB-18-005: to Active (q^em P → A) when the accepted proposal was the last one open, and to Revise (q^em P → R) while another proposal stays open. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Every participant must agree on whether an embargo is in force. If the receiver kept EM at Proposed after the EA, it would act as if no embargo binds the case, and it could disclose while the other participants keep the vulnerability private. Another open proposal stays open as a revision of the embargo now in force, because the consent already given to its terms stays valid (ADR-0130). Revise records both facts. The ledger commit of the EA acknowledges it.

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...pxa
- EM state: PROPOSED
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from PROPOSED to ACTIVE → Receiver EM state is ACTIVE
2. [receiver] CASE_MANAGER commits the received EA and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is ACTIVE, or REVISE while another proposal is open; EK discharged by the ledger commit

Implements: VP-05-003 — An embargo SHALL begin at the moment it is accepted
Uses definition from: MSM-02-002 — EA shorthand wire-type mapping
Uses definition from: EP-09-009
Refines: EMB-18-005
See also: MSM-02-009 — context for the reader
EMB-02-002 MUST NOT A Participant MUST NOT apply EA's transition to Active when the case is at P/X/A (q^cs ∉ ···pxa). EA is the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] (MSM-07-008). The CASE_MANAGER refuses that activation before committing it to the case ledger, and sends no Reject of the Invite for it.

VP-06-001 prohibits accepting embargoes once public disclosure has occurred. EA is the Case Owner's decision (MSM-02-002), so the refusal falls on it. A Reject of the Invite that the CASE_MANAGER commits reads as its abandonment of the proposal (MSM-07-016, ADR-0152), so the activation is refused instead. The Reject of EMB-02-004 differs: it is a direct answer, never committed. VP-13-004 only discourages Active when RM is Invalid or Closed; this bar is absolute.

ECA Details

Preconditions

- CS matches pattern ...P..
- CS pattern: ...P..
- CS matches pattern ....X.
- CS pattern: ....X.
- CS matches pattern .....A
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Refuse the Case Owner's activation before committing it (embargo not viable) → Nothing is committed; EM state is not transitioned to ACTIVE

Postconditions

- Activation refused; EM state not transitioned to ACTIVE

Refines: VP-06-001 — MUST NOT accept a new embargo when public/exploit/attacks
Uses definition from: MSM-02-002 — EA shorthand wire-type mapping
See also: MSM-07-008 — context for the reader
EMB-02-003 SHOULD NOT A Participant in RM Invalid or Closed (q^rm ∈ {I, C}) SHOULD NOT allow EM to proceed from Proposed to Active upon receiving EA.

VP-13-004 discourages proceeding to Active when the report has been assessed as invalid or closed. The embargo would apply to a case the participant is not actively working.

ECA Details

Preconditions

- Participant is in RM Invalid/Closed
- RM state: INVALID, CLOSED

Refines: VP-13-004 — SHOULD NOT proceed from EM Proposed to EM Accepted when RM is Invalid or Closed
Uses definition from: MSM-02-002 — EA shorthand wire-type mapping
EMB-02-004 MUST The case may be at P/X/A (q^cs ∉ ···pxa) when a Participant's Accept(Invite(EmbargoEvent)) reaches the CASE_MANAGER. The CASE_MANAGER MUST then refuse the Accept by answering that Participant with a Reject of the Invite.

An Accept of the Invite is the Participant's own consent, not EA (MSM-02-010), so EMB-02-002 does not cover it. VP-06-001 prohibits accepting embargoes once public disclosure has occurred, so consent to the proposed terms cannot be recorded. The Reject of the Invite tells the Participant that its answer was refused, as EMB-01-002 does for a proposal. It is a direct answer addressed to that Participant and is never committed to the ledger, so no replica reads it as the abandonment of MSM-07-016. It sits beside EMB-02-002 because both refuse an acceptance on a public case.

ECA Details

Preconditions

- CS matches pattern ...P..
- CS pattern: ...P..
- CS matches pattern ....X.
- CS pattern: ....X.
- CS matches pattern .....A
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Emit a Reject of the Invite to refuse the acceptance (embargo not viable) → Reject(Invite(EmbargoEvent)) queued for the accepting Participant; its consent is not recorded

Postconditions

- Reject(Invite(EmbargoEvent)) emitted; the Participant's acceptance is not recorded

Refines: VP-06-001 — MUST NOT accept a new embargo when public/exploit/attacks
Receive EV (Embargo Revision Proposed)

Behaviors triggered when a participant receives an EV (Embargo Revision Proposed) message while an embargo is active, transitioning EM state to Revise and acknowledging receipt. Written in the voice of the formal protocol, in which every Participant is a peer. In the CASE_MANAGER topology (PCR-08-001) a participant addresses its proposal to the CASE_MANAGER alone, so the Participant receiving EV is the CASE_MANAGER on receipt; every other participant reaches the same EM state through ledger replay, and is asked for its answer by the Invite the CASE_MANAGER relays to it. "Emit EK" is discharged by the CASE_MANAGER's commit and announcement of the received activity; no EK message exists (EP-09-009). See EP-09 and ADR-0113.

Trigger: Message Received — EV

ID Priority Requirement Related
EMB-03-001 MUST A Participant in EM Active (q^em ∈ A) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving EV MUST transition their EM state to Revise (q^em A → R). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

A participant must know that a change to the embargo is open while the current terms still bind it. Revise records both facts: an embargo is in force, and a revision of it waits for an answer. If the receiver stayed in Active, it could not tell that a later EC or EJ decides a revision. The revision does not change any participant's consent to the embargo in force until the Case Owner activates it (EP-05-002).

ECA Details

Preconditions

- EM state is Active; CS matches pattern ...pxa
- EM state: ACTIVE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from ACTIVE to REVISE → Receiver EM state is REVISE
2. [receiver] CASE_MANAGER commits the received EV and fans out its entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is REVISE; original embargo remains in force; EK discharged by the ledger commit

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-03-002 MUST A Participant already in EM Revise (q^em ∈ R) with CS not yet public/exploit/attack (q^cs ∈ ···pxa) receiving a counter EV (counter-revision) MUST stay in Revise with no additional state transition. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Multiple revision proposals can arrive. When already in Revise, no further state transition is needed; the receiver evaluates the counter-revision and answers its Invite with an Accept or a Reject of it, and the Case Owner decides the revision for the case with EC or EJ.

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa
- EM state: REVISE
- CS pattern: ...pxa

Steps

1. [receiver] CASE_MANAGER commits the counter EV and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists; EM state remains REVISE

Postconditions

- EM state remains REVISE; EK discharged by the ledger commit

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-03-003 MUST NOT This rule binds a Participant that is neither Case Owner nor CASE_MANAGER. Its EM is Active or Revise (q^em ∈ {A, R}) and the case is at P/X/A (q^cs ∉ ···pxa). That Participant, receiving EV, MUST NOT adopt the proposal, emit ET or change its own EM state. Only the Case Owner, or the CASE_MANAGER when delegated, initiates termination (EP-09-003, EP-09-008, CM-24, ADR-0113, ADR-0118). The public, exploit or attack fact causes it, never a revision proposal.

A proposal is at most the occasion on which a participant notices the case is public; making it the cause would tie termination to someone proposing terms. Ending the embargo is the Case Owner's decision, and only the CASE_MANAGER writes shared EM state (EP-09-008, ADR-0113). VP-06-001 and VP-09-001 are met by the owner's or CASE_MANAGER's termination (VP-11-002, VP-11-011), which in the CASE_MANAGER topology is the CS public-event cascade, not by each participant emitting ET (ADR-0118).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...P..
- EM state: ACTIVE, REVISE
- CS pattern: ...P..
- EM state is Active or Revise; CS matches pattern ....X.
- EM state: ACTIVE, REVISE
- CS pattern: ....X.
- EM state is Active or Revise; CS matches pattern .....A
- EM state: ACTIVE, REVISE
- CS pattern: .....A

Steps

1. [receiver] Leave the revision unadopted and emit no ET → No ET is emitted; the receiver's EM state is unchanged

Postconditions

- No revision proposal adopted; the receiver emits no ET and its EM state is unchanged

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Refines: EP-09-003
See also: EP-09-008 — context for the reader
EMB-03-004 MUST This rule binds the Participant of EMB-03-003: neither the Case Owner nor the CASE_MANAGER, in EM Active or Revise, with the case at P/X/A. That Participant, receiving EV, MUST answer the revision Invite with its own Reject of it to the CASE_MANAGER. EMB-01-002 requires the same answer to a proposal.

Revision negotiation is not viable once public disclosure has occurred, so the participant refuses the revision. A participant answers only the Invite addressed to it (EP-09-003). The Reject of the Invite is the participant's own consent answer (MSM-07-004), not ER, which is the Case Owner's decision or the CASE_MANAGER's abandonment (MSM-02-006).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...P..
- EM state: ACTIVE, REVISE
- CS pattern: ...P..
- EM state is Active or Revise; CS matches pattern ....X.
- EM state: ACTIVE, REVISE
- CS pattern: ....X.
- EM state is Active or Revise; CS matches pattern .....A
- EM state: ACTIVE, REVISE
- CS pattern: .....A

Steps

1. [receiver] Emit a Reject of the revision Invite to the CASE_MANAGER → Reject(Invite(EmbargoEvent)) queued for the CASE_MANAGER

Postconditions

- Reject(Invite(EmbargoEvent)) queued for the CASE_MANAGER

Uses definition from: MSM-02-003 — EV shorthand wire-type mapping
Uses definition from: EMB-03-003
See also: EMB-01-002 — an analogy ("requires the same answer"); a revision Invite is not EMB-01-002's new proposal
Receive EJ (Embargo Revision Rejected)

Behaviors triggered when a participant receives an EJ (Embargo Revision Rejected) message, reverting EM state from Revise to Active and acknowledging receipt.

Trigger: Message Received — EJ

ID Priority Requirement Related
EMB-04-001 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EJ for the last open proposal, it MUST move its EM state back to Active (q^em R → A). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), discharges "Emit EK". No EK message is emitted (EP-09-009, MSM-02-009).

EJ says that a revision proposal is rejected. A rejected revision leaves the embargo in force and the consent to it unchanged (EP-05-002), so when no other proposal is open, EM returns to Active under the terms it had. The CASE_MANAGER's commit and fan-out of the received activity tell every participant of the change, so no separate EK message is necessary (ADR-0113).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa
- EM state: REVISE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from REVISE back to ACTIVE → Receiver EM state is ACTIVE
2. [receiver] CASE_MANAGER commits the received EJ and fans out its entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is ACTIVE (revision rejected); EK discharged by the ledger commit

Uses definition from: MSM-02-004 — EJ shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-04-003 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EJ while another proposal is open, it MUST remain in Revise (q^em R → R) (EMB-18-005).

While another proposal stays open, EM stays in Revise, because the register still holds an open proposal (ADR-0130).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa; another proposal is open
- EM state: REVISE
- CS pattern: ...pxa

Postconditions

- Receiver EM state is REVISE

Refines: EMB-18-005
EMB-04-002 MUST The CASE_MANAGER in EM Revise (q^em ∈ R) with CS in a public/exploit/attack state (q^cs ∉ ···pxa) that commits the Case Owner's EJ of the last open revision MUST emit ET in the same act to terminate the embargo, rather than reverting to Active.

Reverting to Active is not viable once public disclosure has occurred. VP-09-001 requires termination in these states. "Rather than reverting" describes where the act ends: EM ends EXITED, never back in Active. Inside the act, the CASE_MANAGER records the rejection as decided (the revision REJECTED) and then terminates the embargo, as two entries a replica copies in order (MSM-07-032, CM-23-016).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...P..
- EM state: REVISE
- CS pattern: ...P..
- EM state is Revise; CS matches pattern ....X.
- EM state: REVISE
- CS pattern: ....X.
- EM state is Revise; CS matches pattern .....A
- EM state: REVISE
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Commit the Case Owner's EJ, then emit ET to terminate the embargo in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- ET emitted; EM state is EXITED

Refines: VP-09-001 — Embargoes SHALL terminate immediately when public/exploit
Uses definition from: MSM-02-004 — EJ shorthand wire-type mapping
Receive EC (Embargo Revision Accepted)

Behaviors triggered when a participant receives an EC (Embargo Revision Accepted) message, advancing EM state from Revise back to Active with updated terms and acknowledging receipt.

Trigger: Message Received — EC

ID Priority Requirement Related
EMB-05-001 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EC for the last open proposal, it MUST move its EM state back to Active (q^em R → A) with the revised terms. The CASE_MANAGER's commit of the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase], fanned out as Add(CaseLedgerEntry), discharges "Emit EK". No EK message is emitted (EP-09-009, MSM-02-009).

EC says that the Case Owner activates a revision. The revised terms replace the terms in force, so when no other proposal is open, EM returns to Active under the revised terms. The CASE_MANAGER's commit and fan-out of the owner's Add tell every participant of the change, so no separate EK message is necessary (ADR-0113).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa
- EM state: REVISE
- CS pattern: ...pxa

Steps

1. [receiver] Transition EM state from REVISE to ACTIVE with revised embargo terms → Receiver EM state is ACTIVE; revised terms recorded
2. [receiver] CASE_MANAGER commits the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] and adds the entry to the ledger (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is ACTIVE with new terms; EK discharged by the ledger commit

Uses definition from: MSM-02-005 — EC shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-05-003 MUST This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EC while another proposal is open, it MUST remain in Revise (q^em R → R) under the revised terms (EMB-18-005).

The revised terms replace the terms in force at once. While another proposal stays open, EM stays in Revise, because the register still holds an open proposal (ADR-0130).

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...pxa; another proposal is open
- EM state: REVISE
- CS pattern: ...pxa

Postconditions

- Receiver EM state is REVISE with the revised terms

Refines: EMB-18-005
EMB-05-002 MUST This rule covers the CASE_MANAGER in EM Revise (q^em ∈ R) with CS in a public/exploit/attack state (q^cs ∉ ···pxa). It MUST refuse the Case Owner's EC before committing it, and emits no ET for the EC.

Accepting a revision is not viable once public disclosure has occurred (VP-06-001). EC activates a revision, so it is refused as EA is (EMB-02-002), before the commit (CLP-10-009). A refusal is not an act, so it carries no ET. The P/X/A fact causes the termination, not the EC (EMB-03-003): the act that adopts P, X or A ends the embargo (RSH-03-001, ADR-0210). EJ differs (EMB-04-002): it is committed, so its act can end the embargo.

ECA Details

Preconditions

- EM state is Revise; CS matches pattern ...P..
- EM state: REVISE
- CS pattern: ...P..
- EM state is Revise; CS matches pattern ....X.
- EM state: REVISE
- CS pattern: ....X.
- EM state is Revise; CS matches pattern .....A
- EM state: REVISE
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Refuse the Case Owner's EC before committing it → No ledger entry and no ET; EM stays Revise under the prior terms

Postconditions

- EC refused uncommitted; no ET emitted for it; the embargo in force is unchanged

Refines: EMB-02-002 — EC is the activation of a revision
Uses definition from: MSM-02-005 — EC shorthand wire-type mapping
Receive ER (Embargo Rejected)

Behaviors triggered when a participant receives an ER (Embargo Rejected) message, transitioning EM state from Proposed to None and acknowledging receipt.

Trigger: Message Received — ER

ID Priority Requirement Related
EMB-06-001 MUST A Participant in EM Proposed (q^em ∈ P) receiving ER MUST move their EM state along the reject transition of EMB-18-005: back to None (q^em P → N) when the rejected proposal was the last one open, and staying in Proposed (q^em P → P) while another proposal is open. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

If the receiver stayed in Proposed after the last open proposal is rejected, it would wait for an answer that does not come, and it would show an embargo negotiation that has ended. None tells every participant that no embargo binds the case. While another proposal is open, EM stays in Proposed, because that proposal still waits for an answer (ADR-0130). The ledger commit of the ER acknowledges it.

ECA Details

Preconditions

- EM state is Proposed
- EM state: PROPOSED

Steps

1. [receiver] Transition EM state from PROPOSED to NONE → Receiver EM state is NONE
2. [receiver] CASE_MANAGER commits the received ER and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is NONE (proposal rejected), or PROPOSED while another proposal is open; EK discharged by the ledger commit

Uses definition from: MSM-02-006 — ER shorthand wire-type mapping
Uses definition from: EP-09-009
Refines: EMB-18-005
See also: MSM-02-009 — context for the reader
Receive ET (Embargo Terminated)

Behaviors triggered when a participant receives an ET (Embargo Terminated) message, transitioning EM state to Terminated and acknowledging receipt.

Trigger: Message Received — ET

ID Priority Requirement Related
EMB-07-001 MUST A Participant in EM Active (q^em ∈ A) receiving ET MUST transition their EM state to Exited (q^em A → X). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

ET is the message that terminates an active embargo. The receiver records that the embargo has ended. ET has immediate effect regardless of other pending messages.

ECA Details

Preconditions

- EM state is Active
- EM state: ACTIVE

Steps

1. [receiver] Transition EM state from ACTIVE to EXITED → Receiver EM state is EXITED
2. [receiver] CASE_MANAGER commits the received ET and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is EXITED; EK discharged by the ledger commit

Uses definition from: MSM-02-007 — ET shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-07-002 MUST A Participant in EM Revise (q^em ∈ R) receiving ET MUST transition their EM state to Exited (q^em R → X). "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

ET terminates the embargo regardless of whether a revision is pending. The revision proposal is abandoned upon termination.

ECA Details

Preconditions

- EM state is Revise
- EM state: REVISE

Steps

1. [receiver] Transition EM state from REVISE to EXITED → Receiver EM state is EXITED
2. [receiver] CASE_MANAGER commits the received ET and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists

Postconditions

- Receiver EM state is EXITED; pending revision abandoned; EK discharged by the ledger commit

Uses definition from: MSM-02-007 — ET shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
EMB-07-003 MUST A Participant already in EM Exited (q^em ∈ X) receiving ET MUST remain in Exited with no state transition. "Emit EK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no EK message is emitted (EP-09-009, MSM-02-009).

Exited is already the terminal state, so a duplicate termination message needs no additional transition and no acknowledgment of its own.

ECA Details

Preconditions

- EM state is Exited
- EM state: EXITED

Steps

1. [receiver] Make no state change for the duplicate ET → EM state remains EXITED; no EK message exists

Postconditions

- EM state remains EXITED; no EK message emitted

Uses definition from: MSM-02-007 — ET shorthand wire-type mapping
Uses definition from: EP-09-009
See also: MSM-02-009 — context for the reader
Receive EE (Embargo Error)

Behaviors triggered when a participant receives an EE (Embargo Management Error) signal, which has no dedicated semantic dispatch value and is handled outside the standard AS2 pattern-matching pipeline.

Trigger: Message Received — EE

ID Priority Requirement Related
EMB-08-001 SHOULD A Participant that receives Create(ProcessingFault) about an embargo activity it sent SHOULD inquire about the nature of the error (GI) when the fault does not say what went wrong. EE has no wire activity of its own (MSM-02-008, MSM-05-001). The receiver emits no EK for the fault (EP-09-009).

A fault report says that an embargo activity failed, but it does not always say why. An inquiry lets the sender explain the error and enables recovery. A fault report does not trigger an EM state transition, and the error is grouped by failure mode, not by state machine, so no EE or EK message exists.

ECA Details

Steps

1. [receiver] Emit GI to inquire about the nature of the error → GI queued for sender; no EK message exists

Postconditions

- GI emitted; EM state unchanged

Refines: VP-11-005 — SHOULD inquire (GI) about the nature of an error reported by a fault about an E message; no EK message exists
Uses definition from: MSM-02-008 — EE shorthand wire-type mapping
Uses definition from: EP-09-009
See also*: MSM-05-001 — context for the reader
Receive EK (Embargo Acknowledgment)

Behaviors triggered when a participant receives the acknowledgment (EK) of an embargo activity it sent. No EK message exists (EP-09-009): the acknowledgment is the CASE_MANAGER's commit of the activity, fanned out as Add(CaseLedgerEntry).

Trigger: Message Received — EK

ID Priority Requirement Related
EMB-09-001 MAY A Participant that receives the CASE_MANAGER's Add(CaseLedgerEntry) for an embargo activity it sent MAY treat that entry as the acknowledgment (EK) of the activity, with no further state transition and no required response. No EK message exists (EP-09-009, MSM-02-009).

The ledger entry confirms that the CASE_MANAGER received and recorded the earlier E message. As an acknowledgment it carries no new decision about the embargo, so it gives the receiver nothing more to change and nothing to answer. The replica acknowledges the entry itself through its unbroken hash chain (MSM-05-002).*
Uses definition from: MSM-02-009 — EK shorthand wire-type mapping
Uses definition from: EP-09-009
Enter EM Proposed

Trigger: State Entered — EM.PROPOSED

ID Priority Requirement Related
EMB-10-001 MAY A Participant entering EM Proposed MAY evaluate the proposed terms and answer the Invite with Accept(Invite(EmbargoEvent)) or Reject(Invite(EmbargoEvent)), or counter-propose with EV.

EM Proposed marks that embargo negotiation is underway. The participant must evaluate the proposal and eventually accept, counter, or reject to move the EM process forward. Its answer is its own consent (MSM-07-003, MSM-07-004); the Case Owner's EA or ER decides the proposal for the case (MSM-02-002, MSM-02-006).

ECA Details

Preconditions

- EM state is Proposed
- EM state: PROPOSED

Refines: VP-04-004 — Once proposed, an embargo MAY be accepted or rejected
Refines: VP-06-010 — Participants MAY accept or reject any proposed embargo as they see fit
EMB-10-002 SHOULD NOT A Participant in RM Invalid or Deferred or Closed (q^rm ∈ {I, D, C}) SHOULD NOT begin or continue embargo negotiations while in those inactive RM states.

VP-13-002 and VP-13-003 discourage starting EM in inactive RM states. An embargo proposed while a report is invalid or deferred is unlikely to result in productive coordination.

ECA Details

Preconditions

- Participant is in RM Invalid/Deferred/Closed
- RM state: INVALID, DEFERRED, CLOSED

Satisfies: VP-13-002 — SHOULD NOT begin EM in an inactive RM state
Satisfies: VP-13-003 — SHOULD NOT begin EM with a proposal from a Participant in RM Invalid
Enter EM Active

Trigger: State Entered — EM.ACTIVE

ID Priority Requirement Related
EMB-11-001 SHOULD NOT A Participant in EM Active SHOULD NOT share the vulnerability report with a newly invited Participant until that Participant has accepted the existing embargo terms.

VP-08-006 prohibits sharing the vulnerability report with new Participants who have not yet accepted an existing embargo. Sharing before acceptance undermines the embargo's confidentiality guarantees.

ECA Details

Preconditions

- EM state is Active
- EM state: ACTIVE

Refines: VP-08-006 — SHOULD NOT share vulnerability report with newly invited Participant unless they accepted the embargo
EMB-11-002 SHOULD A Participant entering EM Active SHOULD maintain the embargo by not publishing information about the vulnerability until the embargo is terminated, whether on reaching its end time or early. An embargo whose end time has passed is ended by the CASE_MANAGER with the reason END_TIME_REACHED (EMB-13-003); until that termination reaches a Participant, its end time still bounds what it withholds.

VP-05-014 specifies that Participants SHOULD NOT publish information about the vulnerability when there is an active embargo. Entering Active marks the formal commitment to these terms. Reaching the end time does not end the embargo by itself: the termination is a register change the CASE_MANAGER commits, so every Participant learns of it the same way (ADR-0122).

ECA Details

Preconditions

- EM state is Active
- EM state: ACTIVE

Satisfies: VP-05-014 — SHOULD NOT publish information when there is an active embargo
See also: EMB-13-003 — context for the reader
EMB-11-003 MUST NOT A Participant in RM Closed or Deferred (q^rm ∈ {C, D}) in EM Active while other Participants remain engaged MUST NOT automatically terminate the embargo due to their own RM closure or deferral.

VP-13-009 explicitly requires that a single Participant's closure or deferral SHALL NOT automatically terminate the embargo. The embargo persists as long as other Participants remain engaged and the EM process is Active.

ECA Details

Preconditions

- Participant is in RM Closed/Deferred; EM state is Active
- RM state: CLOSED, DEFERRED
- EM state: ACTIVE

Refines: VP-13-009 — A Participant's closure or deferral SHALL NOT automatically terminate the embargo
EMB-11-004 SHOULD Reports with no further tasks (q^rm ∈ {D, I}) SHOULD be held in Deferred or Invalid while the embargo remains Active or Revise (q^em ∈ {A, R}) rather than being closed.

VP-13-006 advises keeping the report in a non-terminal RM state until the embargo has exited. Closing early may prematurely signal disengagement from the coordinated timeline.

ECA Details

Preconditions

- Participant is in RM Deferred/Invalid; EM state is Active or Revise
- RM state: DEFERRED, INVALID
- EM state: ACTIVE, REVISE

Satisfies: VP-13-006 — SHOULD be held in Deferred or Invalid until embargo exits
EMB-11-005 SHOULD A Participant who intends to change their adherence stance to an active embargo SHOULD communicate that intent clearly to other Participants.

VP-13-008 requires communicating changes to embargo adherence. Surprises about who is or is not honoring the embargo undermine coordinated disclosure.

ECA Details

Preconditions

- EM state is Active
- EM state: ACTIVE

Satisfies: VP-13-008 — Changes to adherence intention SHOULD be communicated clearly
Enter EM Revise

Trigger: State Entered — EM.REVISE

ID Priority Requirement Related
EMB-12-001 MAY A Participant entering EM Revise MAY evaluate the revision proposal and answer its Invite with Accept(Invite(EmbargoEvent)) or Reject(Invite(EmbargoEvent)), or counter-propose a further revision with EV.

EM Revise means an active embargo has a pending revision proposal. The participant must evaluate the proposed new terms and either accept, reject, or counter-propose to move the EM process forward. Its answer is its own consent (MSM-07-003, MSM-07-004); the Case Owner's EC or EJ decides the revision for the case (MSM-02-005, MSM-02-004).

ECA Details

Preconditions

- EM state is Revise
- EM state: REVISE

Refines: VP-04-005 — Once accepted, revisions MAY be proposed, which MAY be accepted or rejected
EMB-12-002 MUST NOT A Participant in RM Closed or Deferred (q^rm ∈ {C, D}) in EM Revise while other Participants remain engaged MUST NOT automatically terminate the embargo due to their own RM state.

VP-13-009 applies equally in Revise state. A single Participant's closure or deferral SHALL NOT automatically terminate the embargo. The embargo remains in force even when one Participant's engagement has declined.

ECA Details

Preconditions

- Participant is in RM Closed/Deferred; EM state is Revise
- RM state: CLOSED, DEFERRED
- EM state: REVISE

Refines: VP-13-009 — A Participant's closure or deferral SHALL NOT automatically terminate the embargo
EMB-12-003 SHOULD A Participant who intends to change their adherence stance while an embargo is in Revise state SHOULD communicate that intent clearly to other Participants.

VP-13-008 requires communicating changes to embargo adherence. This applies during revision negotiations as well as during the stable Active state.

ECA Details

Preconditions

- EM state is Revise
- EM state: REVISE

Refines: VP-13-008 — Changes to adherence intention SHOULD be communicated clearly
Enter EM Exited

Trigger: State Entered — EM.EXITED

ID Priority Requirement Related
EMB-13-001 SHOULD A Participant entering EM Exited SHOULD treat no participant as bound by an embargo. The embargo register's ACTIVE entry is TERMINATED, and no consent row is written (MSM-07-025, ADR-0118, ADR-0122).

Once the embargo exits, no consent row binds anyone: with no ACTIVE register entry nobody is a signatory, and a register with a TERMINATED entry accepts no further change (ADR-0122), so no later invitation to the terminated embargo can rebind anyone. The position is derived from the case, so it is not copied onto each participant record.

ECA Details

Preconditions

- EM state is Exited
- EM state: EXITED

Steps

1. [participant] Terminate the register's ACTIVE entry; write no Participant consent row → No Participant is bound by an embargo; consent rows are as they were

Postconditions

- No active embargo and no signatory; EM state is terminal EXITED

See also: MSM-07-025 — context for the reader
EMB-13-003 MUST When the end time of the embargo in force has passed, the CASE_MANAGER MUST end it with the reason END_TIME_REACHED, through one idempotent termination path. Two ways reach that path. One is the CASE_MANAGER's own lazy check when it next handles the case, for an inbound activity or one of its own triggers. The other is an outside request to end the embargo at its end time, such as from a Sentinel that monitors embargo timers. A request to end the embargo early, made after its end time, takes the same path. Each way commits the CASE_MANAGER's Remove(EmbargoEvent) with content END_TIME_REACHED and runs the full termination cascade. The outside request is made to the CASE_MANAGER itself. A Remove from the Case Owner is the owner's own message, ledgered on receipt like any other.

VP-04-001 requires every accepted embargo to have an end time, so every embargo reaches one; recording the end as a termination keeps EM derived from the register, and lets the content gate stop withholding content under an embargo that has expired. The lazy check needs no scheduler; the outside request lets a deployment end an embargo on time without waiting for the next activity on the case. One path keeps the two from both committing: a register with a TERMINATED entry accepts no further change (ADR-0122).

ECA Details

Preconditions

- An embargo is in force and its end time has passed
- EM state: ACTIVE, REVISE

Postconditions

- The register's ACTIVE entry is TERMINATED with reason END_TIME_REACHED, every open proposal CANCELLED, EM EXITED, and the teardown announced

EMB-13-006 MUST Whichever of the lazy check and the outside request (EMB-13-003) arrives after the embargo has ended MUST commit nothing.

One path keeps the two from both committing: a register with a TERMINATED entry accepts no further change (ADR-0122).
Extends: EMB-13-003
EMB-13-007 MUST The CASE_MANAGER MUST answer an end-time request (EMB-13-003) that arrives after the embargo has ended as already done.

The requester asked for an outcome the case already holds, so the answer tells it the embargo is ended rather than refusing it.
Extends: EMB-13-003
EMB-13-008 MUST An END_TIME_REACHED termination claimed before the embargo's end time MUST be refused, by the CASE_MANAGER before it commits and by a replica that replays it.

An END_TIME_REACHED reason claims the end time has passed. A claim made before then is false, and the content gate would stop withholding content under an embargo that is still in force.
Extends: EMB-13-003
EMB-13-004 MUST A termination Remove(EmbargoEvent) MUST carry what ended the embargo in content, exactly END_TIME_REACHED or EARLY. Its summary carries a human-readable account the protocol does not read.

The what is all a receiver needs to apply a termination and to check it against the end time; the why records the decision. A cause is a kind with its own details, so a new cause (adversary awareness, exploit code held by adversaries, a participant's leak) is a new kind rather than a change to a closed list (ADR-0122).
EMB-13-009 MUST A receiver MUST refuse, at the parse edge, a termination Remove(EmbargoEvent) whose content is anything other than END_TIME_REACHED or EARLY (EMB-13-004).

The what is all a receiver needs to apply a termination and to check it against the end time, so a termination without a valid what cannot be applied.
Extends: EMB-13-004
EMB-13-010 MUST The TERMINATED register entry MUST record the termination's reason (the what) and, when known, a structured cause (the why). The cause is an object discriminated on kind, whose details depend on the kind. One kind is THREAT_SIGNAL, with the signals (P, X, A) that ended the embargo, distinct and in that order. Another, FIX_READY, has the vendor participants whose readiness made the quorum (VP-09-007). The other kinds are FIX_DEPLOYED, and OTHER, whose account is the summary.

The why records the decision. A cause is a kind with its own details, so a new cause (adversary awareness, exploit code held by adversaries, a participant's leak) is a new kind rather than a change to a closed list (ADR-0122).
Extends: EMB-13-004
See also: VP-09-007 — context for the reader
EMB-13-011 MUST NOT An END_TIME_REACHED termination MUST NOT record a cause (EMB-13-010). Every cause kind is EARLY, and an EARLY termination with no cause is valid and records the what alone.

A cause explains why an embargo ended before its end time. An embargo that ran to its end time has no such cause.
Extends: EMB-13-010
EMB-13-005 MUST A termination Remove(EmbargoEvent) whose termination has a cause (EMB-13-010) MUST carry it as terminationCause.

One ledger entry is one activity, and the termination's entry is the whole TERMINATE register step (ADR-0124), so the why reaches a replica replaying the ledger only if the Remove carries it. A threat signal is a fact about the case that every participant learns from a status entry; naming it on a Remove while the case status does not show it would leave the register and the status disagreeing, and reading the Remove as a status change would commit one no participant sent (ADR-0122).
Uses definition from: EMB-13-010 — Carries the recorded cause on the wire so replicas can copy it
EMB-13-012 MUST At the parse edge, a receiver MUST refuse a bad terminationCause (EMB-13-005). A cause is bad when its kind is unknown, when a detail is missing or malformed, or when the termination is END_TIME_REACHED.

A cause the receiver cannot read, or one on a termination that can have none (EMB-13-011), would put a TERMINATED entry in the register that no other node can reproduce.
Extends: EMB-13-005
EMB-13-013 MUST A FIX_READY, FIX_DEPLOYED or OTHER cause on the Case Owner's Remove to the CASE_MANAGER is the owner's claim. The CASE_MANAGER MUST record it as given.

These causes are the owner's account of its own decision, which the CASE_MANAGER has no grounds to check against its own view of the case.
Extends: EMB-13-005
EMB-13-014 MUST The CASE_MANAGER MUST refuse a THREAT_SIGNAL cause on the Case Owner's Remove before it is committed. The refusal's reason directs the sender to a case status update that sets P, X or A, the way a threat signal ends an embargo.

A threat signal is a fact about the case that every participant learns from a status entry. Naming it on a Remove while the case status does not show it would leave the register and the status disagreeing, and reading the Remove as a status change would commit one no participant sent (ADR-0122).
Extends: EMB-13-005
EMB-13-015 MAY A Remove that the CASE_MANAGER sends MAY name THREAT_SIGNAL as its cause. No other Remove names it (EMB-13-014).

The CASE_MANAGER ends an embargo on a threat signal it has adopted into the case status, so its Remove and the status agree.
See also: EMB-13-014 — context for the reader
EMB-13-016 MUST A replica MUST record, on its TERMINATED entry, the cause that the termination's ledger entry carries.

One ledger entry is one activity, and the termination's entry is the whole TERMINATE register step (ADR-0124), so the why reaches a replica replaying the ledger only if the Remove carries it.
Extends: EMB-13-005
EMB-13-017 MUST NOT A replica MUST NOT work a termination cause out from its own case state.

A replica's own view can differ from the CASE_MANAGER's, such as threat signals its PXA does not carry. A cause it worked out would then disagree with the CASE_MANAGER's TERMINATED entry (CM-23-016).
Extends: EMB-13-016
EMB-13-002 MUST NOT A Participant in EM Exited MUST NOT seek new embargoes or accept new embargo proposals (EP) for this case when the CS state is public (q^cs ∈ ···P··), exploit-public (q^cs ∈ ····X·), or attacks-observed (q^cs ∈ ·····A).

VP-06-001 prohibits seeking new embargoes once public disclosure, exploit publication, or attacks have occurred. The EXITED state after any of these events is terminal for embargo negotiations on this case.

ECA Details

Preconditions

- EM state is Exited; CS matches pattern ...P..
- EM state: EXITED
- CS pattern: ...P..
- EM state is Exited; CS matches pattern ....X.
- EM state: EXITED
- CS pattern: ....X.
- EM state is Exited; CS matches pattern .....A
- EM state: EXITED
- CS pattern: .....A

Refines: VP-06-001 — No new embargo once public awareness, exploit publication or attacks have occurred
Actor-Voluntary Embargo Termination (Trigger Side)

Trigger-side factory for voluntarily ending an active embargo (e.g., fix deployed or ready). "The actor" here is the actor enacting the CASE_MANAGER role: the factory's canonical case-state write (EM → EXITED, ledger commit, teardown announce) is gated on CVDRole.CASE_MANAGER (terminate_embargo_bt runs ResolveCaseManagerNode before the state mutation) and is authorised by the Case Owner by default (CM-02-005). A teardown that a received P, X or A report calls for is authorised by the Case Owner's adoption of that value, with no second gate (RSH-07-001, ADR-0210). A non-manager Participant that wishes to end an embargo does not run this trigger to write canonical state; it initiates termination by reporting the condition or notifying intent (VP-11-003, VP-13-017/018), and terminates only its own compliance. See CONCERN-3280 for the reconciliation of the participant-facing protocol prose with this authority model.

Trigger: State Entered — EM.ACTIVE

ID Priority Requirement Related
EMB-14-001 MUST An actor that ends an active embargo early of its own accord MUST name its reason: a deployed fix, a ready fix, or another reason.

Voluntary termination requires an auditable reason.

ECA Details

Preconditions

- EM state is Active or Revise
- EM state: ACTIVE, REVISE

Steps

1. [actor] Choose the termination reason (fix deployed, fix ready, or other) → Reason chosen

Postconditions

- A termination reason is chosen

EMB-14-005 MUST NOT An actor that names no reason MUST NOT end an active embargo early of its own accord.

A termination with no reason gives the other participants nothing to audit (EMB-14-001).

ECA Details

Postconditions

- EM state is unchanged

Derives from: EMB-14-001
EMB-14-006 MUST An actor that ends an active embargo early of its own accord MUST record its reason as the termination's cause (EMB-13-010). The cause is FIX_DEPLOYED, FIX_READY or OTHER respectively, never an EARLY termination with no cause.

Recording the chosen reason as the cause carries it to every participant through the termination's ledger entry, where a cause-less EARLY termination would tell them only that the embargo ended.

ECA Details

Steps

1. [actor] Terminate the embargo, recording the chosen reason as its cause → ET emitted carrying the cause; EM transitions to EXITED

Postconditions

- EM state is EXITED; ET queued; termination cause recorded

Extends: EMB-14-001
Uses definition from: EMB-13-010
Inbound Embargo-Response Decision (Received Side)

Behaviors triggered when an actor receives an inbound embargo overture and must decide how to respond. Two overture flows are distinguished: (Flow A) an EM-level embargo proposal (EP) proposing terms, whose acceptance moves the shared EM state; and (Flow B) a PEC-level invitation (Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) asking the actor to become a signatory to an embargo, whose acceptance advances that participant's Participant Embargo Consent (PEC) state. The pre-PEC simulator conflated these into a single _ChooseEmProposedResponse fallback; the production protocol separates the shared EM lifecycle (EMB-01..EMB-09) from per-participant consent (CM-18, ADR-0048). This group specifies a single decision seam layered over both flows: it selects the response (accept / reject / counter) while delegating the mechanical transition to the existing received and trigger BTs. The mechanics already exist (invite/accept/reject trees, propose/accept/reject trigger use cases); the decision layer chooses among them with a default-accept policy, decided by the deciding actor's own policy and approved by no other actor.

Trigger: Message Received — EP | InviteToEmbargoOnCase

ID Priority Requirement Related
EMB-15-004 MUST An actor that rejects an embargo overture MUST answer with the activity that matches what it rejects. The Case Owner deciding a proposal for the case sends ER, its Reject(EmbargoEvent)[target=VulnerabilityCase], which returns the shared EM to NONE (EMB-06, MSM-07-009). A participant answering an embargo Invite sends a Reject of the Invite, which records only its own consent (MSM-07-004). That Reject marks the rejected embargo's row DECLINED. A signatory refusing proposed terms keeps its row for the embargo in force (MSM-07-015).

A proposal and an Invite carry different EM and consent semantics, so the rejection has to match the overture for every participant to read it the same way. The pre-public constraint (EMB-01-002) is a hard protocol rule that overrides any local acceptance policy.

ECA Details

Preconditions

- Inbound overture received; decision resolves to reject, OR CS is public/exploit/attacks forcing rejection (EMB-01-002)

Steps

1. [participant] Answer with the rejection that matches the overture → The Case Owner's decision on a proposal is ER (EM → NONE); an embargo Invite gets a Reject of the Invite, recording DECLINED

Postconditions

- Overture rejected with the activity that matches it

Uses definition from: MSM-07-009
Uses definition from: MSM-07-004
See also: MSM-07-015 — context for the reader
EMB-15-009 MAY The Case Owner MAY send a Reject(Invite(EmbargoEvent)) besides its decision for the case. That Reject records only the owner's own consent, like any sender's (MSM-07-004).

The owner is also a participant with a consent row of its own. Its decision for the case is a separate activity (MSM-07-009, ADR-0122), so its Invite answer decides nothing for the case.
Uses definition from: MSM-07-004
EMB-15-010 MUST A participant MUST send the refusal EMB-01-002 requires whatever its own decision on the overture would have been.

The pre-public constraint (EMB-01-002) is a hard protocol rule that overrides any local acceptance policy, so no decision seam may answer in its place.
Refines: EMB-01-002 — Mandatory rejection when public/exploit/attacks overrides default-accept
CS Public/Exploit/Attacks Detected While EM Proposed

Behaviors required when a Participant detects that the vulnerability has become public (q^cs ∈ ···P··), an exploit is available (q^cs ∈ ····X·), or attacks have been observed (q^cs ∈ ·····A) while the case EM state is still Proposed (q^em ∈ P). Embargo negotiation is not viable in any of these states; the proposed embargo MUST be abandoned.

Trigger: State Entered — CS.public_exploit_attacks

ID Priority Requirement Related
EMB-16-001 MUST A Participant in EM Proposed (q^em ∈ P) MUST abandon the proposed embargo when it detects a CS transition into P, X or A. The P state is public (q^cs ∈ ···P··), X is exploit-available (q^cs ∈ ····X·), and A is attacks-observed (q^cs ∈ ·····A). It cancels each open proposal in the case's embargo register, so EM derives None (q^em P → N). The CASE_MANAGER cancels a proposal it received with its ER, Reject(Invite(EmbargoEvent)), committed as reject_invite_to_embargo_on_case. It cancels a proposal it made itself with its Undo(Invite(EmbargoEvent)), committed as undo_invite_to_embargo_on_case. After either, it sends its Undo(Invite(EmbargoEvent)) of each Invite it relayed for that proposal. A proposal never relayed is cancelled all the same.

EMB-01-002 establishes that embargo negotiation is not viable once public disclosure, exploit availability, or attacks have occurred. EMB-01-002 is framed as a guard on receiving EP, but the same viability constraint applies when a P/X/A state change arrives while a proposal is already in flight. Continuing to negotiate a proposed embargo in these conditions would be misleading to other Participants and counter to the purpose of coordinated disclosure. CANCEL records that nobody decided the proposal (ADR-0122). An actor undoes only an activity it performed, so withdrawing an Invite one sent is an Undo and declining one received is a Reject; a CASE_MANAGER act with a participant's verb and object carries the participant's semantic type (ADR-0152).

ECA Details

Preconditions

- EM state is Proposed
- EM state: PROPOSED
- CS transitions to public (q^cs ∈ ···P··)
- CS pattern: ...P..
- CS transitions to exploit-available (q^cs ∈ ····X·)
- CS pattern: ....X.
- CS transitions to attacks-observed (q^cs ∈ ·····A)
- CS pattern: .....A

Steps

1. [system] Detect that CS has transitioned to a P/X/A state while EM is Proposed → An open proposal is recognised
2. [system] As the CASE_MANAGER, cancel each open proposal: commit its Reject of the proposal, or its Undo of an own proposal, then an Undo of each Invite relayed for it → Each proposal's register entry is CANCELLED and EM derives NONE; the entries are committed and replayed by every replica

Postconditions

- EM state is NONE; the abandonment is committed; proposed embargo abandoned

EMB-16-003 MUST A Participant that abandons a proposed embargo on a P/X/A transition (EMB-16-001) MUST notify the other Participants.

Continuing to negotiate a proposed embargo that is no longer viable would mislead the other Participants. The CASE_MANAGER's committed entries are the notice to every other Participant (EP-09-007, EP-09-009).
Extends: EMB-16-001
EMB-16-004 MUST The CASE_MANAGER MUST commit the entries that abandon every open proposal (EMB-16-001) in one transaction (CLP-07-015).

A partly committed abandonment would leave some proposals open after the case reached P/X/A, so the case's register and its replicas would disagree about which proposals are still open.
Extends: EMB-16-001
Refines: CLP-07-015
EMB-16-005 MUST A replica MUST apply each abandoned proposal's CANCEL once, from the entry that carries it (ADR-0152).

The CASE_MANAGER's Reject cancels the proposal, and each Undo after it finds the proposal cancelled and changes nothing. Applying the CANCEL from its own entry keeps the replica's register equal to the CASE_MANAGER's.
Extends: EMB-16-001
EMB-16-002 MUST NOT This rule covers a Participant without the CASE_MANAGER role that detects a P/X/A CS transition while EM is Proposed. It MUST NOT emit ER as the abandonment of the case's open proposals.

Abandoning the case's open proposals is a decision for the case, and only the actor that holds the CASE_MANAGER role writes shared EM state (EMB-16-001, EP-09-008). The P/X/A signal already reaches the CASE_MANAGER as a status declaration, and the CASE_MANAGER abandons the proposals when it detects that signal. A Reject of the Invite that another Participant sends arrives at the CASE_MANAGER as that Participant declining the proposal (MSM-07-004). The CASE_MANAGER records only that decline, so the Reject cannot abandon the proposals, and it misstates what the Participant meant.
Extends: EMB-16-001
Refines: EP-09-008
EMB-16-006 MUST NOT This rule covers a Participant without the CASE_MANAGER role that detects a P/X/A CS transition while EM is Proposed. It MUST NOT write the abandonment to its own EM state.

Only the actor that holds the CASE_MANAGER role writes shared EM state (EMB-16-001, EP-09-008). Another Participant's EM moves when its replica replays the CASE_MANAGER's entries.
Extends: EMB-16-002
Refines: EP-09-008
Late Accept of an Expired Embargo Invitation

Behaviors required when an Accept(Invite(EmbargoEvent)) arrives after the invitation's RSVP deadline (CM-28-001) has passed. The protocol is liberal in what it accepts: a late accepter has signalled willingness to coordinate and MUST NOT be sent away. Codified by ADR-0065. Source: IDEA-2066. What decides the answer is whether the named embargo is still available (MSM-07-012), as for an on-time Accept, never the deadline. The trigger is a Participant's consent answer, which carries no protocol shorthand (MSM-02-010).

Trigger: Message Received — AcceptInviteToEmbargoOnCase

ID Priority Requirement Related
EMB-17-001 MUST A CASE_MANAGER receiving an Accept(Invite(EmbargoEvent)) after the invitation's effective RSVP deadline MUST NOT reject it solely because the deadline has passed.

Being liberal in what is accepted serves CVD outcomes. A late accepter is volunteering to coordinate; refusing them converts a missed deadline into a lost participant, which is worse for the case than a late consent. See ADR-0065.

ECA Details

Preconditions

- The referenced invitation's effective RSVP deadline has passed

Postconditions

- The Accept is not refused on deadline grounds; one of EMB-17-002, EMB-17-003, or EMB-17-004 has been applied

EMB-17-012 MUST The CASE_MANAGER MUST check whether a late Accept(Invite(EmbargoEvent)) names an available embargo (MSM-07-012). Those are the case's Active Embargo and its open proposals (MSM-07-003), before their end time. It then applies EMB-17-002, EMB-17-003 or EMB-17-004.

A late Accept can name the embargo in force, an open proposal, terms the case decided, replaced or let run out, or terms it never held. Each needs its own answer, read by the same test as for an on-time Accept. "Is this the Active Embargo" leaves out a case under proposal, and a test without the end time honours an Accept of terms that bind nobody. See ADR-0065.

ECA Details

Preconditions

- The referenced invitation's effective RSVP deadline has passed

Postconditions

- One of EMB-17-002, EMB-17-003, or EMB-17-004 has been applied

Extends: EMB-17-001
Refines: MSM-07-012
Uses definition from: MSM-07-003
See also: EMB-17-002 — context for the reader
See also: EMB-17-003 — context for the reader
See also: EMB-17-004 — context for the reader
EMB-17-002 MUST When the accepted embargo is available (MSM-07-012), the CASE_MANAGER MUST honour the late Accept. Available means the case's Active Embargo or one of its open proposals (MSM-07-003), before its end time. An ACTIVE entry past its end time is not available, so a late Accept of it is refused, not honoured. It marks the participant's consent row for that embargo AGREED, exactly as it would for an on-time Accept. A row at TIMED_OUT moves directly to AGREED (TIMED_OUT → AGREED, ADR-0118). So does one at DECLINED (DECLINED → AGREED, CM-18-003): the participant has changed its answer, so it is not re-invited first. The CASE_MANAGER honours it by committing the received Accept verbatim as accept_invite_to_embargo_on_case, carrying the row it states, as an on-time Accept is committed (EMB-17-009, ADR-0152).

An answer the case can still record is sound whenever it arrives. The deadline governs whether the invitation is open, not whether the agreement is sound, and an open proposal's row takes an answer until the Case Owner decides it, so dropping a late Accept of an open proposal would hide a willing participant from that decision. See ADR-0065. The Accept states the change, so its entry is the change's entry (CLP-07-013), and a replica reaches the state an on-time Accept leaves.

ECA Details

Preconditions

- EM state is Proposed, Active or Revise
- EM state: PROPOSED, ACTIVE, REVISE
- The accepted embargo is the case's Active Embargo or one of its open proposals, and its end time has not passed

Steps

1. [system] Record the PEC AGREE transition for the accepting participant → The participant's consent row for the accepted embargo is AGREED

Postconditions

- The participant's consent row for the accepted embargo is AGREED, so it is a signatory when that embargo is the Active Embargo

Refines: EMB-17-001
Uses definition from: MSM-07-012
Uses definition from: MSM-07-003
Uses definition from: CM-18-003
EMB-17-003 MUST An Accept, late or on time, may name an embargo the register holds but that is not available. The CASE_MANAGER refuses it with the refusal notice (MSM-07-012). When the case holds terms of its own, the CASE_MANAGER MUST also send the accepter a fresh Invite(EmbargoEvent) naming those terms. The fresh Invite goes alongside the refusal notice. The terms are the case's Active Embargo, while it is available. Otherwise they are its earliest-expiring available open proposal (EP-08-002). An accepting participant at TIMED_OUT moves TIMED_OUT → INVITED for the invited embargo (ADR-0118). The fresh Invite is a relay (EP-09-002). Its actor is the CASE_MANAGER. Its attributedTo names the invited embargo's proposer, or the CASE_MANAGER itself when it made the embargo as the protocol default, without a proposal.

Recording the stale Accept as consent binds the participant to terms it never saw; refusing it alone leaves a willing participant unasked. The re-invite asks about the terms that bind, in a relay's shape (ADR-0152). Naming the Active Embargo alone leaves a case under proposal with nothing to invite to. The earliest-expiring proposal is the one a participant answers first (EP-08-001); arrival order would ask about superseded terms. See ADR-0065.

ECA Details

Preconditions

- The register holds the accepted embargo, but it is not available, and the case has an available Active Embargo or open proposal

Steps

1. [system] Emit the refusal notice and a fresh Invite(EmbargoEvent) to the accepting actor carrying the case's current terms → Accepting participant's consent row for the invited embargo is INVITED; stale Accept is not recorded as consent

Postconditions

- A fresh invitation for the case's current terms has been sent; the actor remains a case participant

Refines: EMB-17-001
Extends: MSM-07-012
Uses definition from: EP-08-002
Uses definition from: EP-09-002
EMB-17-013 MUST Once it has queued the fresh Invite of EMB-17-003 (SYNC-09-002), the CASE_MANAGER MUST commit it as invite_to_embargo_on_case. The invitee's INVITED row with the Invite's deadline follows it (CM-28-013).

The re-invite asks about terms somebody proposed, exactly as a relay does, so it carries the relay's semantic type (ADR-0152). Committing it after it is queued lets a rebuilt send keep the same id (SYNC-09-002).
Extends: EMB-17-003
Refines: CM-28-013
Refines: SYNC-09-002
EMB-17-014 MUST A replica MUST apply the CASE_MANAGER's re-invite (EMB-17-003) through the relay slot, so that the Invite proposes nothing and EM does not move.

The replica's register already holds the embargo the Invite names, so the Invite asks for consent to it and changes no embargo state (ADR-0152).
Extends: EMB-17-003
EMB-17-005 MUST NOT The accepted embargo is neither the Active Embargo nor an open proposal. The CASE_MANAGER MUST NOT then record the stale Accept as consent to the current terms.

Recording the stale Accept as consent would make the participant a signatory to terms they never saw. An Accept of an open proposal is not stale: the case can still record it on that proposal's own row (EMB-17-002). See ADR-0065.
Extends: EMB-17-003
EMB-17-006 MUST NOT When the accepted embargo is not available, the CASE_MANAGER refuses the Accept (MSM-07-012). It MUST NOT refuse the accepting actor's participation: the refusal is of the Accept alone.

Refusing a willing participant discards coordination capacity. The refusal notice says the answer is moot, never that the actor is unwelcome, and re-inviting to the current terms is the rest of the answer. See ADR-0065.
Extends: EMB-17-003
Refines: MSM-07-012
EMB-17-004 MUST This rule covers a case with no Active and no Proposed Embargo (EM EXITED or NONE). There, the CASE_MANAGER MUST answer a late Accept of an embargo its register holds with the refusal notice alone (MSM-07-012). A redelivery of the same Accept gets the same result.

Follows the EMB-07-003 precedent for post-terminal messages: no transition. There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested — but the actor's case participation is independent of embargo consent and MUST survive. The sender is still owed word that its answer did not count, which the refusal notice gives (CLP-05-001). An Accept of terms the case never held gets a processing fault instead (MSM-07-039). See ADR-0065.

ECA Details

Preconditions

- EM state is EXITED (embargo terminated) or NONE (no embargo started)
- EM state: EXITED, NONE

Steps

1. [system] Refuse the Accept with the refusal notice, committing nothing and sending nothing else → Participant consent rows are unchanged; participant remains in the case; no ledger entry is committed and only the refusal notice is sent

Postconditions

- No embargo state change; accepting actor remains a case participant

Refines: EMB-17-001
Refines: MSM-07-012
EMB-17-015 MUST NOT The CASE_MANAGER MUST NOT commit any ledger entry for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004).

An entry acknowledging the Accept would change nothing at any receiver. The Accept is refused, and a refusal is never written to the ledger (CLP-04-007).
Part of: EMB-17-004
EMB-17-016 MUST NOT This rule covers a late Accept of an embargo the register holds, in a case with no Active and no Proposed Embargo (EMB-17-004). The CASE_MANAGER MUST NOT send any activity in reply to it but the refusal notice.

There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested. The refusal notice is owed: it tells the sender its answer did not count (MSM-07-012).
Part of: EMB-17-004
EMB-17-017 MUST The CASE_MANAGER MUST leave the participant's consent rows unchanged for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004). Nothing is recorded after a termination (EM EXITED), and a TIMED_OUT row stays TIMED_OUT when no embargo has started (EM NONE) (ADR-0118).

The Accept names an embargo that is no longer, or not yet, in force, so no row can bind to it. The actor's case participation is independent of embargo consent and survives.
Part of: EMB-17-004
EMB-17-007 MUST NOT When the case has no Active Embargo and no Proposed Embargo (EM state is EXITED or NONE), the CASE_MANAGER MUST NOT issue a fresh embargo invitation to the accepting actor.

There is no active embargo to invite the actor to; a fresh invitation would manufacture a negotiation nobody requested. See ADR-0065.
Derives from: EMB-17-004
EMB-17-008 MUST NOT When the case has no Active Embargo and no Proposed Embargo (EM state is EXITED or NONE), the CASE_MANAGER MUST NOT remove the accepting actor from the case.

Case participation is independent of embargo consent; the actor's willingness to coordinate must not result in their removal. See ADR-0065.
Derives from: EMB-17-004
EMB-17-009 MUST When the CASE_MANAGER honours a late Accept (EMB-17-002), it MUST commit the received Accept(Invite(EmbargoEvent)) verbatim as accept_invite_to_embargo_on_case. Its entry carries the AGREED row the Accept states, exactly as for an on-time Accept. A replica then copies the row without re-evaluating the deadline (RSH-08-004, ADR-0124, CLP-07-011).

Without a committed entry the replica has no signal that the row moved to AGREED; the replica's participant record would silently stay TIMED_OUT while the CASE_MANAGER's record shows AGREED, breaking ledger-driven convergence (ADR-0108, ADR-0118). The Accept states the change, so its entry is the change's entry (CLP-07-013); a follow-up Update of the same row would record one state change twice. The deadline having passed is an observation anything holding the case can make, so it is not ledgered either (ADR-0152).

ECA Details

Postconditions

- The late Accept is committed as accept_invite_to_embargo_on_case in the CASE_MANAGER's store, and the accepter's AGREED row is copied from it in every replica's store

Extends: EMB-17-002
Refines: CLP-07-011
See also: RSH-08-004 — replica coverage is not a precondition of the commit
EMB-17-018 MUST NOT When the CASE_MANAGER honours a late Accept (EMB-17-002), it MUST NOT commit any further entry for the same row. An example is its own Update(EmbargoConsent) of the AGREED row (CLP-07-002, ADR-0152).

The Accept states the change, so its entry is the change's entry (CLP-07-013); a follow-up Update of the same row would record one state change twice.
Extends: EMB-17-009
Refines: CLP-07-002
See also: EMB-17-002 — context for the reader
EM Write-Boundary Consolidation

Requirements ensuring that all EM state transitions are executed through the EmbargoLifecycle service layer rather than written directly to case.current_status.em in BT nodes or helpers. Identified by audit in CONCERN-2412: three BT nodes (EmActivateEmbargo, ClearEmbargo, SetDefaultActiveEmbargoNode) bypass EmbargoLifecycle with direct EmDimension assignment. Complements SM-04-001 (general write-boundary guard requirement) with an EM-specific routing rule.

ID Priority Requirement Related
EMB-18-007 MUST A participant replica MUST fetch from the case's CASE_MANAGER the embargo an announced revision replaces, when it cannot read it (AKM-05-007). It defers the revision until the fetch settles (AKM-05-010), and refuses it only when the fetch fails (AKM-05-015).

A replica can lack a record the CASE_MANAGER holds through a gap or a lag, and the CASE_MANAGER can supply it (AKM-05-003). The fetch runs before the activation writer, so EMB-18-003's fail-closed read still guards the register.
Implements: EMB-18-003
Refines: AKM-05-007
Refines: AKM-05-010
See also: AKM-05-015 — context for the reader
EMB-18-004 MUST A receiver MUST refuse an inline EmbargoEvent whose context is neither the case that carries it nor a report that case holds (EP-04-009). The same refusal applies to the record the receiver already holds under the embargo's id. It applies whether the case or ledger entry carries the embargo inline or names it by bare id. For a ledger entry, the case's reports are those of the replica's stored case.

An embargo belongs to the case that its context names. A handler stores a carried embargo when its store does not hold that id yet, and the first write wins. An unchecked event would therefore let a sender plant the embargo of another case under an id that case will name later. That case would then name the planted record. The check therefore covers the record already held under the id, not only the carried copy. A Reporter's proposal names its report until the case exists, and it keeps its id after that (EP-04-004). A refusal of an embargo about one of the case's reports would refuse the Reporter its own case.
Uses definition from: EP-04-009
EMB-18-012 MUST A receiver MUST make an EMB-18-004 refusal before it writes anything. The event is then not stored, and no embargo state of either case changes.

A handler stores a carried embargo when its store does not hold that id yet, and the first write wins. A refusal after a write would leave the planted record in the store for the other case to name later.
Extends: EMB-18-004
EMB-18-005 MUST Every change to a case's embargo register MUST move the case's EM state only along an EM transition for the change's EM trigger: a proposal is propose, an activation is accept, a rejection, or the cancellation of open proposals with no embargo in force, is reject, and a termination is terminate. The EM transitions are propose: N→P, P→P, A→R, R→R; reject: P→N, P→P, R→A, R→R; accept: P→A, P→R, R→A, R→R; and terminate: A→X, R→X. A rejection leaves Proposed, and a rejection or an acceptance leaves Revise, only when no proposal remains open; an acceptance from Proposed moves to Active, or to Revise while another proposal stays open.

EM is computed from the embargo register (ADR-0122), not replaced by it: the EM state machine remains the protocol's model, and the register is a layer beneath it. With several proposals open, rejecting or activating one leaves the others open: a rejection keeps EM in Proposed or Revise until the last one is off the table, and an activation from Proposed puts the embargo in force with the others pending as revisions, in Revise (ADR-0130).
Extends: EMB-18-001
Embargo Teardown Announcement

Who authors the activity that tells the other participants of an embargo teardown, and who receives it. Added by ISSUE-2238 after the recipients were found to be unspecified, which is how they came to disagree with the tree's role gate.

ID Priority Requirement Related
EMB-19-001 MUST The actor that holds the CASE_MANAGER role for the case MUST author the activity that tells the other participants of an embargo teardown. That activity is an Announce(EmbargoEvent) after a received Remove(EmbargoEvent), and the CASE_MANAGER's own Remove(EmbargoEvent) for a teardown it starts.

The teardown changes canonical case state, so the actor that holds the CASE_MANAGER role announces it, and the participants are its audience. The tree that commits the teardown runs as the CASE_MANAGER, because the ledger commit is gated on that role. An announcement addressed to the CASE_MANAGER would therefore go to the announcing actor itself, and the teardown would reach nobody.
EMB-19-003 MUST The CASE_MANAGER MUST address the teardown Announce(EmbargoEvent) (EMB-19-001) to every active participant (CM-10-004) except itself.

The teardown changes canonical case state, and the participants are the audience of that change.
Extends: EMB-19-001
Uses definition from: CM-10-004
EMB-19-004 MUST NOT The CASE_MANAGER MUST NOT address the teardown Announce(EmbargoEvent) (EMB-19-001) to the CASE_MANAGER.

The tree that commits the teardown runs as the CASE_MANAGER, because the ledger commit is gated on that role. An announcement addressed to the CASE_MANAGER would go to the announcing actor itself and loop back for no additional record.
Extends: EMB-19-001
EMB-19-002 MUST When a case has no participants besides the CASE_MANAGER, the teardown announcement MUST be skipped rather than emitted with an empty recipient list.

An activity addressed to nobody is undeliverable, and delivery discards it anyway; constructing one only adds a queue entry that can never be resolved. Skipping keeps the teardown itself unaffected, consistent with the announcement being best-effort — a notification gap MUST NOT block a teardown.
Extends: EMB-19-001

Embargo Policy

Requirements for a standardized embargo policy record associated with an Actor profile. Allows actors to declare their default embargo preferences so that coordinators can evaluate compatibility before proposing an embargo or inviting an actor to a case.

Policy Record Format
ID Priority Requirement Related
EP-01-001 MAY An Actor profile MAY include an embargo_policy field containing the Actor's structured embargo policy record inline. The policy is part of the profile: an Actor has at most one, and it is published, read and replaced as a field of the profile, not as a separate object.

Whoever holds an Actor's profile then holds its embargo terms, so carrying the profile (CP-01-010) carries the policy, and no lookup has to choose among several records.
EP-01-002 MUST The embargo policy record MUST include attributedTo (the full URI of the Actor to which this policy applies) and preferred_duration (ISO 8601 duration string representing the Actor's preferred embargo length).

A coordinator that reads a policy needs to know whose terms it states and what length the actor prefers. Without attributedTo a policy copied out of its profile cannot be attributed, and preferred_duration is the actor default that shortest-wins reads at case creation (EP-04-003). The coordinator reaches the actor through the inbox in the profile attributedTo names: AS2 defines inbox for actors only, so a policy carries none (ADR-0194).
Uses definition from: DUR-01-001 — ISO 8601 duration format
EP-01-003 SHOULD The embargo policy record SHOULD include the optional fields minimum_duration (ISO 8601 duration), maximum_duration (ISO 8601 duration), and content (free-text string describing the Actor's embargo preferences).

A declared range tells a coordinator, before it proposes, which terms the actor will accept (EP-03-002), which saves a propose-and-reject round trip. Free-text notes carry preferences that a duration cannot express. The fields are optional because many actors hold only a preferred length.
Uses definition from: DUR-01-001 — ISO 8601 duration format
EP-01-005 MUST The embargo policy record MUST use a full-URI ID for attributedTo.

Other actors on other servers read and compare policies. A local or short identifier cannot be resolved or compared across servers, so a coordinator could attach a policy to the wrong actor; a full URI names one actor everywhere (OID-01-001).
Refines: OID-01-001
EP-01-006 SHOULD When minimum_duration is declared, an Actor SHOULD reject embargo proposals shorter than that value.

The minimum_duration field signals a floor below which the Actor will not accept an embargo; evaluating it prevents compatibility mismatches.
Uses definition from: EP-01-003
EP-01-007 SHOULD When maximum_duration is declared, an Actor SHOULD reject embargo proposals longer than that value.

The maximum_duration field signals a ceiling above which the Actor will not accept an embargo; evaluating it prevents compatibility mismatches.
Uses definition from: EP-01-003
Policy Compatibility Evaluation
ID Priority Requirement Related
EP-03-001 SHOULD Before proposing an embargo or inviting an actor to join an existing embargo, the CASE_MANAGER SHOULD retrieve and evaluate the target actor's embargo policy for compatibility with the proposed embargo terms

A proposal the invitee will reject costs a negotiation round and can leave the invitee outside the embargo while the round runs. Reading the published policy first lets the CASE_MANAGER choose terms the invitee has said it accepts, or know in advance that it will decline.
EP-03-002 MUST Compatibility evaluation MUST check that the proposed duration falls within the target actor's minimum_duration–maximum_duration range, if declared

The declared minimum and maximum are the actor's statement of what it will accept (EP-01-006, EP-01-007). An evaluation that ignored them would report terms as compatible that the actor has already said it will reject.
Default Embargo Semantics
ID Priority Requirement Related
EP-04-001 MUST When the CASE_OWNER's actor default embargo applies at case creation and the sender submitted no explicit embargo proposal, the case's initial EM state MUST be EM.ACTIVE, not EM.PROPOSED. The sender's report submission without a counter-proposal constitutes tacit acceptance of the CASE_OWNER's actor default embargo.

A sender that submits a report without terms of its own has nothing to object to in the receiver's default, so nobody is left to accept it. A case left at EM.PROPOSED would wait for an answer nobody owes, with no embargo in force at the moment the report is most sensitive.
Refines: DUR-07-003
EP-04-002 MUST NOT When a default embargo is created, the intermediate EM Proposed state MUST NOT be observable to other participants: no message, ledger entry or replica shows the embargo as Proposed.

The default embargo is in force from creation. A participant that saw it as Proposed would treat it as not yet agreed and could answer it or counter-propose, and its replica would record a negotiation that never happened.
EP-04-003 MUST This rule covers case creation where the sender proposes a duration and the CASE_OWNER's profile carries an embargo policy, its actor default (EP-01-001, CP-01-010). The CASE_MANAGER MUST make the shorter of the two the active embargo at once (EM ACTIVE).

Two parties that propose 30 and 60 days respectively agree on days 1–30 and disagree only on days 31–60. Activating the shorter embargo immediately captures all mutual agreement. See docs/topics/process_models/em/formal_model.md § "Why the shortest proposal wins" for the full vector-agreement derivation.
Refines: EP-08-001 — EP-04-003 is the two-party case-creation instance of this ordering rule. Both MUST resolve earliest-end-date first, and both MUST share one comparator (#3392).
Uses definition from: EP-01-001
Uses definition from: EP-04-004
See also: CP-01-010 — context for the reader
EP-04-016 SHOULD This rule covers case creation where both the sender and the CASE_OWNER have an applicable embargo proposal (EP-04-003). The CASE_MANAGER SHOULD register the longer of the two as a pending revision (EM REVISE).

The longer duration becomes a pending revision so the proposer can negotiate the contested portion. This is strictly better than rejecting it outright: both parties secure the overlap they both wanted.
Extends: EP-04-003
EP-04-004 MUST A sender MUST be able to propose embargo terms when it submits a report. It carries a proposed EmbargoEvent, inline or by reference, as the proposedEmbargo of the Offer(VulnerabilityReport) activity. That EmbargoEvent carries the report URI as its context (EP-04-009).

Without a way to state terms on the report, a sender with its own deadline can only take the receiver's default or negotiate after the case exists, and the shortest-wins comparison (EP-04-003) has no sender side to compare. The report Offer is the one message the sender sends before a case exists, so it carries the proposal, and the receiver's CaseProposal carries the Offer whole (CP-01-008), so the terms reach the CASE_MANAGER as the sender stated them.
Refines: EP-04-009
EP-04-017 MUST At case creation, the CASE_MANAGER MUST rewrite the context of the sender's proposed EmbargoEvent (EP-04-004) from the report URI to the case URI.

The context rewrite moves the terms onto the case once there is one, so the case's embargo is about the case like every other (EP-04-009).
Extends: EP-04-004
EP-04-005 MUST A protocol default embargo duration MUST exist.

The goal of the EM process is to lock in an embargo as early as possible (docs/topics/process_models/em/principles.md). Without a protocol default, a case with no embargo proposal and no actor default would have no embargo at all.
EP-04-018 MUST The protocol default embargo duration MUST be no less than 72 hours and no more than 5 days.

The 72-hour floor equals the default EP-07-002 minimum RSVP window, so the shortest embargo the protocol produces is as long as the shortest answer window it grants. The 5-day ceiling keeps a deployment from restoring a default generous enough to make publishing nothing better than publishing a policy.
Extends: EP-04-005
EP-04-019 MUST This rule covers an embargo-eligible case created with no embargo proposal and no actor default. The CASE_MANAGER MUST activate an embargo of the protocol default duration, so the case begins at EM.ACTIVE.

A case with no embargo is the outcome the process exists to avoid, and reaching it through mutual silence is the least deliberate way to arrive there.
Extends: EP-04-005
EP-04-006 MUST NOT The protocol default MUST NOT participate in the shortest-wins comparison of EP-04-003. It is the value applied when no proposal and no actor default applies, never a candidate within that comparison.

A 72-hour protocol default that competed under shortest-wins would win against every longer proposal and cap every embargo in the system at 72 hours, so no longer embargo could ever be agreed. The protocol default answers "what if nobody said anything", not "whose terms are shortest". See ADR-0096.
Derives from: EP-04-003
EP-04-007 MUST NOT The CASE_MANAGER MUST NOT clamp a proposal or actor default that is shorter than the protocol default up to it. It honors that term at its stated duration.

em/principles.md requires embargo duration be "limited to the shortest duration possible", and a Participant is free to set their own terms. EP-04-005's range bounds what the fallback may be configured to; it does not constrain what parties may agree. A reporter who proposes 12 hours gets 12 hours. See ADR-0096.
EP-04-008 MUST NOT The CASE_MANAGER MUST NOT apply the protocol default to a case that is not embargo-eligible. Such a case has P, X or A set at creation.

VP-06-001 already forbids proposing or accepting an embargo negotiation once the vulnerability is public, exploit code is public, or attacks are observed (EMB-01-002 is the accept half of the same prohibition). An embargo on an already-public vulnerability protects nothing, so the protocol default inherits that guard rather than bypassing it. See ADR-0096.
Refines: VP-06-001
EP-04-020 MUST When any of P, X or A is set at case creation, the CASE_MANAGER MUST leave the case at EM.NONE.

VP-06-001 forbids proposing or accepting an embargo once the vulnerability is public, exploit code is public, or attacks are observed. An embargo on an already-public vulnerability protects nothing, so the case starts with none.
Refines: VP-06-001
EP-04-009 MUST EmbargoEvent.context MUST identify the subject the embargo concerns: the report URI before a case exists, and the case URI afterwards.

A proposal embedded on Offer(VulnerabilityReport) (EP-04-004) precedes the case, so the report is the only subject it can name. This gives pre-case embargo terms a representation without a pre-case embargo phase, which ADR-0096 declines.
EP-04-021 MUST NOT A reader of EmbargoEvent.context MUST NOT assume it names a case without checking.

The field is EmbargoEvent.context in vultron/core/models/embargo_event.py, typed NonEmptyString, and nothing validates it as a case reference. Before a case exists it holds a report URI (EP-04-009), so a reader that assumes a case would take a report URI for one.
Derives from: EP-04-009
EP-04-011 MUST The pending revision that EP-04-016 registers at case creation MUST follow the same relay as any other revision proposal (EP-09).

A revision registered in the CASE_MANAGER's store alone is invisible to the party whose terms won and unreachable by the owner: unindexed, the default selection cannot name it, and with no Invite nobody is asked to answer it. The creation-time revision is a revision like any other; the only thing special about it is who proposes it, and CM-24 already covers the CASE_MANAGER proposing on a participant's behalf.
Extends: EP-04-016
Refines: EP-09-002 — The creation-time revision is relayed by the same rule as any other revision.
EP-04-024 MUST The CASE_MANAGER MUST propose the creation-time revision (EP-04-011) on behalf of the party whose terms lost the shortest-wins comparison, with that party in attributedTo.

The creation-time revision is a revision like any other; the only thing special about it is who proposes it, and CM-24 already covers the CASE_MANAGER proposing on a participant's behalf. The party whose terms lost is the proposer and is not invited (EP-09-002).
Part of: EP-04-011
EP-04-025 MUST The CASE_MANAGER MUST commit the creation-time revision (EP-04-011) as a proposal entry. The committed relayed Invite is that entry, and the CASE_MANAGER commits no separate proposal entry.

No proposal activity exists at creation, so the committed relayed Invite is itself the proposal entry. A second entry would record one proposal twice.
Part of: EP-04-011
EP-04-026 MUST The CASE_MANAGER MUST record the creation-time revision (EP-04-011) in the open-proposal record, so that the owner's default selection (EP-08-002) can reach it.

A revision registered in the CASE_MANAGER's store alone is unreachable by the owner: unindexed, the default selection cannot name it.
Part of: EP-04-011
See also: EP-08-002 — a rationale ("so that ... can reach it")
EP-04-027 MUST The CASE_MANAGER MUST relay the creation-time revision (EP-04-011) as an Invite(EmbargoEvent) to the party whose terms won.

A revision registered in the CASE_MANAGER's store alone is invisible to the party whose terms won, and with no Invite nobody is asked to answer it.
Part of: EP-04-011
Revision Activation Consent Rule
ID Priority Requirement Related
EP-05-001 MUST NOT This rule covers the Case Owner's activation of a revised embargo that ends later than the embargo it replaces (REVISE → ACTIVE). The CASE_MANAGER MUST NOT carry any participant's consent over to it.

A participant who signed for terms T1 has not consented to longer terms T2; treating them as a signatory once T2 is in force would imply consent they never gave. A participant is bound by the revised embargo only through an AGREED consent row for it, so each signatory to the replaced embargo that has not agreed to the revised one has lapsed (CM-18-001), and no write is needed to lapse them. The rule applies at activation rather than at proposal because the participant remains bound by T1 for as long as T1 is the active embargo (ADR-0093, ADR-0122).
Uses definition from: CM-18-001
EP-05-003 MUST This rule covers the Case Owner's activation of a revised embargo that ends no later than the one it replaces. The CASE_MANAGER MUST apply CARRY_OVER to the revised embargo's row of each participant with an AGREED row for the replaced embargo. That includes a participant whose row for the revision is DECLINED (CM-10-001, CM-18-003, MSM-07-005).

Shorter terms ask nothing new: agreeing to N days is agreeing to every shorter period, the same containment that makes shortest-wins (EP-04-003) safe without asking anyone, so their agreement is carried over by writing the row. That holds for a participant that declined the shorter revision too: its decline objected to losing time, not to keeping the embargo, and the decline stays in the ledger (ADR-0122).
Uses definition from: CM-18-001
Uses definition from: CM-18-003
Refines: MSM-07-005
See also: CM-10-001 — context for the reader
EP-05-002 MUST NOT A revision proposal (ACTIVE → REVISE) and any further counter-revision (REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force. The proposer's row for the proposed embargo becomes AGREED (MSM-07-022). Every other participant gets an UNINVITED row for it (CM-18-001). Every other row stays as it is until the Case Owner activates a revision (EP-05-001, EP-05-003). Until then the prior embargo stays in force, and every signatory to it remains one.

A participant cannot lapse until the embargo on the case differs from the one they agreed to. Lapsing on proposal would strand signatories when the revision is rejected, report participants who are still bound and still receive embargoed content as not bound, and lapse the proposer of the revision (ADR-0093). With per-embargo rows a proposal only ever adds rows for the proposed embargo.
Uses definition from: CM-18-001
Refines: MSM-07-022
See also: EP-05-001 — scope boundary: a different transition
See also: EP-05-003 — context for the reader
PEC Idempotency
ID Priority Requirement Related
EP-06-001 MUST NOT An idempotent retry or re-processing of a participant add-or-update MUST NOT remove or downgrade any consent row. That covers each row that has left UNINVITED for INVITED, AGREED, DECLINED or TIMED_OUT.

Dropping an AGREED or DECLINED row on retry silently revokes or erases consent that was already given. The positive-path idempotency rule (don't double-add) is covered by CM-13-005; this rule covers the negative path (don't downgrade).
Uses definition from: CM-18-001
Embargo Invite RSVP Window Policy

Policy requirements for the embargo invite RSVP window: the fallback default when no deadline is on the wire, the minimum permitted window, and the clamp-on-receipt rule that neutralises coercively short deadlines. Codified by ADR-0065. Source: IDEA-2066.

ID Priority Requirement Related
EP-07-001 MUST When an Invite(EmbargoEvent) carries no Invite.end_time, an implementation MUST apply a default RSVP window, measured from the invitation's published timestamp.

An invitation with no deadline would leave the invitee's consent row INVITED for ever. A default window gives every invitation an end, so silence resolves. See ADR-0065.
EP-07-009 SHOULD The default RSVP window of EP-07-001 SHOULD be 7 days, matching CM-18-023.

Aligning the fallback with the CM-18-023 policy window means an invitation that omits end_time gets the same answer window as the policy grants. See ADR-0065.
Extends: EP-07-001
See also: CM-18-023 — context for the reader
EP-07-002 MUST An inviting actor MUST set each Invite(EmbargoEvent)'s Invite.end_time at least the minimum RSVP window after the invitation's published timestamp. The minimum is the lesser of a fixed window and the time remaining in the embargo.

An unbounded-downward deadline weaponises the mechanism: a one-minute RSVP window formally invites a participant while guaranteeing they cannot answer, excluding them with the appearance of due process. See ADR-0065.
EP-07-010 SHOULD The fixed window of the minimum RSVP window (EP-07-002) SHOULD be 72 hours.

Seventy-two hours gives an invitee a realistic chance to answer across time zones and weekends, and it equals the floor of the protocol default embargo (EP-04-018). See ADR-0065.
Extends: EP-07-002
EP-07-003 MUST When a receiving actor receives an Invite(EmbargoEvent) whose Invite.end_time is earlier than the applicable minimum window, it MUST clamp the effective deadline up to that minimum. The applicable minimum is the one computed by EP-07-002, so the clamp never raises the deadline past the embargo's own end.

Clamping makes a coercive deadline ineffective rather than fatal. Rejecting the invitation outright would hand the sender exactly what a hostile sender wants — an invite that never takes effect — and would punish the invitee for the inviter's misbehaviour. See ADR-0065.
Uses definition from: EP-07-002
EP-07-006 MUST NOT An RSVP deadline MUST NOT fall after the end of the embargo it concerns.

An invitee must be able to answer while the embargo still exists. A deadline past the embargo's end asks the invitee to consent to an embargo that is already over, and records its silence as an expiry after the answer stopped mattering. See ADR-0096.
Constrains: CM-18-023
Constrains: EP-07-002
EP-07-011 MUST When a computed RSVP deadline would fall after the embargo's end_time, the actor that computes it MUST clamp it down to that end_time. This holds for a deadline from an explicit Invite.end_time and from the CM-18-023 policy window alike.

Clamping is how a deadline is kept within the embargo (EP-07-006) without refusing the invitation: the invitee can still answer while the embargo exists.
Implements: EP-07-006
Uses definition from: CM-18-023
EP-07-004 MUST NOT A receiving actor MUST NOT reject an Invite(EmbargoEvent) as malformed solely on the basis of a sub-minimum deadline.

Rejecting the invitation would hand a hostile sender exactly what they want — an invite that never takes effect — and punishes the invitee for the inviter's misbehaviour.
Derives from: EP-07-003
Open Proposal Resolution Order

How a Participant resolves two or more simultaneously open embargo proposals: earliest expiration first, with the remainder handled as revisions. Codified by ADR-0100, which also records why there is no multi-candidate poll activity. The heuristic itself predates this group as normative prose in docs/topics/process_models/em/defaults.md; stating it here is what makes it testable. Source: CONCERN-3433.

ID Priority Requirement Related
EP-08-001 SHOULD This rule covers a case with two or more open embargo proposals and none accepted. A Participant SHOULD accept the proposal whose embargo end_time is earliest, and propose the remainder as revisions.

Two parties proposing 30 and 60 days agree on days 1–30 and disagree only beyond that, so accepting the shorter proposal captures all mutual agreement immediately and leaves the contested remainder to negotiate as a revision. This is the Shortest Embargo Proposed Wins heuristic stated in docs/topics/process_models/em/defaults.md, derived in docs/topics/process_models/em/formal_model.md, and applied to case growth in docs/topics/process_models/em/working_with_others.md.
EP-08-005 SHOULD This rule covers two or more revisions open against an active embargo. A Participant SHOULD accept or reject them one at a time, in earliest-to-latest end_time order.

Taking revisions shortest first applies the Shortest Embargo Proposed Wins heuristic (EP-08-001) to revisions: each accepted revision captures the agreement the longer ones also contain.
EP-08-002 MUST This rule covers a selection among two or more open embargo proposals where the caller supplied no proposal identifier. The implementation MUST select the earliest-expiring open proposal, never the first by insertion or arrival order.

A counter-proposal is emitted while the EM state remains PROPOSED (EMB-15-003), so arrival order places the superseded terms first. Selecting by arrival therefore accepts the terms the counter-proposal was sent to replace, which inverts EP-08-001 in exactly the situation that makes a default selection necessary.
Refines: EP-08-001
EP-08-004 MUST When an embargo terminates (EM ACTIVE or REVISE → EXITED), the implementation MUST close every open proposal, cancelling it in the same embargo register step that terminates the embargo (ADR-0122), not only the entry for the terminated embargo itself. Every proposal open while EM is ACTIVE or REVISE is a revision of the active embargo, and a revision of an embargo that no longer exists cannot be accepted.

A case has at most one active embargo (VP-04-002), so while EM is ACTIVE or REVISE every open proposal is by construction a revision of that embargo; no field linking a revision to the embargo it revises is needed to know which proposals a termination decides. EP-08-003's text reaches the terminated embargo; this entry reaches the proposals about it.
Refines: EP-08-003
Embargo Negotiation Relays Through the CASE_MANAGER

How an embargo proposal — the first one for a case or a revision of the active embargo — reaches every participant and every replica in the CASE_MANAGER topology. The behavioural specs (EMB-01 through EMB-06) are written in the voice of the formal protocol, in which every Participant is a peer and every Participant "receives EP" or "receives EV". Here a participant addresses its proposal to the CASE_MANAGER alone (PCR-08-001), so the Participant receiving EP or EV is the CASE_MANAGER on receipt, and every other participant learns the resulting case state from the ledger. The protocol interactions the behavioural specs define still happen: the CASE_MANAGER relays the proposal to the participants as an Invite, they answer the CASE_MANAGER, and the owner's answer decides. Each step is recorded in the ledger. Ledger entries carry case state to replicas and set no parse-and-respond expectation; they augment the negotiation as the record of the case, they do not replace it. Decided by ADR-0113 from Concerns #3892, #3836 and #3863 for revisions; generalised to every proposal, with the acknowledgement, RSVP-deadline, trigger-side write and invitee rules below, by its 2026-09-30 amendment from Concern #3918.

ID Priority Requirement Related
EP-09-001 MUST This rule covers the CASE_MANAGER's receipt of an Invite(EmbargoEvent) for a case whose CS state is not yet public, exploit or attack. The CASE_MANAGER MUST move the canonical case's EM state and commit the proposal as a ledger entry. The move is EM NONE → PROPOSED for the first proposal and ACTIVE → REVISE for a revision.

If the CASE_MANAGER does not move the canonical case on receipt, its record never shows that a revision is under negotiation when a non-owner proposes one, and everything keyed on EM.REVISE runs only in the proposer's store. The CASE_MANAGER is the sole writer of canonical case state (ADR-0108); if it does not move the case, no replica can.
Implements: EMB-01-001
Implements: EMB-03-001
EP-09-020 MUST This rule covers the CASE_MANAGER's receipt of a counter-proposal Invite(EmbargoEvent) for a case already at EM PROPOSED or REVISE. The CASE_MANAGER MUST commit the proposal with no further EM transition.

A counter-proposal adds terms to a negotiation already open, so the EM state that says a negotiation is open already holds. Committing it still puts the proposal on the ledger, where every replica learns of it.
Implements: EMB-01-003
Implements: EMB-03-002
EP-09-021 MUST When the CASE_MANAGER receives an Invite(EmbargoEvent) for a case whose CS state is public, exploit or attack, it MUST refuse the proposal (EMB-01-002, EMB-03-003).

An embargo on a vulnerability that is already public, exploited or attacked protects nothing (VP-06-001), so the CASE_MANAGER does not open a negotiation for one.
Refines: EMB-01-002
See also: EMB-03-003 — scope boundary: EMB-03-003 binds a participant that is not the CASE_MANAGER
EP-09-002 MUST After committing a revision proposal, the CASE_MANAGER MUST emit an Invite(EmbargoEvent) for the revision to each case participant whose RM state is not RM.CLOSED. The proposer and the executing CASE_MANAGER itself get none. Each Invite has actor set to the CASE_MANAGER's ID and attributedTo set to the proposer's ID (CM-24-001, CM-24-002).

Participants answer only an Invite addressed to them (EP-09-003), so without the relay nobody but the proposer would be asked. Proposing terms is consenting to them (ADR-0093), so the proposer is not invited. The CASE_MANAGER is the Case Owner's delegate that routes communications and manages ledger entries, with no view of its own on the embargo, and the CASE_MANAGER never addresses an activity it emits to itself (ADR-0109).
Refines: CM-24-001
Refines: CM-24-002
EP-09-022 MUST The CASE_MANAGER MUST commit each Invite emission of EP-09-002 as a ledger entry once the Invite is in the outbox (SYNC-09-002).

The committed emission is how every replica learns who was asked, and committing only after the outbox write keeps the ledger from recording an Invite that was never sent.
Extends: EP-09-002
Refines: SYNC-09-002
EP-09-023 MUST At the commit of a revision proposal, the CASE_MANAGER MUST write the proposer's consent row for the proposed embargo as AGREED.

Proposing terms is consenting to them (ADR-0093), so the proposer is not invited, and its row records that consent instead.
Extends: EP-09-002
EP-09-024 MUST This rule covers an actor that holds the CASE_MANAGER role but not CASE_OWNER. It also has an embargo stake of its own, through a role beyond CASE_MANAGER and COORDINATOR. At the commit of a revision proposal, the CASE_MANAGER MUST write that actor's own row for the proposed embargo. The row is AGREED when the actor is the proposer. Otherwise the actor's own embargo-proposal policy decides AGREED or DECLINED (EMB-15-001).

The CASE_MANAGER relays the Invite and never addresses an activity it emits to itself (ADR-0109), so a stakeholder that holds the role would never be asked.
Extends: EP-09-002
Uses definition from: EMB-15-001
EP-09-003 MUST NOT A participant that receives an Invite(EmbargoEvent) MUST NOT write case EM state or any participant's consent state on receipt. It stores the Invite and answers it with Accept or Reject addressed to the CASE_MANAGER through its response decision (EMB-15).

Only the CASE_MANAGER turns an announcement into case state and every other participant takes case state from the ledger (ADR-0108, RSH-08-003). Consent is recorded when the CASE_MANAGER commits the answer, and the replica learns it from the ledger.
Refines: RSH-08-003
EP-09-025 MUST NOT A participant MUST NOT treat an Add(CaseLedgerEntry) that carries a proposal or an Invite as an invitation to answer. A participant answers only an Invite addressed to it.

The ledger is a channel for case state, not a protocol interaction. Giving an entry parse-and-respond semantics would let every future entry type become an implicit request, and would fork the negotiation into two paths, one over Invites and one over entries. The interactions the behavioural specs define are the ones that happen; the ledger records them.
EP-09-004 MUST NOT A revision Invite(EmbargoEvent) MUST NOT change the consent of a participant that is already a signatory to the active embargo. The PEC INVITE trigger is applied to the participant's row for the revision (CM-18-003), so a signatory's row for the revision moves from UNINVITED to INVITED and it keeps its AGREED row for the active embargo; its answer to the revision is recorded on the revision's row and binds it to nothing new until the owner activates the revision (EP-05-001, EP-05-002).

A signatory is bound by the active embargo for as long as it is active; a proposal to revise it asks nothing of them yet (ADR-0093). Because consent is per embargo (ADR-0122) the Invite lands on its own row and cannot touch the row that binds the signatory, so a receive tree that applies INVITE for every recipient does not fault on exactly the participants a revision most concerns.
Refines: EP-05-002
Uses definition from: CM-18-003
See also: EP-05-001 — context for the reader
EP-09-005 MAY The Case Owner MAY activate or reject an open revision at any time, without waiting for any other participant to answer the revision Invite. The owner's Add(EmbargoEvent)[target=VulnerabilityCase] activates the revision and the owner's Reject(EmbargoEvent)[target=VulnerabilityCase] keeps the prior terms (MSM-07-008, MSM-07-009); either is committed as a ledger entry and decides the embargo. The owner's Accept or Reject of the revision Invite is only its own consent (MSM-07-003, MSM-07-004).

Only the Case Owner's answer changes the embargo on the case; the other participants' answers inform that decision, they do not make it (ADR-0093). The Invites are not a vote: they gather the consent records the activation cascade reads (EP-05-001). The owner's decision settles the embargo; the answers settle who is bound by it.
Uses definition from: MSM-07-008
Uses definition from: MSM-07-009
See also: MSM-07-003 — context for the reader
See also: MSM-07-004 — context for the reader
EP-09-006 SHOULD The Case Owner SHOULD wait for at least some participants to answer a revision Invite before accepting or rejecting the revision, so as to gauge consensus (VP-08-003). The protocol defines no quorum, no vote and no waiting period; which answers, how many and how long are actor policy.

Consensus on embargo terms is the protocol's stated norm (VP-08-003), and "quorum" is deliberately undefined so that different CVD communities can adopt different decision rules (VP-09-007). A fixed threshold here would take that room away. Leaving it to actor policy makes the waiting decision a natural call-out point rather than a rule.
Refines: VP-08-003
EP-09-008 MUST Shared EM state covers proposing, accepting, rejecting or terminating an embargo. An actor acting on its own initiative MUST write it only when it holds the CASE_MANAGER role for the case. EP-09-017 says what an actor without the role does instead.

An actor that writes its own EM state before the CASE_MANAGER has answered, then declares that state to the manager, is left wrong when the manager refuses: nothing corrects the write, so a proposer's replica can sit at PROPOSED while the canonical case never moves. The manager is the one writer of shared case state (ADR-0108); a participant's replica of it comes from the ledger like everyone else's.
EP-09-017 MUST This rule binds an actor acting on its own initiative without the CASE_MANAGER role. It MUST send its embargo activity to the CASE_MANAGER, write no EM state, and declare no EM state. Its replica moves when the CASE_MANAGER's commit is announced (EP-09-007). The CASE_MANAGER's Reject of a refused proposal answers the activity. So does its Reject of the Invite to an Accept it refuses once P/X/A is set (EMB-02-004). A participant takes a Reject(Invite(EmbargoEvent)) from the CASE_MANAGER and from nobody else (PCR-08-001, HP-01-006).

The CASE_MANAGER is the one writer of shared case state (ADR-0108), so an actor without the role asks it instead of writing. A write made before the CASE_MANAGER answers is left wrong when the CASE_MANAGER refuses, and a declaration of that state spreads the error. The CASE_MANAGER's answer is the only one a participant takes, so a refusal always reaches the actor that asked.
Refines: EP-09-008
Refines: PCR-08-001
See also: EMB-02-004 — context for the reader
See also: EP-09-007 — context for the reader
See also: HP-01-006 — context for the reader
EP-09-009 MUST NOT The CASE_MANAGER's commit of a received embargo activity, fanned out as Add(CaseLedgerEntry), is the acknowledgement the EMB behavioural requirements express as "emit EK". Implementations MUST NOT define or emit an EK message to acknowledge an embargo activity.

No EK exists in the production stack and MSM-02-009 records that its purpose is served by ledger hash-chain continuity. Under the relay every accepted embargo activity is committed and announced, so the record the specs want the receiver to produce already exists; a second acknowledgement would be a message with no reader (#3918).
Refines: MSM-02-009
EP-09-010 MUST The invitee of an Invite(EmbargoEvent) is the actor its target names, which is also its sole to recipient. A receiving actor MUST resolve the invitee from target, not from the receiving actor.

AS2 puts the invitee of an Invite in target (ADR-0205). Every emitter sends a single-recipient Invite, a participant to the CASE_MANAGER and the CASE_MANAGER to one participant per relayed Invite (EP-09-002), so the invitee is also the one actor the Invite is delivered to. Inferring the invitee from the receiving actor puts the RSVP deadline on the enforcer's own record instead of the invitee's.
EP-09-026 MUST A receiving actor MUST refuse an Invite(EmbargoEvent) that names no to recipient or more than one, or whose target names an actor other than its sole recipient, as a misrouting (OX-08-001).

Every emitter sends a single-recipient Invite naming that recipient in target (EP-09-010), so an Invite with no recipient or several, or one delivered to an actor it does not invite, is a defect, not a shape to interpret. Refusing names the defect; guessing hides it. An Invite with no target matches no embargo Invite pattern (VAM-05-005), so it is refused as unrecognized before this check.
Extends: EP-09-010
See also: OX-08-001 — context for the reader
EP-09-011 MUST When the CASE_MANAGER admits a participant (Accept(Invite(VulnerabilityCase preview)[target=Actor])) while an embargo proposal is open, it MUST relay an Invite(EmbargoEvent) for every open proposal to the joiner and commit each as a ledger entry, after the joiner holds the case and the prior ledger. Each Invite has actor set to the CASE_MANAGER's ID and attributedTo set to the proposal's original proposer (EP-09-002). A proposal whose consent row for the joiner has already left UNINVITED is not relayed again. Every participant holds a row for every register entry (CM-18-001). The row's state, not its presence, says whether the joiner was asked. The joiner's row for the active embargo is unchanged (EP-09-004), so a joiner that accepts the revision is a signatory of it at activation and one that does not lapses (ADR-0093, EP-05-001).

A joiner is seated after the relay of a proposal (EP-09-002), so it was never on the roster when the Invite went out, and nothing else would ask it. A new participant becomes a signatory to the embargo in effect when it joins, and is asked about a revision on the table exactly like the participants who were present when it was proposed.
Uses definition from: EP-09-002
Uses definition from: CM-18-001
See also: EP-05-001 — context for the reader
See also: EP-09-004 — context for the reader
EP-09-012 MUST This rule covers a participant whose consent row for the embargo of an Invite(EmbargoEvent) it received is INVITED or TIMED_OUT (CM-18-001). The participant MUST be able to answer that Invite with Accept or Reject after its embargo has become the embargo in force, as before. The answer names the Invite it answers.

Activation takes a proposal out of the record of open proposals (EP-08-003), so a participant relayed the proposal (EP-09-011) that had not answered when it was activated, or whose reply deadline has since passed (EMB-17), can no longer answer it as an open proposal. The receive side already honours the answer (MSM-07-003, EMB-17-002).
Uses definition from: CM-18-001
EP-09-027 MUST NOT A participant MUST NOT answer an Invite(EmbargoEvent) whose consent row is in any state other than INVITED or TIMED_OUT.

A row that is AGREED or DECLINED already holds an answer, and an UNINVITED row was never asked. Withdrawing from the embargo in force from an AGREED row is not an answer and has its own message (EP-09-013).
Extends: EP-09-012
EP-09-013 MUST A participant whose consent row for the embargo in force is AGREED MUST be able to withdraw from that embargo. It sends Leave(EmbargoEvent), naming the embargo in force, to the CASE_MANAGER (MSM-07-010, PCR-08). A withdrawal needs no Invite. An Accept or a Reject is never a withdrawal from the embargo in force.

VP-13-017 lets a participant end its own compliance at any time, and VP-13-008 asks that it say so. A signatory made by seeding (CM-14-005) or by joining (CM-11-001) holds no Invite(EmbargoEvent) for the embargo in force, but every participant holds the embargo itself, so a withdrawal names the embargo, not an Invite.
Uses definition from: MSM-07-010
Refines: VP-13-017
EP-09-028 MUST NOT This rule covers a participant with no embargo in force, one whose row for that embargo is not AGREED, and the Case Owner. Each MUST NOT send Leave(EmbargoEvent) to withdraw.

With no embargo in force there is nothing to withdraw from, and a participant whose row is not AGREED is not bound by the embargo. The Case Owner ends an embargo by terminating it (MSM-07-036), not by withdrawing from it.
Extends: EP-09-013
EP-09-032 MUST An embargo proposal is a duplicate when its end time equals that of a pending proposal in the case's register. With no revision pending, a proposal is also a duplicate when its end time equals that of the embargo in force. Neither the sender nor the activity and embargo ids matter. The CASE_MANAGER MUST change no state, add no ledger entry and relay no Invite because of a duplicate proposal.

Each proposal mints a fresh embargo id, so duplicate detection by id (ID-02-001) never matches a repeat of the same terms. Deciding the repeat at the single authoritative writer, as for a repeated answer (CM-13-005), leaves the proposer's suppression window only saving traffic. Another participant proposing the pending terms holds their relayed Invite (EP-09-004) and agrees by accepting it. During a revision, the in-force end time is a counter-proposal to keep the current terms (EP-09-020).
Refines: ID-04-004
Supersedes: EP-09-001
Supersedes: EP-09-020

Duration

Requirements for a canonical representation of time durations independent of start/end timestamps. Applicable wherever a duration must be exchanged in JSON, such as embargo policy records and embargo initialization at case creation.

Representation Format
ID Priority Requirement Related
DUR-01-001 MUST Durations MUST be represented as ISO 8601 duration strings using the P[n]DT[n]H[n]M[n]S format

Participants exchange durations across independent implementations, so they need a format every stack already parses the same way. ISO 8601 durations have libraries in every common language and carry their units in the string; a private format would need every implementer to agree on its grammar separately.
DUR-01-002 MUST Duration strings MUST be serialized as JSON strings, not as numbers

A JSON number carries no unit, so 30 could mean seconds, hours or days, and two receivers could read different embargo lengths from the same record. A string in the DUR-01-001 format states its units, so the value means one thing to every reader.
DUR-01-003 MUST Durations represent absolute elapsed time, not calendar-relative intervals; P1D means exactly 86400 seconds, with no DST or calendar adjustment implied

An embargo ends at one instant for every participant. If P1D meant a calendar day, a duration that spans a daylight-saving change would end an hour earlier or later depending on the time zone it was computed in, and participants in different zones would disagree on when disclosure is allowed.
Allowed Grammar (Restricted ISO 8601 Subset)
ID Priority Requirement Related
DUR-02-001 MUST Only the following units are permitted in duration strings: days (D), hours (H), minutes (M, time-part only), and seconds (S).

Each of these units has a fixed length in seconds, so every implementation computes the same end time from the same string. The list is closed so that a receiver can reject anything else (DUR-04-001) rather than guess at its length.
DUR-02-002 MUST NOT The following units MUST NOT appear in Vultron duration strings because they introduce calendar ambiguity: years (Y), months (M, date-part), and weeks (W).

A year is 365 or 366 days depending on leap year; a month is 28, 29, 30, or 31 days; a week is 5 business days or 7 calendar days depending on context. These variable lengths make duration arithmetic non-deterministic across implementations. ISO 8601 day-based durations (e.g., P90D) represent an exact number of 86400-second intervals and are unambiguous.
Canonical Form
ID Priority Requirement Related
DUR-03-001 SHOULD Duration strings SHOULD be normalized to a canonical form: prefer the largest unit without remainder, except for a zero-length duration, which is written PT0S (DUR-03-003).

One duration can be written several ways (P1D, PT24H, PT1440M), so two records that hold the same value can fail a plain string comparison or show a spurious change in a diff. One preferred spelling lets readers compare strings and lets a person read the value at a glance.
DUR-03-002 SHOULD An embargo policy duration SHOULD use whole-day units only, where it can.

Embargo terms are negotiated and compared in days, and policy ranges are read by people as well as code. A whole number of days compares against a policy range at a glance.
DUR-03-004 SHOULD NOT An embargo policy duration SHOULD NOT mix day and time units, as in P29DT23H.

A mixed value such as P29DT23H is hard to compare against a policy range at a glance, and it usually signals an arithmetic leftover rather than an intended term.
Extends: DUR-03-002
DUR-03-003 SHOULD NOT P0D SHOULD NOT be used to express a zero-length duration; prefer PT0S for explicitness

A zero duration needs one spelling so that equal values compare equal as strings. PT0S is the form a zero timedelta serializes to (DUR-05), so a zero value written and read back keeps the same spelling.
Refines: DUR-03-001
Validation Requirements
ID Priority Requirement Related
DUR-04-001 MUST Implementations MUST reject duration strings containing disallowed units: Y, date-part M, W

A duration with a year, month or week unit has no fixed length (DUR-02-002), so two receivers that accept it can compute different embargo end dates from the same message. Rejecting it at the edge exposes the disagreement before any participant acts on its own reading.
DUR-04-002 MUST Implementations MUST reject malformed ISO 8601 duration strings

A malformed duration that a receiver accepts with a guessed meaning sets an embargo length that nobody proposed. Rejecting it at parse time keeps the bad value out of the core and tells the sender its message was not understood.
DUR-04-003 MUST Implementations MUST reject empty duration strings ("P" or "PT")

P and PT match the start of the grammar but state no length. A parser that read them as zero would turn a missing value into an embargo that ends the moment it starts.
DUR-04-004 MUST A valid duration MUST contain at least one component

Each ISO 8601 component is optional on its own, so without this rule the grammar admits a duration that states no length at all. A reader would then have to guess one, and the obvious guess, zero, ends an embargo at its start.
Interval Composition
ID Priority Requirement Related
DUR-06-001 MUST A duration-only embargo policy field MUST be interpreted as a relative offset from a context-specific anchor (typically case creation time)

A duration alone has no position in time. Without a named anchor, two participants could apply the same policy to different start points, such as report receipt, case creation or the moment they read it, and hold different embargo end dates.
DUR-06-002 MUST When combined with a start timestamp, the end time is end = start + duration

Plain addition with no calendar adjustment (DUR-01-003) is the one rule every implementation computes identically, so a start time and a duration give every participant the same end instant.
DUR-06-003 MUST A timestamp used in interval composition MUST conform to RFC 3339.

A timestamp without an offset is read in each participant's local zone, so the same start time names different instants on different servers. An RFC 3339 timestamp carries its offset, so every participant reads the same instant.
DUR-06-004 SHOULD An implementation SHOULD compose intervals in UTC, not in a local time zone.

Local time zones shift for daylight saving, so the same start and duration can give different end instants on different servers. UTC has no such shift, so every participant computes the same end instant.
Extends: DUR-06-003
Embargo Duration Semantics
ID Priority Requirement Related
DUR-07-001 MUST Specific embargo end times on cases MUST be declared as event intervals with unambiguous start and end timestamps, not as durations alone

An embargo on a case is a commitment to a disclosure date that every participant must agree on. A duration alone depends on an anchor each participant might read differently and on when it is read, while explicit start and end timestamps name the same instants for everyone.
DUR-07-002 SHOULD At case creation (RM.RECEIVED), if no embargo end time is established, the case creation process SHOULD apply the actor's default embargo duration (from the actor profile) to the case creation timestamp to establish the initial embargo end time

A case with no embargo end has no agreed disclosure date, and the EM process exists to lock in an embargo as early as possible. The receiving actor's published default is the terms it has already declared it will accept, so applying it at creation gives the case an embargo without a negotiation round.
Implements: DUR-07-004
DUR-07-003 MUST When a default embargo duration is applied at case creation, the case's resulting EM state MUST be EM.ACTIVE, not EM.PROPOSED (EP-04-001).

The default applies only when the sender submitted no terms of its own, which is tacit acceptance of the default (EP-04-001), so nobody is left to accept it. A case left at EM.PROPOSED would wait for an answer that nobody owes, with no embargo in force while it waits.
DUR-07-004 MUST An embargo end time MUST be established before an embargo-eligible case (none of P, X or A set) transitions to RM.VALID.

Once a report is valid, coordination begins and other parties are brought into the case. An embargo end set before that point means every participant joins under a known disclosure date instead of sharing vul details with no agreed date in force. A case with P, X or A set is exempt and is validated with no embargo, at EM.NONE when P, X or A was set at creation. It can never receive a new embargo (EP-04-008, VP-06-001), so requiring one would block RM.VALID.

CVD Case State Behavioral Requirements

Event-Condition-Action behavioral requirements for CVD Case State (CS) transitions. Each group is triggered by either a received CS message or a local CS state transition, and specifies typed preconditions, ordered steps, and postconditions that implementations must satisfy. CS cascade chains that trigger embargo teardown reference EM behavior directly and are developed in concert with the EM behavioral requirements.

Receive CV (Vendor Aware)

Behaviors triggered when a participant receives a CV (Vendor Aware) message, updating the sender's CS state model to reflect vendor awareness of the vulnerability.

Trigger: Message Received — CV

ID Priority Requirement Related
CSB-01-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) receiving CV MUST update their model of the sending Participant's CS state to Vendor Aware (q^cs ∈ Vfd···). No CK message is emitted (MSM-03-008). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), records it. Each replica acknowledges that entry by its unbroken hash chain (MSM-05-002).

CV announces a Vendor-specific CS transition. The receiver does not change their own CS state; they update their awareness model for the sender.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update model of sender's CS state to Vendor Aware (Vfd···) — receiver's own CS state is unchanged → Receiver's awareness model for sender reflects CS=Vfd
2. [receiver] CASE_MANAGER commits the received CV and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Sender's CS state recorded as Vfd; CK discharged by the ledger commit; receiver CS unchanged

Uses definition from: MSM-03-001 — CV shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
Receive CF (Fix Ready)

Behaviors triggered when a participant receives a CF (Fix Ready) message, updating the sender's CS state model to reflect that a fix is ready.

Trigger: Message Received — CF

ID Priority Requirement Related
CSB-02-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) receiving CF MUST update their model of the sending Participant's CS state to Fix Ready (q^cs ∈ VFd···). No CK message is emitted (MSM-03-008). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), records it. Each replica acknowledges that entry by its unbroken hash chain (MSM-05-002).

CF announces a Vendor-specific CS transition. The receiver does not change their own CS state; they update their awareness model for the sender.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update model of sender's CS state to Fix Ready (VFd···) — receiver's own CS state is unchanged → Receiver's awareness model for sender reflects CS=VFd
2. [receiver] CASE_MANAGER commits the received CF and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Sender's CS state recorded as VFd; CK discharged by the ledger commit; receiver CS unchanged

Uses definition from: MSM-03-002 — CF shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
Receive CD (Fix Deployed)

Behaviors triggered when a participant receives a CD (Fix Deployed) message, updating the sender's CS state model to reflect that a fix has been deployed.

Trigger: Message Received — CD

ID Priority Requirement Related
CSB-03-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) receiving CD MUST update their model of the sending Participant's CS state to Fix Deployed (q^cs ∈ VFD···). No CK message is emitted (MSM-03-008). The CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry), records it. Each replica acknowledges that entry by its unbroken hash chain (MSM-05-002).

CD announces a Vendor-specific CS transition. The receiver does not change their own CS state; they update their awareness model for the sender.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Update model of sender's CS state to Fix Deployed (VFD···) — receiver's own CS state is unchanged → Receiver's awareness model for sender reflects CS=VFD
2. [receiver] CASE_MANAGER commits the received CD and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Sender's CS state recorded as VFD; CK discharged by the ledger commit; receiver CS unchanged

Uses definition from: MSM-03-003 — CD shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
Receive CP (Public Aware)

Behaviors triggered when a participant receives a CP (Public Aware) message, recording public disclosure of the vulnerability and initiating embargo teardown if an active embargo exists.

Trigger: Message Received — CP

ID Priority Requirement Related
CSB-04-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM None or Exited (q^em ∈ {N, X}) receiving CP MUST transition their local CS to Public Aware (q^cs ···p·· → ···P··). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

CP is a global (participant-agnostic) CS transition. All receivers must update their own CS state. When EM is None or Exited, no embargo teardown is needed.

ECA Details

Preconditions

- EM state is None or Exited; CS matches pattern ...p..
- EM state: NONE, EXITED
- CS pattern: ...p..

Steps

1. [receiver] Transition local CS to Public Aware (···P··) → Receiver CS public bit set to P
2. [receiver] CASE_MANAGER commits the received CP and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is public-aware; CK discharged by the ledger commit

Uses definition from: MSM-03-004 — CP shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-04-002 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM Proposed (q^em ∈ P) receiving CP MUST transition their local CS to Public Aware.

Public awareness terminates a pending embargo proposal per VP-09-001. The embargo cannot be negotiated once the information is public (VP-06-001).

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...p..
- EM state: PROPOSED
- CS pattern: ...p..

Steps

1. [receiver] Transition local CS to Public Aware (···P··) → Receiver CS public bit set to P
2. [receiver] Transition EM from PROPOSED to NONE (embargo proposal abandoned) → Receiver EM state is NONE
3. [receiver] CASE_MANAGER commits the received CP and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is public-aware; EM is NONE; CK discharged by the ledger commit

Uses definition from: MSM-03-004 — CP shorthand wire-type mapping
CSB-04-003 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM Active or Revise (q^em ∈ {A, R}) receiving CP MUST transition their local CS to Public Aware.

VP-09-001 requires immediate embargo termination when public awareness occurs. The CS transition is recorded before embargo teardown begins (CSB-12-004).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...p..
- EM state: ACTIVE, REVISE
- CS pattern: ...p..

Steps

1. [receiver] Transition local CS to Public Aware (···P··) → Receiver CS public bit set to P
2. [CASE_MANAGER] Emit ET to initiate embargo termination (CSB-04-007); a receiver that does not hold the CASE_MANAGER role emits no ET → ET queued for participants; EM begins transitioning to EXITED
3. [receiver] CASE_MANAGER commits the received CP and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is public-aware; the CASE_MANAGER has emitted ET; EM is EXITED; CK discharged by the ledger commit

Uses definition from: MSM-03-004 — CP shorthand wire-type mapping
CSB-04-004 MUST A Participant in a non-Closed RM state (q^rm ∉ C) already in CS Public Aware (q^cs ∈ ···P··) receiving a duplicate CP MUST make no CS or EM state transition. "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

Duplicate CP does not re-trigger CS or EM transitions.

ECA Details

Preconditions

- CS matches pattern ...P..
- CS pattern: ...P..

Steps

1. [receiver] Make no state change for the duplicate CP → CS and EM states unchanged; no CK message exists

Postconditions

- No state change; no CK message emitted

Uses definition from: MSM-03-004 — CP shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-04-005 MUST The CASE_MANAGER in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM Proposed (q^em ∈ P) receiving CP MUST transition EM to None (q^em P → N) by abandoning each open proposal (EMB-16-001).

Public awareness makes further embargo negotiation moot; the pending proposal is abandoned per VP-09-001. The abandonment is shared EM state, so the CASE_MANAGER, which can be the Case Owner itself, makes it when it records the P/X/A status (RSH-03-001, EMB-16-001). A Participant that does not hold the role writes no EM state; its replica follows the replayed entries (EMB-16-002, EP-09-008).
Refines: EMB-16-001
CSB-04-007 MUST This rule covers a CASE_MANAGER whose RM state is not Closed (q^rm ∉ C) and whose EM is Active or Revise (q^em ∈ {A, R}). Its CS is not yet public (q^cs ∈ ···p··). On receiving CP, it MUST initiate embargo termination by emitting ET in the act that adopts the P value.

VP-09-001 requires immediate embargo termination when public awareness occurs. Only the CASE_MANAGER writes shared EM state, so it emits the ET when it records the P/X/A status (RSH-03-001, EP-09-008); it can be the Case Owner itself. A non-manager Participant reports the CS change and emits no ET (EMB-03-003, ADR-0118). Adopting P also authorizes the termination, so no second approval is asked (ADR-0210).
Refines: CSB-12-001 — The adoption of a received CP
Receive CX (Exploit Public)

Behaviors triggered when a participant receives a CX (Exploit Public) message, recording public availability of an exploit and initiating embargo teardown if an active embargo exists.

Trigger: Message Received — CX

ID Priority Requirement Related
CSB-05-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM None or Exited (q^em ∈ {N, X}) receiving CX MUST transition their local CS to both Public Aware and Exploit Public (q^cs ···px· → ···PX·). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

CX in state ···px· implies the pX→PX invariant (constraint C-15): exploit public without prior public awareness is an ephemeral state that immediately resolves to both P and X. The CS transition is atomic.

ECA Details

Preconditions

- EM state is None or Exited; CS matches pattern ...px.
- EM state: NONE, EXITED
- CS pattern: ...px.

Steps

1. [receiver] Transition local CS to Public Aware and Exploit Public (···PX·) → Receiver CS public bit P and exploit bit X both set
2. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···PX·; CK discharged by the ledger commit

Uses definition from: MSM-03-005 — CX shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-05-002 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Proposed (q^em ∈ P) receiving CX MUST transition their local CS to ···PX·.

Exploit publication terminates a pending embargo proposal per VP-09-001. The pX→PX invariant applies (constraint C-15).

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...px.
- EM state: PROPOSED
- CS pattern: ...px.

Steps

1. [receiver] Transition local CS to Public Aware and Exploit Public (···PX·) → Receiver CS public bit P and exploit bit X both set
2. [receiver] Transition EM from PROPOSED to NONE (embargo proposal abandoned) → Receiver EM state is NONE
3. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···PX·; EM is NONE; CK discharged by the ledger commit

Uses definition from: MSM-03-005 — CX shorthand wire-type mapping
CSB-05-003 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Active or Revise (q^em ∈ {A, R}) receiving CX MUST transition their local CS to ···PX·.

VP-09-001 requires immediate embargo termination when exploit publication occurs. The pX→PX invariant applies. The CS transition is recorded before teardown begins (CSB-05-010).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...px.
- EM state: ACTIVE, REVISE
- CS pattern: ...px.

Steps

1. [receiver] Transition local CS to Public Aware and Exploit Public (···PX·) → Receiver CS public bit P and exploit bit X both set
2. [CASE_MANAGER] Emit ET to initiate embargo termination (CSB-05-008); a receiver that does not hold the CASE_MANAGER role emits no ET → ET queued for participants; EM begins transitioning to EXITED
3. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···PX·; the CASE_MANAGER has emitted ET; EM is EXITED; CK discharged by the ledger commit

Uses definition from: MSM-03-005 — CX shorthand wire-type mapping
CSB-05-004 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS already public but not yet exploit-public (q^cs ∈ ···Px·) receiving CX MUST transition their local CS exploit bit to X (q^cs ···Px· → ···PX·). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

When public awareness already exists, CX transitions only the exploit bit. No new embargo teardown is triggered since the embargo should already have been terminated when P was reached.

ECA Details

Preconditions

- CS matches pattern ...Px.
- CS pattern: ...Px.

Steps

1. [receiver] Transition local CS exploit bit to X (···PX·) → Receiver CS exploit bit X set; public bit P remains set
2. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···PX·; CK discharged by the ledger commit

Uses definition from: MSM-03-005 — CX shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-05-005 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS already exploit-public (q^cs ∈ ···PX·) receiving a duplicate CX MUST make no CS or EM state transition. "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

Duplicate CX does not re-trigger CS or EM transitions.

ECA Details

Preconditions

- CS matches pattern ...PX.
- CS pattern: ...PX.

Steps

1. [receiver] Make no state change for the duplicate CX → CS and EM states unchanged; no CK message exists

Postconditions

- No state change; no CK message emitted

Uses definition from: MSM-03-005 — CX shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-05-006 MUST The CASE_MANAGER in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Proposed (q^em ∈ P) receiving CX MUST transition EM to None (q^em P → N) by abandoning each open proposal (EMB-16-001).

Exploit publication makes further embargo negotiation moot; the pending proposal is abandoned per VP-09-001. The abandonment is shared EM state, so the CASE_MANAGER, which can be the Case Owner itself, makes it when it records the P/X/A status (RSH-03-001, EMB-16-001). A Participant that does not hold the role writes no EM state; its replica follows the replayed entries (EMB-16-002, EP-09-008).
Refines: EMB-16-001
CSB-05-008 MUST This rule covers a CASE_MANAGER whose RM state is not Closed (q^rm ∉ C) and whose EM is Active or Revise (q^em ∈ {A, R}). Its CS is not yet public and not yet exploit-public (q^cs ∈ ···px·). On receiving CX, it MUST initiate embargo termination by emitting ET in the act that adopts the X value.

VP-09-001 requires immediate embargo termination when exploit publication occurs. Only the CASE_MANAGER writes shared EM state, so it emits the ET when it records the P/X/A status (RSH-03-001, EP-09-008); it can be the Case Owner itself. A non-manager Participant reports the CS change and emits no ET (EMB-03-003, ADR-0118). Adopting X also authorizes the termination, so no second approval is asked (ADR-0210).
Refines: CSB-13-002 — The adoption of a received CX
CSB-05-010 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Active or Revise (q^em ∈ {A, R}) receiving CX MUST record the CS transition to ···PX· before embargo teardown is initiated.

The ledger commits the CS state change before any effect acts on it (CLP-10-006), so every replica sees the cause before its effect.
Receive CA (Attacks Observed)

Behaviors triggered when a participant receives a CA (Attacks Observed) message, recording active exploitation of the vulnerability and initiating embargo teardown if an active embargo exists.

Trigger: Message Received — CA

ID Priority Requirement Related
CSB-06-001 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM None or Exited (q^em ∈ {N, X}) receiving CA MUST transition their local CS attacks bit to A (q^cs ···p·a → ···p·A). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

An observed attack is evidence of exploitation, not public information about the vulnerability: an attack can be seen on one network while nothing about the vulnerability has been published. A CS transition changes one dimension (CSB-17-002), and ···p·A is a state a case can rest in (CSB-17-003), so the public bit waits for its own P event. When EM is None or Exited, no embargo teardown is needed.

ECA Details

Preconditions

- EM state is None or Exited; CS matches pattern ...p.a
- EM state: NONE, EXITED
- CS pattern: ...p.a

Steps

1. [receiver] Transition local CS attacks bit to A (···p·A) → Receiver CS attacks bit A set; public bit p remains unset
2. [receiver] CASE_MANAGER commits the received CA and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···p·A; CK discharged by the ledger commit

Uses definition from: MSM-03-006 — CA shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-06-002 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM Proposed (q^em ∈ P) receiving CA MUST transition their local CS attacks bit to A (q^cs ···p·a → ···p·A).

Observed attacks abandon a pending embargo proposal (EMB-16-001) without making the vulnerability public, so only the attacks bit changes (CSB-17-002).

ECA Details

Preconditions

- EM state is Proposed; CS matches pattern ...p.a
- EM state: PROPOSED
- CS pattern: ...p.a

Steps

1. [receiver] Transition local CS attacks bit to A (···p·A) → Receiver CS attacks bit A set; public bit p remains unset
2. [receiver] Transition EM from PROPOSED to NONE (embargo proposal abandoned) → Receiver EM state is NONE
3. [receiver] CASE_MANAGER commits the received CA and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···p·A; EM is NONE; CK discharged by the ledger commit

Uses definition from: MSM-03-006 — CA shorthand wire-type mapping
CSB-06-003 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM Active or Revise (q^em ∈ {A, R}) receiving CA MUST transition their local CS attacks bit to A (q^cs ···p·a → ···p·A).

Observed attacks warrant embargo termination (VP-09-003, CSB-18-004) without making the vulnerability public, so only the attacks bit changes (CSB-17-002). The CS transition is recorded before teardown begins (CSB-06-010).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...p.a
- EM state: ACTIVE, REVISE
- CS pattern: ...p.a

Steps

1. [receiver] Transition local CS attacks bit to A (···p·A) → Receiver CS attacks bit A set; public bit p remains unset
2. [CASE_MANAGER] Emit ET to initiate embargo termination (CSB-06-008); a receiver that does not hold the CASE_MANAGER role emits no ET → ET queued for participants; EM begins transitioning to EXITED
3. [receiver] CASE_MANAGER commits the received CA and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···p·A; the CASE_MANAGER has emitted ET; EM is EXITED; CK discharged by the ledger commit

Uses definition from: MSM-03-006 — CA shorthand wire-type mapping
CSB-06-004 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS already public but attacks not yet observed (q^cs ∈ ···P·a) receiving CA MUST transition their local CS attacks bit to A (q^cs ···P·a → ···P·A). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

When public awareness already exists, CA transitions only the attacks bit. The public bit is already set; no new P transition is needed.

ECA Details

Preconditions

- CS matches pattern ...P.a
- CS pattern: ...P.a

Steps

1. [receiver] Transition local CS attacks bit to A (···P·A) → Receiver CS attacks bit A set; public bit P remains set
2. [receiver] CASE_MANAGER commits the received CA and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists

Postconditions

- Receiver CS is ···P·A; CK discharged by the ledger commit

Uses definition from: MSM-03-006 — CA shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-06-005 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS attacks already observed (q^cs ∈ ·····A) receiving a duplicate CA MUST make no CS or EM state transition. "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Add(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).

Duplicate CA does not re-trigger CS or EM transitions, whether or not the case is public: ···p·A is a resting state (CSB-17-003).

ECA Details

Preconditions

- CS matches pattern .....A
- CS pattern: .....A

Steps

1. [receiver] Make no state change for the duplicate CA → CS and EM states unchanged; no CK message exists

Postconditions

- No state change; no CK message emitted

Uses definition from: MSM-03-006 — CA shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
CSB-06-006 MUST The CASE_MANAGER in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM Proposed (q^em ∈ P) receiving CA MUST transition EM to None (q^em P → N) by abandoning each open proposal (EMB-16-001).

Observed attacks make further embargo negotiation moot; the pending proposal is abandoned per VP-06-001 and EMB-16-001. The abandonment is shared EM state, so the CASE_MANAGER, which can be the Case Owner itself, makes it when it records the P/X/A status (RSH-03-001, EMB-16-001). A Participant that does not hold the role writes no EM state; its replica follows the replayed entries (EMB-16-002, EP-09-008).
Refines: EMB-16-001
CSB-06-008 MUST This rule covers a CASE_MANAGER whose RM state is not Closed (q^rm ∉ C) and whose EM is Active or Revise (q^em ∈ {A, R}). Its CS is not yet public and has no attacks observed (q^cs ∈ ···p·a). On receiving CA, it MUST initiate embargo termination by emitting ET in the act that adopts the A value.

Observed attacks warrant embargo termination (VP-09-003), and an active embargo cannot coexist with the attacks bit (CSB-18-004). Only the CASE_MANAGER writes shared EM state, so it emits the ET when it records the P/X/A status (RSH-03-001, EP-09-008); it can be the Case Owner itself. A non-manager Participant reports the CS change and emits no ET (EMB-03-003, ADR-0118). Adopting A also authorizes the termination, so no second approval is asked (ADR-0210).
Refines: CSB-14-001 — The adoption of a received CA
CSB-06-010 MUST A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM Active or Revise (q^em ∈ {A, R}) receiving CA MUST record the CS transition to ···p·A before embargo teardown is initiated.

The ledger commits the CS state change before any effect acts on it (CLP-10-006), so every replica sees the cause before its effect.
Receive CE (CS Error)

Behaviors triggered when a participant receives a CE (CVD Case State Error) signal, which has no dedicated semantic dispatch value and is handled outside the standard AS2 pattern-matching pipeline.

Trigger: Message Received — CE

ID Priority Requirement Related
CSB-07-001 SHOULD A Participant in a non-Closed RM state (q^rm ∉ C) that receives Create(ProcessingFault) about a CS activity it sent SHOULD inquire about the nature of the error (GI) when the fault does not say what went wrong. CE has no wire activity of its own (MSM-03-007, MSM-05-001). The receiver emits no CK for the fault (MSM-03-008).

A fault about a CS activity says the sender could not process it, but not always why. Following up with GI allows the sender to explain the error and enables recovery. A fault does not trigger a CS state transition, and faults are grouped by failure mode, not by state machine, so no CE or CK message exists.

ECA Details

Preconditions

- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted)
- RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED

Steps

1. [receiver] Emit GI to inquire about the nature of the error, when the fault does not say what went wrong → GI queued for sender; no CK message exists

Postconditions

- GI emitted; CS state unchanged

Uses definition from: MSM-03-007 — CE shorthand wire-type mapping
Uses definition from: MSM-03-008
See also: MSM-05-001 — context for the reader
Receive CK (CS Acknowledgment)

Behaviors triggered when a participant receives the acknowledgment (CK) of a CS activity it sent. No CK message exists (MSM-03-008): the acknowledgment is the CASE_MANAGER's commit of the activity, fanned out as Add(CaseLedgerEntry).

Trigger: Message Received — CK

ID Priority Requirement Related
CSB-08-001 MAY A Participant that receives the CASE_MANAGER's Add(CaseLedgerEntry) for a CS activity it sent MAY treat that entry as the acknowledgment (CK) of the activity, with no further state transition and no required response. No CK message exists (MSM-03-008, MSM-05-002).

The ledger entry confirms that the CASE_MANAGER received and recorded the earlier C message. As an acknowledgment it asks nothing more of the receiver. The replica acknowledges the entry itself through its unbroken hash chain (MSM-05-002).*
Uses definition from: MSM-03-008 — CK shorthand wire-type mapping
See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008
Enter CS Vendor Aware (V)

Trigger: State Entered — CS.V

ID Priority Requirement Related
CSB-09-001 SHOULD A Vendor Participant entering CS Vendor Aware (q^cs ∈ Vfdpxa) with EM None (q^em ∈ N) SHOULD begin embargo negotiations promptly.

VP-14-005 recommends starting the EM process as soon as possible once a Vendor is aware. Constraint C-32: EM SHOULD begin promptly on Vfdpxa entry when no embargo exists.

ECA Details

Preconditions

- EM state is None; Participant holds the Vendor role; CS matches pattern Vfd...
- EM state: NONE
- Role: vendor
- CS pattern: Vfd...

Refines: VP-14-005 — Once a case has reached Vendor Aware, if the EM process has not started, it SHOULD begin as soon as possible
CSB-09-002 SHOULD A Participant entering CS Vendor Aware SHOULD emit CV to announce the transition to other case Participants.

State-change notifications support shared situation awareness. CV informs other Participants that a Vendor is now aware, enabling them to coordinate embargo and fix timing accordingly.

ECA Details

Preconditions

- CS matches pattern Vfd...
- CS pattern: Vfd...

Steps

1. [participant] Emit CV to announce Vendor Aware CS transition → CV queued for case participants

Postconditions

- CV emitted; other Participants informed of V transition

Refines: VP-03-012
Enter CS Fix Ready (F)

Trigger: State Entered — CS.F

ID Priority Requirement Related
CSB-10-001 SHOULD NOT A Participant entering CS Fix Ready (q^cs ∈ VFd···) SHOULD NOT start new embargo negotiations. If an embargo proposal is pending (q^em ∈ P), the Participant SHOULD reject it. The one exception is the brief publication or deployment embargo of VP-06-008.

VP-14-007 discourages starting or completing new embargo negotiations once a fix is ready, and VP-06-008 names its one exception. Constraint C-34: fix readiness is late in the process for beginning embargo negotiations.

ECA Details

Preconditions

- CS matches pattern VFd...
- CS pattern: VFd...

Refines: VP-14-007 — Once a case has reached Fix Ready, new embargo negotiations SHOULD NOT start and pending embargoes SHOULD be rejected, except for the VP-06-008 publication or deployment embargo
See also: VP-06-008 — context for the reader
CSB-10-002 SHOULD A Participant entering CS Fix Ready SHOULD emit CF to announce the transition to other case Participants.

State-change notifications support shared situation awareness. CF informs other Participants that a fix is available, enabling them to coordinate embargo extension or termination decisions.

ECA Details

Preconditions

- CS matches pattern VFd...
- CS pattern: VFd...

Steps

1. [participant] Emit CF to announce Fix Ready CS transition → CF queued for case participants

Postconditions

- CF emitted; other Participants informed of F transition

Enter CS Fix Deployed (D)

Trigger: State Entered — CS.D

ID Priority Requirement Related
CSB-11-001 SHOULD When a Participant enters CS Fix Deployed (q^cs ∈ VFD···) with an active embargo (q^em ∈ {A, R}), the Case Owner, or the CASE_MANAGER it delegates to, SHOULD terminate the embargo by emitting ET.

VP-14-015 recommends terminating any existing embargo once the fix has been deployed. Constraint C-35: embargo termination SHOULD follow fix deployment. Ending an embargo is the Case Owner's decision, or the delegated CASE_MANAGER's, so the Participant that deploys the fix reports its CS change and does not emit ET itself (EMB-03-003, ADR-0118, EP-09-008). The Case Owner can hold the CASE_MANAGER role itself.

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern VFD...
- EM state: ACTIVE, REVISE
- CS pattern: VFD...

Steps

1. [Case Owner or CASE_MANAGER] Emit ET to terminate the active embargo → ET queued for participants; EM begins transitioning to EXITED

Postconditions

- ET emitted; EM is EXITED

Refines: VP-14-015 — By the time a fix has been deployed, any existing embargo SHOULD terminate
CSB-11-002 SHOULD A Participant entering CS Fix Deployed SHOULD emit CD to announce the transition to other case Participants.

State-change notifications support shared situation awareness. CD informs other Participants that the fix is deployed, allowing them to coordinate publication and embargo termination decisions.

ECA Details

Preconditions

- CS matches pattern VFD...
- CS pattern: VFD...

Steps

1. [participant] Emit CD to announce Fix Deployed CS transition → CD queued for case participants

Postconditions

- CD emitted; other Participants informed of D transition

Enter CS Public Aware (P)

Trigger: State Entered — CS.P

ID Priority Requirement Related
CSB-12-001 MUST This rule covers the CASE_MANAGER when it adopts a P value (q^cs → ···P··) while an embargo is active (q^em ∈ {A, R}). Acting for the Case Owner, it MUST end the embargo immediately, by emitting ET in the act that adopts the value.

VP-09-001 requires immediate embargo termination upon public disclosure. Ending an embargo is the Case Owner's decision, and only the CASE_MANAGER writes shared EM state; it can be the Case Owner itself (EMB-03-003, ADR-0118). Adopting P also authorizes the termination (ADR-0210). A non-manager Participant reports P instead (CSB-12-005), and CSB-04-007 covers a received CP. CSB-12-004 orders the CS transition before the teardown.

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...P..
- EM state: ACTIVE, REVISE
- CS pattern: ...P..

Steps

1. [CASE_MANAGER] Adopt the P value into the canonical case status → Case CS public bit set to P
2. [CASE_MANAGER] Emit ET to terminate the embargo, in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- CS public bit is P; the CASE_MANAGER has emitted ET; EM is EXITED

Refines: VP-09-001 — Embargoes SHALL terminate immediately when information becomes public
CSB-12-005 MUST This rule covers a Participant that is not the CASE_MANAGER and enters CS Public Aware (q^cs → ···P··) while an embargo is active (q^em ∈ {A, R}). It MUST report the P value to the CASE_MANAGER instead of emitting ET.

VP-11-003 has a Participant that learns the vulnerability is public initiate embargo termination. Ending the embargo is the Case Owner's decision, carried out by the CASE_MANAGER (EMB-03-003, ADR-0118, VP-11-012), so the Participant's part is the report. The CASE_MANAGER then ends the embargo in the act that adopts the P value (CSB-12-001, ADR-0210). Participants message only the CASE_MANAGER (PCR-08-001).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...P..
- EM state: ACTIVE, REVISE
- CS pattern: ...P..

Steps

1. [participant] Report the P value to the CASE_MANAGER → Status report queued for the CASE_MANAGER only; no ET queued

Postconditions

- The CASE_MANAGER has the P report; the Participant has emitted no ET

Refines: VP-11-003 — Participants SHALL initiate embargo termination on learning that information about the vulnerability is public
CSB-12-004 MUST This rule covers the CASE_MANAGER when it adopts a P value (q^cs → ···P··) while an embargo is active (q^em ∈ {A, R}). It MUST record the adopted P value before it ends the embargo under CSB-12-001.

Every replica replays the ledger in order, so a teardown committed ahead of its cause would show the embargo ending for no recorded reason. CSB-04-003 is the received transition this rule orders; the ledger mechanism is CLP-10-006.
Extends: CSB-12-001
CSB-12-002 MUST NOT A Participant entering CS Public Aware MUST NOT seek new embargoes or accept new embargo proposals for this case.

VP-06-001 prohibits seeking new embargoes once public awareness has occurred. This applies to all future EP messages for this case.

ECA Details

Preconditions

- CS matches pattern ...P..
- CS pattern: ...P..

Refines: VP-06-001 — Once Public Awareness, new embargoes SHALL NOT be sought
CSB-12-003 SHOULD A Participant entering CS Public Aware SHOULD emit CP to announce the transition to other case Participants if CP was not already the triggering event (i.e., the transition was triggered locally or by a different message type).

State-change notifications support shared situation awareness. CP informs other Participants that the vulnerability is now public. This item applies when the P transition is triggered by a local event (e.g., own publication) rather than by receiving CP from another Participant.

ECA Details

Preconditions

- CS matches pattern ...P..
- CS pattern: ...P..

Steps

1. [participant] Emit CP to announce Public Aware CS transition → CP queued for case participants

Postconditions

- CP emitted; other Participants informed of P transition

Enter CS Exploit Public (X)

Trigger: State Entered — CS.X

ID Priority Requirement Related
CSB-13-001 MUST A Participant whose CS sets the exploit bit while the public bit is unset (···px·) MUST also trigger CS→P (the pX→PX invariant). It triggers CS→P before or with the exploit transition.

The ephemeral state ···pX· (exploit public without public awareness) cannot exist as a stable state. Constraint C-15 requires the transition to be ···px· → ···PX·, not ···px· → ···pX· → ···PX·. Observable consequence: CX emitted from ···px· state must be accompanied by CP. The precondition uses the post-transition pattern ···pX· (X uppercase, P lowercase) since state_entered fires after the X bit is set.

ECA Details

Preconditions

- CS matches pattern ...pX.
- CS pattern: ...pX.

Steps

1. [participant] Emit CX to announce exploit public transition → CX queued for case participants
2. [participant] Emit CP to announce public aware transition (C-15 constraint) → CP queued for case participants

Postconditions

- CS is ···PX·; CX and CP both emitted; pX→PX invariant satisfied

CSB-13-006 MUST A Participant MUST treat the compound transition of CSB-13-001 as atomic, so that it sets the P and X bits together.

If the P and X bits were set in two steps, the participant would pass through the ephemeral state ···pX·, which cannot exist as a stable state (C-15). The write is the exception CSB-17-002 names, and it loses no ordering: ···pX· has one forced successor (CSB-17-012), so a replay recovers X, then P.

ECA Details

Preconditions

- CS matches pattern ...pX.
- CS pattern: ...pX.

Steps

1. [participant] Transition CS to ···PX· (set both public bit P and exploit bit X atomically) → Receiver CS public bit P and exploit bit X both set

Postconditions

- CS is ···PX·, with no stored ···pX· state

Refines: CSB-13-001
Supersedes: CSB-17-002
Supersedes: CSB-17-008
CSB-13-002 MUST This rule covers the CASE_MANAGER when it adopts an X value (q^cs → ···PX·) while an embargo is active (q^em ∈ {A, R}). Acting for the Case Owner, it MUST end the embargo immediately, by emitting ET in the act that adopts the value.

VP-09-001 requires immediate embargo termination upon exploit publication. Ending an embargo is the Case Owner's decision, and only the CASE_MANAGER writes shared EM state; it can be the Case Owner itself (EMB-03-003, ADR-0118). Adopting X also authorizes the termination (ADR-0210). A non-manager Participant reports X instead (CSB-13-005), and CSB-05-008 covers a received CX. CSB-13-004 orders the CS transition before the teardown.

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...PX.
- EM state: ACTIVE, REVISE
- CS pattern: ...PX.

Steps

1. [CASE_MANAGER] Adopt the X value into the canonical case status → Case CS exploit bit set to X
2. [CASE_MANAGER] Emit ET to terminate the embargo, in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- CS exploit bit is X; the CASE_MANAGER has emitted ET; EM is EXITED

Refines: VP-09-001 — Embargoes SHALL terminate immediately when exploit becomes public
CSB-13-005 MUST This rule covers a Participant that is not the CASE_MANAGER and enters CS Exploit Public (q^cs → ···PX·) while an embargo is active (q^em ∈ {A, R}). It MUST report the X value to the CASE_MANAGER instead of emitting ET.

VP-11-003 has a Participant that learns of public exploit code initiate embargo termination. Ending the embargo is the Case Owner's decision, carried out by the CASE_MANAGER (EMB-03-003, ADR-0118, VP-11-012), so the Participant's part is the report. The CASE_MANAGER then ends the embargo in the act that adopts the X value (CSB-13-002, ADR-0210). Participants message only the CASE_MANAGER (PCR-08-001).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern ...PX.
- EM state: ACTIVE, REVISE
- CS pattern: ...PX.

Steps

1. [participant] Report the X value to the CASE_MANAGER → Status report queued for the CASE_MANAGER only; no ET queued

Postconditions

- The CASE_MANAGER has the X report; the Participant has emitted no ET

Refines: VP-11-003 — Participants SHALL initiate embargo termination on learning of public exploit code
CSB-13-004 MUST This rule covers the CASE_MANAGER when it adopts an X value (q^cs → ···PX·) while an embargo is active (q^em ∈ {A, R}). It MUST record the adopted X value before it ends the embargo under CSB-13-002.

Every replica replays the ledger in order, so a teardown committed ahead of its cause would show the embargo ending for no recorded reason. The received form of this rule is CSB-05-010; the ledger mechanism is CLP-10-006.
Extends: CSB-13-002
CSB-13-003 MUST NOT A Participant entering CS Exploit Public MUST NOT seek new embargoes or accept new embargo proposals for this case.

VP-06-001 prohibits seeking new embargoes once exploit publication has occurred.

ECA Details

Preconditions

- CS matches pattern ....X.
- CS pattern: ....X.

Refines: VP-06-001 — Once Exploit Publication, new embargoes SHALL NOT be sought
Enter CS Attacks Observed (A)

Trigger: State Entered — CS.A

ID Priority Requirement Related
CSB-14-001 SHOULD This rule covers the CASE_MANAGER when it learns of an A value (q^cs → ·····A) while an embargo is active (q^em ∈ {A, R}). Acting for the Case Owner, it SHOULD end the embargo by adopting the value, in an act that emits ET.

VP-09-003 recommends ending the embargo when attacks are observed. It is SHOULD, not SHALL, to leave room for judgment. Under ADR-0166 that judgment is whether to adopt A: an adopted A ends the embargo in the same act (CSB-06-008, RSH-03-001). The Case Owner may delegate that decision in advance (RSH-07-003) and keeps the authority (VP-11-006). A non-manager Participant reports A instead (CSB-14-006).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern .....A
- EM state: ACTIVE, REVISE
- CS pattern: .....A

Steps

1. [CASE_MANAGER] Adopt the A value into the canonical case status → Case CS attacks bit set to A
2. [CASE_MANAGER] Emit ET to terminate the embargo, in the same act → ET queued for participants; EM transitions to EXITED

Postconditions

- CS attacks bit is A; the CASE_MANAGER has emitted ET; EM is EXITED

Refines: VP-09-003 — Embargoes SHOULD terminate immediately when there is evidence of active exploitation
CSB-14-006 SHOULD This rule covers a Participant that is not the CASE_MANAGER and enters CS Attacks Observed (q^cs → ·····A) while an embargo is active (q^em ∈ {A, R}). It SHOULD report the A value to the CASE_MANAGER instead of emitting ET.

VP-11-007 has a Participant that learns of attacks initiate embargo termination. Ending the embargo is the Case Owner's decision, carried out by the CASE_MANAGER (EMB-03-003, ADR-0118, VP-11-012), so the Participant's part is the report, sent to the CASE_MANAGER (PCR-08-001). The Case Owner may delegate in advance the decision to adopt a reported A (RSH-07-003); it then decides ahead of time and keeps the authority (VP-11-006).

ECA Details

Preconditions

- EM state is Active or Revise; CS matches pattern .....A
- EM state: ACTIVE, REVISE
- CS pattern: .....A

Steps

1. [participant] Report the A value to the CASE_MANAGER → Status report queued for the CASE_MANAGER only; no ET queued

Postconditions

- The CASE_MANAGER has the A report; the Participant has emitted no ET

Refines: VP-11-007 — Participants SHOULD initiate embargo termination on learning of attacks
CSB-14-005 SHOULD This rule covers the CASE_MANAGER when it adopts an A value (q^cs → ·····A) while an embargo is active (q^em ∈ {A, R}). It SHOULD record the adopted A value before it ends the embargo under CSB-14-001.

Every replica replays the ledger in order, so a teardown committed ahead of its cause would show the embargo ending for no recorded reason. The received form of this rule is CSB-06-010; the ledger mechanism is CLP-10-006.
Extends: CSB-14-001
CSB-14-003 MUST NOT A Participant entering CS Attacks Observed MUST NOT seek new embargoes for this case.

VP-06-001 prohibits seeking new embargoes once attacks have been observed.

ECA Details

Preconditions

- CS matches pattern .....A
- CS pattern: .....A

Refines: VP-06-001 — Once Attacks observed, new embargoes SHALL NOT be sought
CSB-14-004 SHOULD A Participant entering CS Attacks Observed SHOULD emit CA to announce the transition to other case Participants.

State-change notifications support shared situation awareness. CA informs other Participants that active exploitation has been observed, enabling them to re-evaluate embargo and disclosure decisions. VP-12-002 recommends that fix development accelerate and embargo teardown begin.

ECA Details

Preconditions

- CS matches pattern .....A
- CS pattern: .....A

Steps

1. [participant] Emit CA to announce Attacks Observed CS transition → CA queued for case participants

Postconditions

- CA emitted; other Participants informed of A transition

Refines: VP-03-012
Trigger-Side VFD Role Preconditions

Precondition requirements for self-reported CS trigger endpoints (notify-fix-ready, notify-fix-deployed, notify-published). These complement the receive-side CSB-02, CSB-03, and CSB-04 groups by specifying which CVD roles may initiate each VFD transition locally and what state each trigger endpoint MUST set.

ID Priority Requirement Related
CSB-15-001 MUST A participant MUST hold the VENDOR role in the case to report its own fix-ready transition (f → F).

Fix readiness (F event) represents that the actor has produced a fix. Only actors who develop or maintain the affected product (Vendors) can produce a fix; Deployers operate existing deployments and do not produce fixes. Finders, Reporters, and Coordinators likewise MUST NOT self-report fix readiness.

ECA Details

Preconditions

- A participant is about to report its own f → F transition

Steps

1. [participant] Check that the participant holds the VENDOR role in the case → The check passes for a Vendor; the transition is refused otherwise
2. [participant] If the check passes, report its vf state as F → The report goes to the CASE_MANAGER

Postconditions

- Only a VENDOR participant reports F

CSB-15-007 MUST NOT A participant without the VENDOR role in the case MUST NOT record its own fix-ready transition (f → F). Such a participant has no vendor-fix (vf) path.

Only a Vendor can produce a fix (CSB-15-001). A recorded F from any other participant would claim a fix it cannot have produced, and every reader of its status would believe it.

ECA Details

Postconditions

- Only a VENDOR participant records F

Extends: CSB-15-001
CSB-15-002 MUST A participant MUST hold the DEPLOYER role in the case to report its own fix-deployed transition (d → D).

Fix deployment (D event) represents applying a fix in one's own environment. Only actors who are responsible for operating deployed instances (Deployers) can perform this action. A shipping-product Vendor who does not control downstream deployment holds only the VENDOR role, not DEPLOYER, and has no deployer path.

ECA Details

Preconditions

- A participant is about to report its own d → D transition

Steps

1. [participant] Check that the participant holds the DEPLOYER role in the case → The check passes for a Deployer; the transition is refused for a VENDOR-only or any other non-DEPLOYER participant
2. [participant] If the check passes, report its d state as D → The report goes to the CASE_MANAGER

Postconditions

- Only a DEPLOYER participant reports D

CSB-15-009 MUST NOT A participant without the DEPLOYER role in the case MUST NOT record its own fix-deployed transition (d → D). Such a participant has no deployer (d) path.

Only a Deployer operates the deployed instances (CSB-15-002). A recorded D from any other participant would claim a deployment it cannot have done.

ECA Details

Postconditions

- Only a DEPLOYER participant records D

Extends: CSB-15-002
CSB-15-003 MUST A participant that reports that the vulnerability is public MUST record only the P event (pxa → Pxa) in its participant status.

Conflating P and D transitions causes non-deployer actors (Finders, Reporters, Coordinators) to incorrectly acquire deployment state when they announce public disclosure. The P event is participant-agnostic; the D event is valid only for a DEPLOYER participant that has separately completed deployment (CSB-15-002).

ECA Details

Preconditions

- A participant reports that the vulnerability is public

Steps

1. [participant] Record P (Pxa) in its participant status → Public awareness recorded

Postconditions

- The participant status records P

CSB-15-011 MUST NOT A participant's report of the P event MUST NOT also advance its d dimension.

The D event (fix deployed) is participant-specific and distinct from the P event (public awareness). A participant that reports fix deployment reports it separately, and must hold the DEPLOYER role (CSB-15-002).

ECA Details

Steps

1. [participant] Leave the vf and d dimensions unchanged (do not advance d to D) → vf and d reflect prior state; D event not triggered by P event

Postconditions

- The participant status's vf and d dimensions are unchanged

Refines: CSB-15-003
CSB-15-004 MUST A participant that holds the DEPLOYER role but not the VENDOR role MUST be permitted to make the d→D transition only when at least one participant holding the VENDOR role in the same case has reached F (fix ready). Such a participant has no vendor-fix (VF) state of its own and is at d before the transition; the transition moves it to D, recording deployment of a fix another participant produced.

A participant with the DEPLOYER role and no VENDOR role has a deployer path and no vendor path (ADR-0075). It can deploy only a fix that exists, so its d→D move waits until at least one VENDOR participant in the case is at F. Its d dimension starts at d and moves to D when that gate passes. The gate asks only that some VENDOR is at F, because the protocol does not record which vendor a deployer depends on, and a rule that named the vendor would need that record.

ECA Details

Preconditions

- The participant holds the DEPLOYER role but not VENDOR in the case (no vendor path; deployer path at d); at least one other participant holds the VENDOR role and is at F

Steps

1. [participant] Check that the participant holds DEPLOYER and not VENDOR, and that at least one participant in the case holds VENDOR and is at F (causal gate) → All checks pass; d → D transition allowed
2. [participant] Record its d state as D and report it → d is D (it was d); the participant still has no vendor path; the report goes to the CASE_MANAGER

Postconditions

- The DEPLOYER-only participant records D with no vendor path throughout; at least one VENDOR participant is at F in the same case

Extends: CSB-15-002 — CSB-15-002 gates d→D on the DEPLOYER role; CSB-15-004 adds the causal precondition requiring at least one VENDOR participant to be at F first
CS Write-Boundary Transition Validation

Requirements for CS state write paths (VFD and PXA) to validate source→target transition validity before persisting a ParticipantStatus snapshot. Complements CSB-15 (trigger-side role preconditions) and SDO-02-002 (dimension object transition contract) by requiring that the BT write node itself is fail-closed regardless of upstream guard coverage.

ID Priority Requirement Related
CSB-16-001 MUST A participant MUST advance its own vendor-path (vf) or deployer-path (d) dimension only along a transition its sub-machine permits. The vendor path uses CS_vf, and the deployer path uses CS_d. Restating the current state is a status confirmation and is permitted.

A participant's status is its own claim about the case, and every other participant reads it. A jump the sub-machine does not permit therefore misstates the history of the vulnerability (SDO-02-004). The vendor and deployer paths are separate sub-machines (ADR-0075), so a participant that holds both roles is held to each path independently. The rule covers a participant's own writes. A receiver applies a weaker forward-only check to the status of a peer, because a peer can advance several steps between two messages.

ECA Details

Preconditions

- A participant is about to record a new vf state (Vendor path) or d state (Deployer path) for itself

Steps

1. [participant] Read its current vf state (if a Vendor) or d state (if a Deployer) → Current dimension state available; a participant without the role has no such dimension
2. [participant] For each dimension it holds: if the target is the current state, proceed; if the sub-machine permits current → target, proceed; otherwise refuse → Only permitted transitions or same-state confirmations are recorded

Postconditions

- No participant status with an illegal vf or d jump is recorded

CSB-16-005 MUST NOT A participant MUST NOT record a backward move or an illegal jump of its own vf or d dimension.

Every other participant reads a participant's status as its claim about the case, so a recorded backward move or illegal jump misstates the history of the vulnerability (CSB-16-001, SDO-02-004).

ECA Details

Postconditions

- No participant status with an illegal vf or d jump is recorded

Refines: CSB-16-001
CSB-16-002 MUST A participant MUST advance a PXA state it records only along a transition the PXA state machine permits. This holds in its own participant status and in the case status. Restating the current state is permitted.

PXA events are forward-only (p→P, x→X, a→A). Public awareness, a public exploit or observed attacks cannot become untrue later. The rule that limits the vf and d paths to permitted transitions (CSB-16-001) applies to PXA for the same reason.

ECA Details

Preconditions

- A participant is about to record a new PXA state

Steps

1. [participant] Read the current PXA state → Current PXA state available
2. [participant] If the target is the current state, proceed; if the PXA state machine permits current → target, proceed; otherwise refuse → Only permitted transitions or same-state confirmations are recorded

Postconditions

- No status with an illegal PXA regression is recorded

CSB-16-007 MUST NOT A participant MUST NOT record a backward PXA move, in its own participant status or in the case status.

A backward PXA write would show a false regression in the case record, and every participant reads that record (CSB-16-002).

ECA Details

Postconditions

- No status with an illegal PXA regression is recorded

Refines: CSB-16-002
CS Compound State and History Validity

CS-internal validity invariants over the compound (VFD x PXA) case state and over whole case histories. Where CSB-16 validates a single write at the persistence boundary, CSB-17 defines which compound states exist, which single-event transitions between them are causally possible, and which orderings of the six CS events a real case could have produced. Mined from the legacy vultron.core.case_states hypercube model and re-expressed against the current CS enums; see ADR-0060.

ID Priority Requirement Related
CSB-17-001 MUST An implementation MUST treat exactly 32 compound CS states as valid: the cross product of the 4 valid VFD states (vfd, Vfd, VFd, VFD) and the 8 PXA states.

The VFD dimension is a linear chain, not a free product of three bits: readiness presupposes awareness and deployment presupposes readiness. Enumerating only the reachable combinations makes the two impossible combinations unrepresentable rather than merely rejected at runtime, which is why CS_vfd has four members and not eight.

ECA Details

Postconditions

- The CS enum has exactly 32 members, one per valid compound state

Refines: SM-09-002 — SM-09-002 states the vF/fD prohibition as a rejection rule; this refines it to a structural guarantee by enumerating only the 32 reachable combinations, so the impossible ones are unrepresentable.
CSB-17-002 MUST A CS transition MUST change exactly one of the six CS dimensions. The one exception is a compound transition, as in CSB-13-006. It applies an event together with the forced successor of the ephemeral state (CSB-17-003) that the event would enter.

CS events are irreversible and are observed one at a time; a compound state change of Hamming distance greater than one conflates two distinct events and loses their ordering, which is exactly the information history validity depends on. These two conditions alone admit 72 transitions; applying the ephemeral-state rule of CSB-17-003 leaves exactly 58 valid CS transitions.

ECA Details

Preconditions

- A (source, destination) pair of compound CS states

Steps

1. [validator] Identify the single dimension that differs between source and destination; reject if more than one differs. If none differs, the write is a same-state re-assertion, which CSB-16-001 and CSB-16-002 permit as a status confirmation: accept it only when the caller has opted in (the allow_null parameter), and reject it otherwise, because a transition validator's default answer for "no change" must be "that is not a transition". → A single CS event accounts for the change, or the caller has explicitly asked for same-state writes to pass
2. [validator] Delegate to the changed dimension's own transition table (is_valid_vfd_transition or is_valid_pxa_transition). → Monotonicity and VFD prerequisite ordering are enforced
3. [validator] Apply the ephemeral-state rule of CSB-17-003 to the source state. → A transition out of a vP or pX state fires only the event that state requires

Postconditions

- Only Hamming-distance-1 monotone transitions are accepted

Constrains: CSB-16-001 — Adds the one-dimension-at-a-time and monotonicity constraints that a per-dimension write validator cannot see. The same-state write CSB-16 permits is preserved via the opt-in described in step 1.
Constrains: CSB-16-002
Uses definition from: CSB-17-003
CSB-17-014 MUST A CS transition MUST change its one dimension from the not-yet-happened value to the happened value.

CS events are irreversible, so a change from the happened value back to the not-yet-happened value describes no event. With CSB-17-002 this condition admits 72 transitions, and the ephemeral-state rule of CSB-17-003 leaves 58.

ECA Details

Postconditions

- Only monotone transitions are accepted

Extends: CSB-17-002
CSB-17-003 MUST An implementation MUST treat the compound states vP (public aware while the vendor is unaware) and pX (exploit public while the public is unaware) as ephemeral.

Neither condition can persist in reality: public awareness reaches the vendor, and a published exploit makes the public aware. Modelling these as ephemeral rather than invalid preserves the causal ordering of the events while forbidding the case from progressing in any other direction first. The pX ephemeral rule is the pX to PX invariant of CSB-13-001 generalised from the entry cascade to every successor of a pX state.

ECA Details

Preconditions

- The case is in one of the 12 ephemeral compound CS states

Postconditions

- Each ephemeral state has exactly one valid successor state

Extends: CSB-13-001
CSB-17-004 SHOULD A consumer validating a reported CS history SHOULD validate it causally by replaying the event sequence through CSB-17-002 and CSB-17-003 from the initial state vfdpxa, rather than checking states point-in-time or comparing wall-clock timestamps. A complete history contains all six CS events exactly once; there are exactly 70 valid complete histories out of 720 orderings.

Validity of a case trajectory is a property of the whole ordered sequence, not of any single state: VFDPXA and VFDXAP visit only valid states, but only the first is a possible case history. Wall-clock timestamps cannot substitute, because they may be missing, skewed, or recorded by different participants. SHOULD rather than MUST because a consumer holding only a current state, with no event log to replay, cannot do better.

ECA Details

Preconditions

- An ordered sequence of CS events, possibly incomplete

Steps

1. [validator] Reject any event that occurs more than once in the sequence → Each CS event happens at most once
2. [validator] Replay the sequence from vfdpxa, requiring each step to satisfy CSB-17-002 and CSB-17-003 given every event that preceded it. → Causally impossible orderings are rejected

Postconditions

- A complete valid history terminates in VFDPXA

Uses definition from: CSB-17-002
Uses definition from: CSB-17-003
CSB-17-005 MUST An incomplete CS history MUST be validated as a prefix.

Real cases are usually still in progress, so requiring six events would reject every live case. Ending in an ephemeral state is unavoidable at the prefix level: CSB-17-003's forced successor has not happened yet when the prefix is cut, which is different from an actor persisting an ephemeral state as its own — SM-09-003 still forbids that. Pinning acceptance to CSB-17-004's prefix closure keeps both directions honest: a validator that merely never rejects a genuine prefix could still accept dead ends.

ECA Details

Preconditions

- An ordered sequence of CS events with fewer than six entries

Steps

1. [validator] Apply CSB-17-004's replay to the sequence without requiring that it terminate in VFDPXA. → The prefix is accepted iff it is a prefix of at least one valid complete history

Postconditions

- A prefix ending in an ephemeral state is accepted, and its forced successor per CSB-17-003 is the only legal continuation

Refines: CSB-17-004
CSB-17-006 MUST An implementation MUST NOT allow a fix to be ready while the vendor is unaware (the vF compound state is impossible).

Fix readiness presupposes vendor awareness; the vF combination is structurally excluded from the 32 valid compound CS states.
CSB-17-007 MUST An implementation MUST NOT allow a fix to be deployed that was never ready (the fD compound state is impossible).

Fix deployment presupposes fix readiness; the fD combination is structurally excluded from the 32 valid compound CS states.
CSB-17-008 MUST A CS transition that changes two or more dimensions at once, that reverses a dimension, or that skips a VFD prerequisite MUST be rejected. The compound transition of CSB-13-006 is exempt from the multi-dimension form only.

Each of the three prohibited forms conflates or reorders distinct causal events; rejecting them enforces the one-event-at-a-time and monotonicity invariants.
CSB-17-009 MUST From a vP state the next CS event MUST be V.

The forced-successor rule is the operational consequence of CSB-17-003's ephemeral classification: each ephemeral state has exactly one valid continuation, enforcing the vP→VP invariant.
CSB-17-012 MUST From a pX state the next CS event MUST be P.

The forced-successor rule for pX states enforces the pX→PX invariant; pX is ephemeral and P is the only valid continuation.
Refines: CSB-17-003
CSB-17-013 MUST Any CS event other than the forced successor MUST be rejected when the current state is ephemeral (vP or pX).

Accepting any other event would break the vP→VP and pX→PX invariants that the forced-successor rule exists to enforce.
Refines: CSB-17-003
CSB-17-010 MUST NOT Prefix validation MUST NOT require all six CS events to be present.

Real cases are still in progress at validation time, so requiring all six events would reject every live case.
CSB-17-015 MAY A CS history prefix MAY end in an ephemeral state.

An ephemeral-ending prefix is valid as long as its forced successor has not yet been observed.
CSB-17-011 MUST Every accepted incomplete CS history prefix MUST have at least one valid completion among the 70 valid complete histories of CSB-17-004.

Pinning acceptance to the prefix closure of CSB-17-004 prevents a validator from accepting dead-end prefixes that cannot lead to any valid complete history.
Uses definition from: CSB-17-004
Cross-Machine State Entailments

Invariants that span two state machines simultaneously. These are causal entailments, not local transition constraints: they capture states that are logically contradictory given the sequence of events that produced them. CSB-18-001 is enforced at emit time via ValidateTriggerTransitionsNode and on the receive path via composite_state_violations() (composite_state_invariants.py). CSB-18-002 through CSB-18-004 (PXA↔EM) are enforced on the receive path via ThreatTerminationBranchNode in add_participant_status_tree; violation_pxa_em_entailment() (composite_state_invariants.py) is the post-cascade diagnostic caller via PxaEmInvariantDiagnosticNode (CONCERN-3008, issue #3115).

ID Priority Requirement Related
CSB-18-001 MUST NOT A participant's composite state MUST NOT have the VFD F-bit set (q^cs ∈ VFd··· or VFD···) while the participant's RM state is outside {ACCEPTED, DEFERRED, CLOSED}. A fix cannot be ready before the vulnerability has been accepted for action.

The F bit records that the vendor has a fix. A vendor makes a fix only after it accepts the report for action. An F bit with an RM state before acceptance (START, RECEIVED, INVALID or VALID) is therefore causally impossible. The true rule is about history: the participant passed through ACCEPTED at some time. A participant status holds only the current RM state, so the check uses the RM states that ACCEPTED can reach. DEFERRED and CLOSED can also be reached without ACCEPTED, so the check is sound but not complete. The set keeps them because a peer can move through ACCEPTED to DEFERRED or CLOSED and report a ready fix in one message. A check of ACCEPTED alone would refuse that valid update. Only the RM history of the participant can give a complete check.

ECA Details

Preconditions

- Any participant state snapshot is available for inspection

Constrains: CSB-16-001
CSB-18-002 MUST NOT Once a CASE_MANAGER act commits, a participant's composite state MUST NOT have the PXA P-bit set (q^cs ∈ ···P··) while an active embargo exists (q^em ∈ {ACTIVE, REVISE}). Public awareness of a vulnerability while an embargo is active is causally impossible in a well-functioning coordination — the P event causes embargo termination, so EM cannot remain ACTIVE once P has occurred.

The P event (public awareness) makes the embargo end. An embargo that stays ACTIVE or REVISE after P is recorded is therefore a causal contradiction, and it misstates the case to every participant that reads it. The emit path does not refuse a P report while an embargo is active, because that report is what causes the embargo to end. The rule is judged per act, not per entry (ADR-0210): the adopting act writes its snapshot before the teardown (RSH-01-004).

ECA Details

Preconditions

- A PXA state and an EM state are both available for the same case

CSB-18-003 MUST NOT Once a CASE_MANAGER act commits, a participant's composite state MUST NOT have the PXA X-bit set (q^cs ∈ ···X·) while an active embargo exists (q^em ∈ {ACTIVE, REVISE}). Public exploit availability while an embargo is active is causally impossible — the X event entails embargo termination.

A public exploit lets attackers use the vulnerability, so secrecy no longer protects users. An embargo that stays ACTIVE or REVISE after X tells participants to keep a secret that attackers already have. It also holds back information that defenders need now, and it misstates the case to every participant that reads it. It is judged when an act commits, as CSB-18-002 is (ADR-0210).

ECA Details

Preconditions

- A PXA state and an EM state are both available for the same case

Derives from: CSB-18-002
CSB-18-004 MUST NOT Once a CASE_MANAGER act commits, a participant's composite state MUST NOT have the PXA A-bit set (q^cs ∈ ···A) while an active embargo exists (q^em ∈ {ACTIVE, REVISE}). Observed attacks while an embargo is active is causally impossible — the A event entails embargo termination.

Observed attacks show that the vulnerability is in use. An embargo that stays ACTIVE or REVISE after A holds back the information that defenders need to protect themselves while the attacks go on. It also misstates the case to every participant that reads it. It is judged when an act commits, as CSB-18-002 is (ADR-0210).

ECA Details

Preconditions

- A PXA state and an EM state are both available for the same case

Extends: CSB-18-002
CS Ordering Invariants Under Out-of-Order Ledger Delivery

Normative requirements for how CS ordering invariants interact with the ADR-0037 out-of-order ledger hold. Clarifies when invariant guards are evaluated relative to the hold and the drain.

ID Priority Requirement Related
CSB-19-001 MUST CS ordering invariants (ephemeral-state guard, history-prefix validity, CP-before-ET ordering) MUST be evaluated at drain time — that is, against the causal-order replay of the held Adds (ADR-0037, SYNC-14-009) — not at the time of original out-of-order receipt.

An out-of-order Add(CaseLedgerEntry) carrying a CS update is held by BufferOutOfOrderEntryNode before any domain effects are applied; the CS state machine is not touched at hold time. When the gap fills, the drain replays each held Add through the full add-log-entry receive BT in log_index order (ADR-0037, CLP-14-001), so CS guards see the entries in correct causal sequence. Evaluating guards at original receipt would produce false violations whenever the predecessor CS entry has not yet arrived.
Uses definition from: CSB-12-004
Uses definition from: SYNC-14-009
CSB-19-002 MUST NOT A held out-of-order CS ledger entry MUST NOT trigger an ephemeral-state violation or history-prefix validation failure at the time it is held.

An ephemeral-state entry (e.g., a pX-state CaseStatus arriving before its P-state predecessor) is structurally valid in isolation; the violation would only be real if the predecessor never arrives. Flagging it at hold time produces a false positive and may cause the entry to be incorrectly rejected, breaking convergence.
Refines: CSB-19-001
CSB-19-003 MUST Under out-of-order ledger delivery, the CP-before-ET constraint of CSB-12-004 MUST still hold. It holds because the CASE_MANAGER commits in causal order (CLP-14-001): the P-state entry has a lower log_index than the ET entry after it. The drain therefore processes P before ET when it holds both.

CSB-12-004 is enforced at the CASE_MANAGER write-side: the CASE_MANAGER commits the P-state entry before committing the ET entry. This means the P-state entry's log_index is strictly lower than the ET entry's log_index. The ADR-0037 drain replays in log_index order, so the constraint cannot be violated by reordered delivery alone. No receiver-side re-enforcement of the temporal constraint is required; the causal order in the ledger is sufficient.
Refines: CSB-12-004
Depends on: CLP-14-001

14.4 Case Management

The requirements on cases and their participants: the case object, case proposals, participant roles, and the asks a participant answers.

Case Management

Requirements for VulnerabilityCase lifecycle management, CASE_MANAGER responsibilities, and the RM/EM/CS/VFD state model. Covers actor isolation at the protocol level, the distinction between participant-specific and participant-agnostic state, case initialization sequencing, embargo acceptance ownership, and the invitation acceptance lifecycle.

Actor Isolation
ID Priority Requirement Related
CM-01-001 MUST Each actor MUST have an isolated protocol state domain

Each actor is a separate party, with its own view of the case and its own authority over its state. If the records of one actor can change what another actor reads, a fault or a hostile peer in a shared deployment can change the case history of another party. Then no actor can trust its own copy.
CM-01-002 MUST Each actor's RM state MUST be maintained independently per case

RM is a process for each participant. Each participant receives, validates, accepts, defers and closes a report on its own schedule (CM-03-002). One RM state for each actor in each case lets an actor be at different RM stages in different cases. It also stops the progress of one actor from counting as the progress of another actor.
CASE_MANAGER Lifecycle
ID Priority Requirement Related
CM-02-001 MUST Each VulnerabilityCase MUST have exactly one associated CASE_MANAGER

The CASE_MANAGER is the only writer of canonical case state (CM-02-002). With no CASE_MANAGER, no actor can commit a case change. With two, two actors can commit changes that conflict. The copies of the case then become different, and no rule can make them agree again.
CM-02-002 MUST CASE_MANAGER MUST be the authoritative source of truth for case state

Every participant has its own copy of the case. Without one source of authority, two participants that disagree have no rule to decide which copy is correct, and the copies become different. When the CASE_MANAGER is that source, every replica gets the same state (ADR-0108).
CM-02-003 MUST CASE_MANAGER MUST persist until the associated VulnerabilityCase is closed

The authority for a case must be clear for as long as the case accepts changes. If the CASE_MANAGER role stops before the case closes, messages that need its decision have no valid recipient. Then the case cannot close in the correct sequence.
CM-02-004 MUST CASE_MANAGER MUST know the Case Owner

Only the Case Owner can do some case actions (CM-02-005). The CASE_MANAGER can enforce this only if it knows the Case Owner. The case records the Case Owner in attributed_to.
CM-02-005 MUST CASE_MANAGER MUST restrict the following activities to the Case Owner: case closure, approving an embargo proposal to become active on the case and terminating an active embargo, approving or rejecting participant invitations, case ownership transfer, and offering a participant an additional role (CM-33-002) (see CM-02-006 for the authorisation mechanism).

These actions decide who learns about the vulnerability, under what embargo, and who is responsible for the case. In CVD, the Case Owner makes these decisions. If any participant can start them through the CASE_MANAGER, a participant can close the case, change the embargo, admit a party that nobody checked, or take the case.
See also: CM-02-006 — context for the reader
CM-02-006 MUST CASE_MANAGER MUST enforce case-level authorization for all case mutations

The CASE_MANAGER applies every change to canonical case state. Thus it is the one place that can stop an unauthorized change before every replica copies it. If a change path skips the check, any actor that can get to the inbox can change the case.
CM-02-007 MUST A VulnerabilityCase MUST carry a notes collection recording the case-scoped notes added to it by Add(Note) activities that target the case

Case notes are the discussion of the case by the participants, and they must stay with the case. A notes collection on the case gives each Add(Note) a location. It also lets a participant that joins later see the notes from before it joined.
CM-02-008 MUST This rule covers every path that creates a VulnerabilityCase from an Offer(VulnerabilityReport), the CASE_MANAGER's path included (CP-09-001). Each such path MUST set the case's attributed_to to the ID of the actor that received the Offer, the CASE_OWNER.

attributed_to is the owner field of the case. Ownership checks read it (MSM-07-027), and ownership transfer changes it together with the CASE_OWNER role (CM-21-002, CM-21-024). The actor of Create(VulnerabilityCase) records who created the case, not attributed_to. Thus the CASE_MANAGER does not become the owner when it creates the case.
CM-02-017 MUST A path that creates a VulnerabilityCase from an Offer(VulnerabilityReport) MUST record the actor that received the Offer, the CASE_OWNER, as the case's initial primary participant.

The actor that received the report is the first party that must act on it, and it owns the case. When it is the first participant, the case has a participant record for its owner before any other party joins.
Extends: CM-02-008
CM-02-009 MUST For each state-changing event it receives, the CASE_MANAGER MUST take the commit stamp on the event's ledger entry as its trusted time. That stamp is the envelope published of CLP-14-002.

The CASE_MANAGER's clock is the only trusted source of time for the order of events in a case. If each copy of the case used the time a participant supplied, the copies could disagree on the order of events. The ledger entry carries two times (ADR-0103): the CASE_MANAGER's commit stamp, which orders the case, and the sender's claim, which CM-02-018 keeps.
Derives from: CM-02-002
Uses definition from: CLP-14-002
CM-02-018 MUST The CASE_MANAGER MUST keep the sender's claimed time on each state-changing event as sent in the entry's payloadSnapshot, never overwriting it.

The sender's claim is evidence of when the sender says the event happened (ADR-0103). The CASE_MANAGER cannot verify it, so it does not order the case by it (CM-02-009). If the CASE_MANAGER overwrote it, the record of what the sender said would be lost, and the received body would change (CLP-07-011).
Extends: CM-02-009
CM-02-014 MUST A VulnerabilityCase MUST have both a CASE_OWNER participant and a CASE_MANAGER participant from the moment of creation onward. Neither slot may be left empty or deferred to a later operation. Role delegation transfers the CASE_MANAGER role without a gap.

An empty CASE_OWNER or CASE_MANAGER slot leaves every role check without an answer from the moment the case exists, and a case created without either has no participant entitled to repair it (ADR-0088). Both creation paths register a CASE_MANAGER: a dedicated CASE_MANAGER actor (ADR-0041), or the creating actor holding both roles. With a CASE_MANAGER always present, every case-scoped message has the CASE_MANAGER to go through (PCR-08-001).
Extends: CM-02-001
Case State Model
ID Priority Requirement Related
CM-03-001 MUST The system MUST implement the three interacting state machines: RM (Report Management), EM (Embargo Management), and CS (Case State)

Report handling, embargo negotiation, and the public and fix state of a case change for different reasons and at different times. Three interacting machines let an implementation validate each one on its own. The interactions between them stay explicit and do not hide in one combined state.
CM-03-002 MUST RM state MUST be participant-specific

Each participant moves through report handling on its own. One participant can accept a report that another has not yet validated. A single shared RM state cannot show this, and one participant's transition would overwrite the state of another (CM-01-002).
CM-03-003 MUST A shared EM state MUST be tracked at the case level in the case's CaseStatus, to represent the collective embargo agreement

An embargo binds every participant in the case. Thus, whether an embargo is proposed, active or ended is one fact for the whole case. One case-level record gives every participant the same answer. The consent rows keep each participant's agreement separately (CM-10-001).
Implements: VP-04-002
CM-03-004 MUST CS (PXA sub-state) MUST be participant-agnostic (shared per case)

Public awareness, exploit publication and attacks in the wild are facts about the world, not about one participant. When the vulnerability is public, it is public for all participants. A copy for each participant can only disagree with the facts.
CM-03-005 MUST VFD (Vendor Fix Deployment) state MUST be participant-specific

Fix readiness and deployment are different for each participant. One vendor can ship a fix before another vendor, and a deployer has its own deployment state. A shared VFD state would let the progress of one participant show as the progress of another (ADR-0075).
CM-03-007 MUST RM state transitions MUST use the established protocol activity types without introducing new activity types for reverse transitions

Keeps the RM symbol set minimal and produces clean audit histories; Undo conflates historical negation with a new forward transition
State Transition Correctness
ID Priority Requirement Related
CM-04-001 MUST A receiver of a participant-status message MUST record the declared RM state on the sending actor's CaseParticipant, as its model of the sender (SM-10-001).

RM state is self-declared: each participant reports its own report-handling progress (CM-03-002). A participant-status message updates the receiver's model of its sender. A record on any other participant would give one participant the progress of another. Other messages move the receiver's own state instead (SM-10-001). RSH-08-003 says which receiver writes the record directly.
Refines: SM-10-001
Implements: VP-01-002
CM-04-002 MUST A receiver processing a VFD state transition MUST update the VFD state in the participant status of the sending actor's CaseParticipant

VFD state is participant-specific (CM-03-005). A VFD message reports the fix readiness or deployment of the sender. A record on any other participant would claim a fix that this participant did not make.
Refines: SM-10-001
CM-04-003 MUST When the Case Owner accepts an embargo, the CASE_MANAGER MUST activate it in the case's embargo register, from which the case-level EM state derives (ADR-0122). Every other replica takes that state from the CASE_MANAGER's ledger (RSH-08-003).

The shared embargo binds the case only when the Case Owner accepts it (CM-02-005). A case-level record of that acceptance puts the embargo in force for all participants at the same time. Only the CASE_MANAGER writes canonical case state (ADR-0108), and the EM state is derived from the append-only register, with CaseStatus.em only a stamped copy (ADR-0122). The acceptances of other participants stay in their own consent rows (CM-04-008).
See also: RSH-08-003 — context for the reader
CM-04-004 MUST When the CASE_MANAGER adopts a PXA transition (public disclosure, exploit publication or attack observation), it MUST record the case-level PXA state in the case's CaseStatus. Every other replica takes that state from the CASE_MANAGER's ledger (RSH-08-003).

PXA state is a case-level fact (CM-03-004). A record of a reported disclosure, exploit or attack on the shared CaseStatus makes it visible to all participants at the same time. This is important because each of these events can end an embargo early. Only the CASE_MANAGER writes canonical case state (ADR-0108).
Refines: SM-10-002
See also: RSH-08-003 — context for the reader
CM-04-005 MUST A receiver processing a VFD or PXA transition MUST validate the requested transition against the authoritative current state before recording it

A transition is valid only from the current state of the case or participant. If the receiver records a transition without a check against the authoritative current state, a stale or out-of-order message can move the state backward or skip a necessary step. Every replica then copies the incorrect state.
CM-04-006 MUST NOT A participant-specific transition (RM or VFD) MUST NOT change any case-level (participant-agnostic) state (EM or PXA).

Participant-specific state and case-level state are separate by design (CM-03-002 through CM-03-005). If an RM or VFD transition of one participant wrote across this boundary, it could change the shared embargo or public state.
Satisfies: VP-13-009
CM-04-010 MUST NOT A case-level transition (EM or PXA) MUST NOT change any participant-specific state (RM or VFD).

Participant-specific state and case-level state are separate by design (CM-03-002 through CM-03-005). If a shared event wrote across this boundary, it could overwrite the progress of one participant.
Extends: CM-04-006
CM-04-007 MUST RM transition validation MUST treat RM.CLOSED as terminal before it applies any same-state no-op shortcut.

If the validator checks for equality first, a duplicate close retry can flow into the later append and broadcast paths as a fresh state change.
CM-04-011 MUST RM transition validation MUST treat a repeated RM.CLOSED -> RM.CLOSED update as a terminal no-op: no new participant status record, broadcast or case-ledger entry.

A participant can send its close again, for example on a retry. A repeat of the close is not a new decision. If it appended a record, broadcast or ledgered, every replica would record a second close that never happened.
Extends: CM-04-007
CM-04-008 MUST When processing an EM state transition and the accepting actor is any participant other than the Case Owner, the receiver MUST update only that participant's own consent row for the accepted embargo.

Non-owner participants do not advance the shared EM state; their individual acceptance updates only their own consent record.
Object Model Relationships
ID Priority Requirement Related
CM-05-001 MUST VulnerabilityReport, VulnerabilityCase, VulnerabilityItem, CaseReference, CaseParticipant, and ParticipantStatus MUST be distinct, non-interchangeable object types.

Each of these objects has its own meaning and its own rules. If two of them were one type, a receiver could not tell which one a message carries. The CASE_MANAGER is not in this list: it is an ordinary actor designated for a case, not an identity or a distinct object type (ADR-0088).
CM-05-015 MUST NOT A message MUST NOT carry one of the six object types of CM-05-001 where the protocol expects another of them.

A receiver acts on an object by its type. If a message carried a case where a report is expected, the receiver would apply the rules of one object to a different object.
Refines: CM-05-001
CM-05-002 MUST NOT A VulnerabilityCase MUST NOT exist without a reference to at least one VulnerabilityReport.

A case exists to coordinate the response to a reported vulnerability. A case with no report has nothing to coordinate and gives participants nothing to act on. Also, a participant that joins later reads the report to learn what the case is about.
CM-05-003 SHOULD A VulnerabilityCase SHOULD reference at least one VulnerabilityItem before closure

A VulnerabilityItem identifies the vulnerability outside the case, for example with a CVE ID. If a case closes without one, the outcome is difficult to find and to cross-reference. Some cases close without one for a good reason, thus the rule is a SHOULD.
CM-05-004 MAY A VulnerabilityCase MAY have zero or more CaseReference objects, each with its own id and an as:Link to the referenced resource in its url.

Advisories, patches and other public material can exist for a case or not. Their number depends on how many parties publish. Zero or more items let the case record what exists, with no placeholder. A reference is offered, admitted and ledgered (CM-34), so it needs an id; an as:Link has none, because AS2 makes Link disjoint with Object and treats a Link's properties as hints about another resource. The Link therefore sits in the reference's url, which AS2 types as a URI or a Link.
CM-05-005 MUST CaseReference objects MUST include at minimum a url field, an as:Link whose href names the referenced resource.

A reference points a reader to a public resource. Without a url and its href, it identifies nothing that a consumer can get or examine.
CM-05-006 MAY One report MAY describe several vulnerabilities.

Reports and vulnerabilities do not always map one to one. One finder can report several flaws together.
CM-05-017 MAY One case MAY group several reports, for example when the reports involve overlapping participants.

Several finders can report the same flaw. Then one case can coordinate the response to the related reports, and the same work does not divide across cases.
CM-05-007 MAY Multiple CaseReference objects MAY arise from a single case (e.g., coordinated simultaneous disclosure by multiple vendors)

When several vendors fix the same vulnerability, each vendor usually publishes its own advisory. The case must record all of these advisories, not only one.
CM-05-008 MUST NOT An actor MUST NOT interpret the value of a vulnerability identifier, nor restrict vulnerability identifiers to the CVE namespace or any other one namespace.

No namespace is the only one: CVE, CERT/CC VU#, GHSA, CNNVD and vendor IDs all name real vulnerabilities. A rule that reads meaning out of an identifier's value, or admits only one namespace, would refuse valid identifiers. A field that is CVE-typed on purpose may still check the CVE ID format (CM-05-019), because it chose its namespace up front (ADR-0187).
CM-05-009 SHOULD A VulnerabilityItem SHOULD support a list of alias identifiers from different namespaces for the same vulnerability

Multiple IDs from different namespaces may refer to the same underlying vulnerability (e.g., a CVE ID and a CERT/CC VU# ID)
CM-05-010 MUST Not yet in the reference implementation (tracked by #6241)

When a vulnerability item carries a CVE record as its content, that content MUST conform to the CVE JSON schema (https://github.com/CVEProject/cve-schema).

Tools that read a CVE record expect the CVE JSON schema, and they refuse or misread data that does not conform. A CVE ID on its own is an identifier, not a CVE record, so it carries no data for the schema to check (CM-05-008, ADR-0187). A case reference borrows only the schema's reference tag names, as the rel values of its url Link (CM-05-012); that is a vocabulary, not CVE record content, so this rule does not reach it.
CM-05-011 SHOULD CaseReference objects SHOULD include a name field containing a human-readable title.

A human-readable title makes references easier to identify in case summaries and reports.
CM-05-012 MAY A CaseReference's url Link MAY carry rel values, each a CVE reference tag (e.g., "patch", "exploit") written as an RFC 8288 relation type.

Relation types let consumers filter or categorise references without parsing the URL or name. AS2 puts a link's relation types in the Link's rel, in the RFC 8288 form: a type IANA registers keeps its bare name ("related"), and any other is a URI, here under https://certcc.github.io/Vultron/ns/rel/. AS2's tag takes objects and links, not strings, so it cannot carry them.
CM-05-018 MUST A vulnerability item MUST carry the identity fields of a CSAF 2.1 vulnerability entry: a list of ids that each pair a system_name with a text, an optional name that holds the entry's title, a list of notes, and a list of references. A CVE ID is an ids entry whose system_name is CVE; the item has no cve field of its own.

Shaped like a CSAF vulnerability entry, the item maps a CSAF report's vulnerabilities in and out field by field. Pairing each identifier with its tracking system names its namespace without parsing its value (CM-05-008, ADR-0187). A reader finds all of a vul's identifiers in one list; CSAF's own cve field maps to and from the CVE entry (CSAF-03-008). The title travels as AS2 name, which means the same, because a Vultron term never duplicates an AS2 term (VM-10-009, ADR-0194).
CM-05-019 MUST The text of a vulnerability item's ids entry whose system_name is CVE MUST match the CVE ID format that CSAF 2.1 gives its cve field.

The CSAF translation maps the CVE entry to CSAF's CVE-typed cve field, so a value that passes this check also passes CSAF. This is the one exception to CM-05-008: the identifier of every other system stays opaque (ADR-0187).
CM-05-020 MUST NOT A vulnerability item MUST NOT hold the per-vulnerability state of a CSAF vulnerability entry, such as product status, metrics, dates, remediations, threats or flags.

The item names and describes a vulnerability. The case's state lives in its own records, so a second copy on the item could disagree with them (ADR-0187).
CM-05-021 MUST A VulnerabilityCase MUST hold a list of its vulnerability items and a list of its case references, each empty by default.

CM-05-003 expects a case to reference a vulnerability item and CM-05-004 lets it have references, so the case needs a place for both. Each item and each reference is an object of its own, which the case lists as it lists its reports (ADR-0187).
Case Update Broadcast
ID Priority Requirement Related
CM-06-001 MUST When the CASE_MANAGER updates canonical case state, it MUST notify every active participant (CM-10-004).

Every change the CASE_MANAGER makes to the case file is its own ledger entry (CLP-07-013), so the ledger fan-out is the notice: each change reaches the active participants as Add(CaseLedgerEntry). The CASE_MANAGER also announces the updated case as Announce(VulnerabilityCase) after admitting an engagement that moved the sender's recorded RM state. An engagement that restates a move already recorded changes no case state, so it announces nothing (RSH-08-002, ID-05-003). No participant sends the CASE_MANAGER an Update(VulnerabilityCase); one that arrives is the shape of the CASE_MANAGER's own update_case_owner act, which no received use case handles, so it is reported "no use case found" (SE-05-002, ADR-0140).
Implements: VP-02-019
Implements: VP-03-012
Uses definition from: CM-10-004
CM-06-002 MUST Participants receiving a case update notification MUST treat the update as authoritative only when it originates from the CASE_MANAGER

Only the CASE_MANAGER writes canonical case state, and replicas get it from the CASE_MANAGER (ADR-0108). If a replica accepts a case update from any other participant, any peer can make that replica diverge from the canonical case.
Derives from: CM-02-002
CM-06-003 MUST Case update notifications MUST include the updated CASE_MANAGER's actor URL so participants can fetch the current case state if needed

A notification can be a summary, can arrive late, or can arrive out of order. The actor URL of the CASE_MANAGER lets a participant that thinks its copy is stale get the current state from the authoritative source, not from a peer.
CM-06-004 MUST Participants MUST authenticate case update notifications before accepting them as authoritative

Participants accept an update as authoritative only when it comes from the CASE_MANAGER (CM-06-002). Without authentication, any party can claim to be the CASE_MANAGER and send false case state, for example an embargo that it says is lifted.
CM-06-005 MUST When a note is added to a case, the CASE_MANAGER MUST broadcast the note to every active participant (CM-10-004), excluding the note author.

A note is part of the case discussion, and every active participant must see it. The author already has the note. A copy back to the author adds traffic and a duplicate that the author must ignore.
Uses definition from: CM-10-004
Redacted Case View
ID Priority Requirement Related
CM-09-001 SHOULD The system SHOULD support a RedactedVulnerabilityCase type for sharing case information with invited-but-not-yet-accepted participants

An invitee has not yet agreed to the embargo. Thus, it must learn only enough about the case to decide whether to join. A redacted view gives it this information and does not disclose case details that it has no obligation to protect yet.
CM-09-002 MUST The ID of a RedactedVulnerabilityCase MUST be cryptographically unrelated to the full VulnerabilityCase ID. The prototype case stub (CM-11-013) is not a RedactedVulnerabilityCase, and this requirement does not apply to it.

Prevents an attacker who obtains a redacted case ID from inferring the full case ID
See also: CM-11-013 — context for the reader
CM-09-003 MUST Each invitee MUST receive a distinct RedactedVulnerabilityCase ID

Prevents cross-correlation of redacted IDs to infer participant list size or identities
Per-Participant Embargo Acceptance
ID Priority Requirement Related
CM-10-001 MUST CaseParticipant MUST record its consent per embargo: one consent row for every entry in the case's embargo register, naming the embargo and the participant's answer to it, UNINVITED until it is asked (CM-18-001). A participant agrees to an embargo explicitly, by an Accept, as its proposer, by seeding (CM-14-003, CM-14-005), or by containment, when the Case Owner activates a revision that ends no later than terms the participant had agreed to (EP-05-001). Each invitation's RSVP deadline is stored on that invitation's INVITED row (CM-28-013). No other record of embargo consent may exist on the participant.

Consent is per embargo (ADR-0093, ADR-0122), so a revision does not inherit an agreement given to an earlier version (CM-18-001). The CM-10-004 content gate reads the rows, so they must name every embargo that binds the participant, including one that containment carries over: an agreement to N days is an agreement to every shorter period, so no explicit Accept is needed for it. A second record of consent beside the rows can disagree with them, and a reader cannot know which is correct.
Uses definition from: CM-18-001
See also: CM-14-003 — context for the reader
See also: CM-14-005 — context for the reader
See also: CM-28-013 — context for the reader
See also: EP-05-001 — context for the reader
CM-10-002 MUST Embargo acceptances MUST be timestamped by the CASE_MANAGER at the time of receipt, not using the participant's claimed timestamp

The CASE_MANAGER applies the only trusted timestamp; the participant's reported time cannot be verified
Refines: CM-02-009
CM-10-004 MUST The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).

Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122).
Uses definition from: CM-14-001
Uses definition from: CM-18-001
Uses definition from: CM-31-001
CM-10-005 MUST NOT This rule covers each Add(CaseLedgerEntry) the CASE_MANAGER sends, as fan-out of a new entry or as a replay answering a Reject(CaseLedgerEntry) (SYNC-03-002). While an embargo is active, the CASE_MANAGER MUST NOT send one to a participant that has not accepted that embargo (the CM-10-004 content gate).

The ledger fan-out is how participants learn every accepted case change, and each entry carries its payload verbatim — an added report or note reaches the recipient whole. Fan-out is therefore "sharing case updates" in CM-10-004's sense. An entry cannot be redacted per recipient without breaking the hash chain. Skipping a single entry does not work either: the replica buffers the next one as a forward gap and Rejects to request the missing entry (SYNC-14-002), so the replay would deliver the withheld content anyway. The gate therefore pauses the participant's whole stream, replay included, rather than filtering entries; the replica stays at the last entry it was sent.
Refines: CM-10-004
Uses definition from: SYNC-03-002
CM-10-008 MUST While an embargo is active, the CASE_MANAGER MUST still deliver an embargo Invite, and its responses, to a participant that has not accepted the embargo. These are embargo meta-protocol activities addressed to the participant directly, not ledger fan-out.

These activities are not ledger fan-out, so the CM-10-005 pause does not cover them. A participant that never receives the embargo Invite cannot accept the embargo, so its paused stream could never resume.
Extends: CM-10-005
CM-10-006 MUST When the CM-10-004 content gate admits a participant whose ledger stream it had paused (CM-10-005) — whenever the active check turns from false to true for that participant, whether because it accepts the active embargo, the embargo ends, or it is reinstated (CM-31-011) — the CASE_MANAGER MUST send that participant every canonical entry it was not sent, in log order starting with the first entry withheld from it, before or together with the entry that records the change admitting it.

A paused participant's replica is a contiguous prefix of the ledger; backfilling the withheld suffix in order restores it to the leader's tip without a gap the catch-up gate (SYNC-10-004) would block on. Ending the embargo lifts the gate for everyone, so a participant that never accepted it is caught up at that point too. The trigger is the active check itself, not any one message (ADR-0116).
Extends: CM-10-005
Uses definition from: CM-10-004
See also: CM-31-011 — context for the reader
Joining a Case — Stub Invite, Inert Participant, Full-Case Invite

How an actor goes from invited to participating: the stub Invite creates an inert participant record, the participant's reply to it decides whether it joins, and a joined participant judges the case by replying to a full-case Invite (ADR-0114, ADR-0121; notes/case-joining.md).

ID Priority Requirement Related
CM-11-001 MUST When a participant accepts the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.

The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this.
Uses definition from: CM-10-001
Extends: BT-10-005
CM-11-002 SHOULD After joining a case, a participant SHOULD judge the case by replying to the full-case Invite (CM-11-010, CM-11-011).

The CASE_MANAGER cannot count a joined participant as engaged until the participant says so (CM-11-004). The other participants plan their work from the list of engaged participants. The participant receives the full-case Invite, examines the case and its history, and then engages or defers. Every replica then records the RM decision of the participant itself, not a decision that the CASE_MANAGER infers from silence.
Uses definition from: CM-11-001
Uses definition from: CM-11-010
See also: CM-11-011 — context for the reader
CM-11-022 SHOULD After it replies to the full-case Invite, a participant SHOULD engage with Join(VulnerabilityCase) (RM.ACCEPTED) or defer with Ignore(VulnerabilityCase) (RM.DEFERRED).

Judging the case says whether the report is valid. It does not say whether the participant will work on the case. Only the participant can make that choice, and Join or Ignore records it, so no replica has to infer it from silence (CM-11-004).
Extends: CM-11-002
CM-11-004 MUST The CASE_MANAGER MUST NOT treat a joined participant as having committed to the case (RM.ACCEPTED) until it receives Join(VulnerabilityCase) from that participant.

Only the participant can say it has chosen to engage. Neither accepting the stub Invite (joining) nor accepting the full-case Invite (RM.VALID) is an engagement decision.
Uses definition from: CM-11-001
CM-11-003 MUST A receiver processing a reply to a stub Invite (Accept or Reject of Invite(VulnerabilityCase preview)[target=Actor]) MUST identify the case from the id of the case reference that is the nested Invite's object; the top-level target of the reply is not populated.

The reply wraps the Invite as its object_, so the case reference is on object_.object, which extract_event maps to inner_object. The reference names the case by the case's own ID (CM-11-013, ADR-0205), and its preview carries no case ID of its own, so no receiver parses one ID out of another.
CM-11-006 MUST When the CASE_MANAGER sends a stub Invite (Invite(VulnerabilityCase preview)[target=Actor]), it MUST create the invitee's CaseParticipant in the same step. The participant is inert (CM-10-004).

The CASE_MANAGER needs to track every invitee from the moment it is invited — whether it has been told and how it answered — including the invitees that decline (ADR-0114).
Uses definition from: CM-10-004
CM-11-026 MUST The CaseParticipant a stub Invite creates MUST hold the Invite's roles, RM RECEIVED, VF v (VENDOR), and an INVITED row for an active embargo.

The invitee has been told of the case and has decided nothing. RM RECEIVED and VF v record exactly that. The INVITED row records that it was asked about the embargo in force and has not answered (CM-18-001).
Extends: CM-11-006
CM-11-023 MUST When it sends a stub Invite, the CASE_MANAGER MUST commit its own add_case_participant_to_case entry, Add(CaseParticipant) with the case as its target and context (CLP-07-021), separate from the Invite's invite_actor_to_case entry.

The ledger holds the wire messages that the actors exchanged, and every state change has a message. The Invite is one message. Creating the invitee's record is the CASE_MANAGER's own act, so it is a second message with its own entry (ADR-0114, ADR-0124).
Extends: CM-11-006
Refines: CLP-07-021
CM-11-024 MUST The add_case_participant_to_case entry MUST carry the whole participant record as stored: its statuses and consent rows, with their ids and times.

A replica copies the record from the entry and derives nothing (CM-11-025, ADR-0124). The entry must therefore carry every field the CASE_MANAGER holds, or the replica's record differs from the CASE_MANAGER's.
Extends: CM-11-023
CM-11-025 MUST A replica MUST store an invitee's record exactly as the add_case_participant_to_case entry carries it, in the case its target names, and derive none of it from the Invite's entry.

Replicas copy; they never mint ids, read clocks or run lifecycle logic (ADR-0124). A record a replica derived could differ from the CASE_MANAGER's in an id or a time, and the copies of the case would then disagree.
Depends on: CM-11-024
CM-11-007 MUST A stub Invite has exactly two valid replies, Accept (CM-11-001) and Reject. On Reject(Invite(VulnerabilityCase preview)[target=Actor]), the CASE_MANAGER MUST close the participant and keep its record, which stays inert. Closing it moves its RM state to RM.CLOSED, sets VF V for a VENDOR, and records consent DECLINED when an embargo is active.

A stub reject is a hard no to joining. Keeping the record keeps the history that the actor was told and declined, which is what the early record exists for.
See also: CM-11-001 — context for the reader
CM-11-027 MUST A replica MUST apply a stub Reject from two entries: the invitee's reject_invite_actor_to_case, which carries the DECLINED row, and the CASE_MANAGER's add_participant_status_to_participant closing status.

The invitee's Reject is a message, so it is its own ledger entry, and it is the entry for the DECLINED row. A replica applies that row through the same write the CASE_MANAGER uses. The closing status is the CASE_MANAGER's own act, with an entry of its own that a replica stores. Each replica then holds the record the CASE_MANAGER holds (ADR-0114, ADR-0124).
Extends: CM-11-007
CM-11-028 MUST The CASE_MANAGER MUST refuse TentativeReject(Invite(VulnerabilityCase preview)[target=Actor]).

Accepting the stub is not a judgement of the case, so there is nothing for a tentative reject to say. Only the full-case Invite asks for a judgement (CM-11-011).
Derives from: CM-11-007
CM-11-008 MUST When the CASE_MANAGER processes Accept(Invite(VulnerabilityCase preview)[target=Actor]) and the participant is active (CM-10-004), it MUST send the participant Announce(VulnerabilityCase) and begin replaying the case ledger to it without waiting for any further signal from the participant.

The participant is entitled to case content from the moment it is active, and the history is part of what it then judges. The Accept is the readiness signal; out-of-order arrival is buffered (SYNC-14, SYNC-15) and a real gap is recovered by Reject(CaseLedgerEntry) and replay.
Uses definition from: CM-10-004
CM-11-009 MUST Any reply from a VENDOR-role invitee to its stub Invite MUST set its VF state to V.

Any reply is evidence the vendor is aware of the case.
CM-11-029 MAY The CASE_MANAGER or the Case Owner MAY set an inert invitee's VF state to V before the invitee replies (PRM-06-003).

The CASE_MANAGER or the Case Owner can learn that a vendor is aware of the case before the vendor answers its stub Invite, for example from a direct contact. Recording that awareness early keeps the VF history correct.
Refines: PRM-06-003
CM-11-010 MUST After CM-11-008, the CASE_MANAGER MUST send the participant the full-case Invite, Invite(whole VulnerabilityCase)[target=Actor], queued after the last replayed ledger entry.

AS2 puts what one is invited to in object, so the Invite carries the whole case it asks the participant to judge (ADR-0205); the participant is active, so it is entitled to it (CM-10-004), and reads the case from its own replica. Delivery to each recipient is ordered (ADR-0112), so queuing the Invite after the replay means it usually arrives once the participant can answer it. The protocol does not rely on that order (ADR-0161): CM-11-033 covers an Invite that arrives first.
Depends on: CM-11-008
CM-11-031 MUST The full-case Invite MUST name the case by ID and carry the log_index and entry_hash of the CASE_MANAGER's ledger tail when it issued the Invite.

The Invite's ledger position is the floor the participant must reach before answering (ADR-0121). It travels as the Invite's ledgerPosition, the property every case activity carries (VAM-04-011, SYNC-18-001, ADR-0156).
Extends: CM-11-010
CM-11-032 MUST A receiver MUST refuse a full-case Invite whose sender is not the CASE_MANAGER on its replica of the case.

Only the case's CASE_MANAGER may ask a participant to judge the case. The receiver judges the Invite only when it holds the replica (CM-11-033), so the replica's CASE_MANAGER is the only record the sender check needs. The stub-Invite trust anchor decides an earlier question: whether the Announce may create that replica (PCR-03-004).
CM-11-033 MUST A receiver MUST NOT judge a full-case Invite for a case it holds no replica of.

The protocol does not rely on delivery order (ADR-0161), so the Invite can arrive before the Announce (CM-11-010). It is case-scoped: the inbox's defer check holds it until the Announce creates the replica, then replays it (HP-01-041). With no trust anchor, no Announce can create the replica (PCR-03-004), so the held Invite expires unprocessed (CBT-03-003) and the receiver fails closed.
Extends: CM-11-032
Depends on: HP-01-041
CM-11-011 MUST The CASE_MANAGER MUST record each full-case Invite reply as a move from RM.RECEIVED: RV Accept to RM.VALID, RI TentativeReject to RM.INVALID, RC Reject to RM.CLOSED.

Each reply is the participant's own judgement of the case (ADR-0121). The three replies map to the three RM triage outcomes, so every replica records the judgement the participant made.
CM-11-034 MUST A reply to the full-case Invite MUST carry the replier's own ledger position: the log_index and entry_hash of its tail when it decided.

The position is the reply's ledgerPosition, the property every case activity carries (VAM-04-012..014, SYNC-18-001, ADR-0156), so the CASE_MANAGER judges it against the Invite's floor (CM-11-012) from the one field it reads on every case activity.
Extends: CM-11-011
CM-11-012 MUST The CASE_MANAGER MUST refuse a full-case Invite reply whose position is behind the Invite's, or names an entry missing from its ledger at that index.

The Invite's position is a floor. A reply behind it was made without seeing what the participant was asked to judge. A reply that names an entry the CASE_MANAGER's ledger does not hold was not made on its ledger.
Supersedes: SYNC-18-004
CM-11-035 MUST The CASE_MANAGER MUST accept a full-case Invite reply whose position is at or beyond the Invite's.

The Invite's position is a floor, not a pin. A reply beyond it is better informed. Pinning the reply to the Invite's position would make every reply on a busy case stale (ADR-0121).
Extends: CM-11-012
CM-11-036 MUST The CASE_MANAGER MUST refuse a full-case Invite reply from a participant that has not joined the case (an inert participant), writing nothing.

Only a joined participant judges the case. An inert participant has not received the case or its history, so it has nothing to judge (CM-10-004).
Extends: CM-11-012
CM-11-013 MUST The stub Invite's object MUST be a typed reference to the case, naming the case by its own id, whose preview is the case's preview, of its own wire type CasePreview.

A receiver classifies an activity by its shape. ADR-0205 retires the stub's own type, its own id and its caseId: the case is named by the reference's own id, the preview has a type of its own, and nothing stands in for the case. The reference carrying a preview and the whole case of the full-case Invite differ in form, so a receiver tells the two Invites apart as received (SE-01-009).
CM-11-038 MUST A receiver MUST classify a case stub by its type, never by which fields it carries or by parsing its ID.

A sparse case and an enriched stub can carry the same fields, so only the type tells them apart. A classifier that read the fields would take a sparse VulnerabilityCase for a stub (ADR-0114).
Depends on: CM-11-013
CM-11-014 MUST A stub Invite MUST carry a reply deadline.

An invitee that never answers must not hold the CASE_MANAGER in an open wait for ever. The deadline tells both sides when the ask ends (ADR-0114).
CM-11-039 MUST When a stub Invite's deadline passes unanswered, the CASE_MANAGER MUST close the Invite as an expired ask.

An expired ask is over. Closing it ends the CASE_MANAGER's wait for an answer, so the case does not wait on an invitee that never replies (ADR-0114).
Extends: CM-11-014
CM-11-040 MUST NOT When a stub Invite expires unanswered, the CASE_MANAGER MUST NOT change the invitee's record, which stays inert at RM.RECEIVED with its consent row INVITED.

RM is the participant's own judgement (ADR-0121), so a timeout cannot stand in for one. The CM-18-002 time-out to TIMED_OUT applies to an Invite(EmbargoEvent), not to the embargo terms a stub Invite carries, so the consent row stays INVITED.
Extends: CM-11-039
CM-11-041 MUST A case-wide closure check ("all participants closed") MUST count only joined participants: those seated by case initialization (CM-14-001) or that accepted their stub Invite.

An invitee that never answered must not keep the case from closing (ADR-0114). An invitee that has not joined has made no judgement, so it has nothing to close.
Uses definition from: CM-10-004
Uses definition from: CM-14-001
CM-11-015 MUST When the CASE_MANAGER re-invites an unanswered or expired invitee, it MUST send a fresh stub Invite on the same record, with a new deadline.

One actor has one participant record per case. A fresh stub Invite with a new deadline gives the invitee a live ask, and keeps the record that already holds its history.
CM-11-042 MUST A re-invite's inReplyTo MUST be the id of the invitee's earlier stub Invite.

Naming the earlier stub in the standard AS2 inReplyTo property leaves the invitee one live stub. CM-11-045 then refuses an Accept of the earlier one, naming the fresh one.
Extends: CM-11-015
CM-11-043 MUST The CASE_MANAGER MUST refuse, before committing any ledger entry, every stub Invite to a participant that has joined or is at RM.CLOSED.

One actor has one participant record per case. RM.CLOSED is terminal with no rejoin path, and a stub reject is a closure (CM-11-007). The refusal comes before the commit, so a refused Invite leaves no ledger entry (ADR-0085).
Extends: CM-11-015
CM-11-016 MUST This rule covers a stub Invite still outstanding when the active embargo is activated, revised or terminated. The CASE_MANAGER MUST re-issue that stub Invite on the same participant record, with the embargo terms that now apply and a new deadline.

Accepting a stub consents to the terms it carried. Accepting stale terms would make the participant join already lapsed, or join without consent, and need a second answer at once.
CM-11-044 MUST A replacement stub Invite MUST name the Invite it supersedes by setting its inReplyTo to that Invite's id.

Naming the superseded Invite tells the invitee the old one is dead in whichever order the two arrive. A retraction (Undo) was considered and rejected (ADR-0114).
Extends: CM-11-016
CM-11-045 MUST The CASE_MANAGER MUST refuse an Accept of a superseded stub Invite, naming the replacement in the refusal.

An Accept of a superseded Invite consents to terms that are no longer in force. Naming the replacement tells the invitee which Invite it can accept.
Extends: CM-11-016
CM-11-046 MUST The CASE_MANAGER MUST honour a Reject of a superseded stub Invite.

Declining to join does not depend on the terms, so a Reject of any version of the ask is a hard no.
Extends: CM-11-016
CM-11-017 MUST The CASE_MANAGER MUST refuse a stub-Invite reply, and create or change no participant, unless the sender is the invitee its own recorded stub Invite names.

If the CASE_MANAGER trusts an Accept by itself, any actor can admit itself or a third party. That actor then receives the case and its full ledger. The recorded stub Invite is the CASE_MANAGER's own record of whom it invited (CM-11-006). Thus, it is the only source against which the CASE_MANAGER can check a reply (HP-01-006, ADR-0115).
Refines: HP-01-006
Constrains: CM-11-001
CM-11-047 MUST The CASE_MANAGER MUST take a stub invitee's roles from the stub Invite it recorded, never from the copy of the Invite embedded in the reply.

The embedded copy is the sender's claim. If the CASE_MANAGER read the roles from it, an invitee could give itself any role by editing its copy. The recorded Invite holds the roles the CASE_MANAGER chose (CM-11-006, ADR-0115).
Extends: CM-11-017
CM-11-018 MUST When the CASE_MANAGER receives Reject(Invite(VulnerabilityCase preview)[target=Actor]) for an invitee with no participant record, it MUST refuse it with a reported reason, not as a silent no-op.

The participant record created at invite-send time (CM-11-006) is the evidence that the CASE_MANAGER sent the stub Invite. A Reject with no matching record is either a protocol violation (the CASE_MANAGER never sent the Invite) or a replay of a Reject already processed to RM.CLOSED; both cases are erroneous and must be reported, not silently accepted. Accepting them would hide inconsistencies in the CASE_MANAGER's own audit trail.
Supersedes: CM-11-007
CM-11-021 MUST When the CASE_MANAGER receives Accept(Invite(VulnerabilityCase preview)[target=Actor]) and holds no participant record for the invitee, it MUST refuse the Accept with a reported reason.

The CASE_MANAGER creates the participant record when it sends the stub Invite (CM-11-006). That record is the evidence that the CASE_MANAGER sent the Invite. CM-11-017 ties every reply to a recorded Invite. If an Accept rebuilt a missing record, it would admit an actor whose Invite the CASE_MANAGER's roster does not show, and it would skip that check. This rule is the Accept counterpart of CM-11-018.
Refines: CM-11-017
Supersedes: CM-11-001
CM-11-052 MUST NOT The CASE_MANAGER MUST NOT create a participant record, commit a ledger entry or send any activity for a stub-Invite Accept it refuses under CM-11-021.

An Accept never creates a participant: the record exists from the stub Invite (CM-11-006). A refused Accept that still wrote a record, an entry or a message would admit the actor in part.
Extends: CM-11-021
CM-11-019 MUST A stub Invite MUST carry at least one CVD role for the invitee.

A participant with no roles cannot be routed to the right recipients or granted the right access.
CM-11-048 MUST The CASE_MANAGER MUST refuse to emit a stub Invite with an empty role list.

Refusing at send time catches missing roles before the Invite is delivered, keeping the error close to its source.
Implements: CM-11-019
CM-11-049 MUST NOT The CASE_MANAGER MUST NOT create a participant record with an empty case_roles list.

A participant record with no roles could not be routed or granted access. Refusing the record keeps every participant in the roster routable.
Extends: CM-11-019
CM-11-050 MUST NOT When an inviter, the Case Owner included, names no roles for a stub Invite, the CASE_MANAGER MUST NOT substitute a default role such as VENDOR.

Defaulting to VENDOR would silently assign a role the inviter never requested, violating the inviter's intent. In the Case Owner's own stub Invite the owner names the roles, so no role is guessed.
Extends: CM-11-019
CM-11-020 MUST NOT A participant that joined a case through an Invite MUST NOT send Accept, TentativeReject or Reject of the original Offer(VulnerabilityReport).

A reply must answer a message sent to the replier. A joined participant was never offered that report.
CM-11-051 MUST NOT A participant that joined a case through an Invite MUST NOT validate, invalidate or reject the case's report. It judges the case by replying to the full-case Invite (CM-11-011).

A joined participant — a late joiner especially — judges the case as it stands, with its history, not the original submission, which may have been far sparser (ADR-0121).
Extends: CM-11-020
See also: CM-11-011 — context for the reader
Case Creation Timing
ID Priority Requirement Related
CM-12-002 MUST At case creation, the system MUST create two initial CaseParticipant records in the order defined by CM-14-001

At receipt, the case knows two parties: the Case Owner and the reporter. Each party needs its own RM state (CM-01-002). Thus each party needs a record before the case records anything else about it. The CM-14-001 order makes sure that an existing participant creates the embargo, and that the reporter has the case before any entry about the case arrives.
Uses definition from: CM-14-001
CM-12-004 MUST A default embargo MUST be initialized at case creation (RM.RECEIVED) following the sequence in CM-14-001 whenever the case is embargo-eligible — from the receiver's actor default where one is configured, and otherwise from the protocol default of EP-04-005

If a case has no embargo, the reporter's information has no protection when another party joins. The receiver initializes the default embargo at RM.RECEIVED, before it adds any other participant. Thus every later participant joins under the embargo (CM-14-010). The protocol default makes sure that a receiver with no configured policy also gets an embargo with a limit (EP-04-019, ADR-0096).
Refines: DUR-07-002 — which now applies at case receipt
Uses definition from: CM-14-001
Depends on: EP-04-005
Embargo Acceptance Ownership
ID Priority Requirement Related
CM-13-005 MUST A repeated embargo answer is a second Accept, or a second Reject, of one embargo invitation by the same participant, whatever its activity id. The receiver of a repeated answer MUST change no state, add no ledger entry and send no message because of it. Answers from different participants are separate consents.

Delivery is at least once. A participant can send the same answer again under a new activity id. If a repeat counted, the receiver would add a ledger entry and a fan-out for a consent that did not change. Every replica would then record an answer that was not a new decision. Each participant gives consent for itself. Thus the answer of one participant is never a repeat of the answer of a different participant.
Case Initialization Sequence

Defines the canonical ordered sequence of initialization steps that MUST occur when a VulnerabilityCase is created at Offer(VulnerabilityReport) receipt (CM-12-001). All steps MUST complete before the case is considered fully initialized.

ID Priority Requirement Related
CM-14-001 MUST The case initialization sequence MUST execute exactly 6 ordered steps (CM-14-008 through CM-14-013) before the case is considered fully initialized. No step may be omitted or reordered.

Step CM-14-009 precedes CM-14-010 so that the embargo is always created by a participant (the Case Owner). The Create(VulnerabilityCase) notification in CM-14-011 is flushed before the reporter is added in CM-14-012 so each recipient of that Create holds the case object before any subsequent Add(CaseLedgerEntry) fan-out that references it.
CM-14-002 MUST The Case Owner's CaseParticipant MUST be created before the default embargo is initialized, so that the embargo is always associated with an existing participant

An embargo without any participant lacks an owning actor. Creating the owner participant first ensures that the embargo is initialized in the context of an actor who can be responsible for it.
Derives from: CM-14-001
CM-14-003 MUST When the case initialization sequence creates a default embargo, the Case Owner MUST be seeded as a signatory on that embargo immediately after the embargo reaches EM.ACTIVE state

The Case Owner initiated the embargo by accepting the default policy on behalf of the case. Requiring a separate accept step would leave the Case Owner as a non-signatory on their own active embargo.
Uses definition from: CM-14-001
Refines: CM-13-006
Refines: CM-18-007
CM-14-004 MUST The Create(VulnerabilityCase) notification MUST be queued and the outbox flushed before the reporter is added as a CaseParticipant in step 5 of CM-14-001

The reporter's system must receive and store the case object before any Add(CaseLedgerEntry) fan-out that lists them as a participant. Reversing this order causes "case not found" errors on the reporter side when the log entry arrives referencing a case the reporter has not yet seen.
Derives from: CM-14-001
Uses definition from: CBT-01-001
CM-14-005 MUST When the reporter is added as a CaseParticipant during case initialization, they MUST be seeded as a signatory on any active embargo

The reporter already possesses the vulnerability information before the case is created. Requiring an explicit embargo acceptance before sharing case content would create a paradoxical deadlock: the reporter has the information that the embargo is meant to protect, yet cannot receive case updates until they accept the embargo. Seeding them as signatory reflects their implicit consent, expressed by submitting the report.
Uses definition from: CM-14-001
CM-14-007 MUST NOT An actor MUST NOT invite an additional participant to a case until the case's initialization sequence (CM-14-001), with any applicable conditional steps, is complete.

The initialization sequence establishes the minimum valid case state: a case object, an owner, an optional embargo and a reporter. An Invite to a third party before this baseline is in place causes race conditions and protocol violations.
Uses definition from: CM-14-001
CM-14-014 MUST NOT An actor MUST NOT initiate an embargo modification on a case until the case's initialization sequence (CM-14-001), with any applicable conditional steps, is complete.

The initialization sequence establishes the embargo that later changes modify. A modification before this baseline is in place causes race conditions and protocol violations.
Extends: CM-14-007
Uses definition from: CM-14-001
CM-14-008 MUST Step 1 of the case initialization sequence MUST create the VulnerabilityCase with the receiving actor set as attributed_to.

Creating the case object first establishes the anchor to which all subsequent initialization steps (participants, embargo, ledger) are attached.
Part of: CM-14-001
CM-14-009 MUST Step 2 of the case initialization sequence MUST create the Case Owner's CaseParticipant with RM.RECEIVED and the CASE_OWNER role.

The Case Owner's participant must exist before the default embargo can be initialized, so that the embargo is always associated with an existing participant.
Part of: CM-14-001
CM-14-010 MUST Step 3 of the case initialization sequence MUST initialize the default embargo to EM.ACTIVE and seed the Case Owner as a signatory whenever the case is embargo-eligible, using the actor default where one is configured and the EP-04-005 protocol default otherwise.

The embargo must be in place before any participant other than the Case Owner is added, so that all subsequent participants are subject to the embargo from the moment they join.
Part of: CM-14-001
Depends on: EP-04-005
CM-14-011 MUST Step 4 of the case initialization sequence MUST queue a Create(VulnerabilityCase) activity and flush the outbox. When the CASE_MANAGER is the report receiver, the activity goes to the reporter (CBT-01-001). Otherwise it goes to the report receiver, the CASE_OWNER, only (CM-22-006, CBT-01-010).

Each recipient must hold the case object before any Add(CaseLedgerEntry) fan-out that references it. The reporter trusts only the actor it sent its report to, so the case reaches it from that actor: directly when that actor is the CASE_MANAGER, and through the report receiver's introduction when it is not (ADR-0132).
Part of: CM-14-001
Uses definition from: CBT-01-001
Uses definition from: CBT-01-010
Uses definition from: CM-22-006
CM-14-012 MUST Step 5 of the case initialization sequence MUST add the reporter as a CaseParticipant with RM.ACCEPTED and the REPORTER role, and seed them as a signatory on any active embargo.

The reporter is added after the Create(VulnerabilityCase) notification is flushed (CM-14-011) so that the case object is on its way to the reporter, directly or through the report receiver's introduction, before the fan-out of the ledger entry that records their participation.
Part of: CM-14-001
CM-14-013 MUST Step 6 of the case initialization sequence MUST commit a case ledger entry, triggering Add(CaseLedgerEntry) fan-out to all participants.

The ledger entry commits the completed initialization as a single protocol-significant event and notifies all participants atomically.
Part of: CM-14-001
Actor Suggestion Routing (Recommend-Actor Flow)
ID Priority Requirement Related
CM-16-001 MUST A participant wishing to suggest that another actor be invited to the case MUST send Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER's inbox, not directly to the Case Owner's inbox.

All case-scoped protocol messages MUST route through the CASE_MANAGER so the event can be recorded in the canonical case ledger before any downstream action is taken (ADR-0021, PCR-08-001).
Refines: PCR-08-001
CM-16-002 MUST When the CASE_MANAGER receives Offer(Actor)[target=VulnerabilityCase], it MUST commit a CaseLedgerEntry for the received Offer and fan out the entry to every active participant (CM-10-004) BEFORE taking any downstream action.

Ledger entries record events that have already occurred; pre-committing a decision before communicating it is not permitted (CLP-10-006 commit ordering).
Refines: CLP-10-006
Uses definition from: CM-10-004
CM-16-004 MUST The CASE_MANAGER MUST transform the received Offer(Actor) into Offer(CaseParticipant)[target=VulnerabilityCase], whose CaseParticipant has attributed_to set to the actor and case_roles set to the roles, and send it to the Case Owner's inbox, with inReplyTo set to the ID of the original recommender's Offer activity and no origin.

The Case Owner makes a membership decision about a CaseParticipant (actor + roles), not about a bare Actor identity. The forward answers the recommender's Offer, and AS2 inReplyTo names the entities an object responds to, so it preserves the causal chain without a side-channel data store. origin names where an object comes from or leaves, so it is not the link to an answered activity.
CM-16-005 MAY The recommender's Offer(Actor) MAY include a content or summary field that explains why it suggests the actor.

The recommender often knows why the actor belongs in the case, for example that it maintains the affected code. A short reason gives the Case Owner that knowledge. The field is optional, because the actor's identity can be reason enough.
CM-16-020 SHOULD The CASE_MANAGER SHOULD forward the reason text of a recommender's Offer(Actor) as the content of the transformed Offer(CaseParticipant) it sends to the Case Owner.

The Case Owner decides about the recommendation. The recommender's reason is the main evidence that the Case Owner has. If the CASE_MANAGER removed that text when it transforms the Offer, the Case Owner would decide without it.
Extends: CM-16-005
CM-16-006 MUST After it receives Accept(Offer(CaseParticipant)) from the Case Owner, the CASE_MANAGER MUST take four steps. (1) It commits a ledger entry for the Accept. (2) It fans out the ledger entry. (3) It sends the original recommender an Accept of its Offer(Actor)[target=VulnerabilityCase], with in_reply_to set to that Offer's ID. (4) It sends the suggested actor the stub Invite (Invite(VulnerabilityCase preview)[target=Actor], CM-11-013) per CM-17.

The ledger records the Case Owner's decision before any step acts on it (CLP-10-006). Thus every replica sees the cause before its effects. The recommender waits for an answer to its Offer, and in_reply_to tells it which suggestion the answer closes.
Uses definition from: CM-17-001
See also: CM-11-013 — context for the reader
CM-16-021 MUST When the suggested actor has joined or is at RM.CLOSED, the CASE_MANAGER MUST refuse the Accept(Offer(CaseParticipant)) before committing or sending anything, with a reported reason.

The CASE_MANAGER refuses an Accept for an actor that joined or is at RM.CLOSED. This keeps one participant record for each actor, and keeps RM.CLOSED terminal (CM-11-043). The refusal comes first, so nothing of the Accept is recorded or sent.
Supersedes: CM-16-006
CM-16-007 MUST After receiving Reject(Offer(CaseParticipant)) from the Case Owner, the CASE_MANAGER MUST (1) commit a ledger entry for the Reject, (2) fan out the ledger entry, and (3) send a Reject of the recommender's Offer(Actor)[target=VulnerabilityCase] to the original recommender with in_reply_to set to the ID of the original recommender's Offer activity.

The ledger records the Case Owner's refusal. Thus every replica knows that the suggestion is closed. The recommender waits for an answer to its Offer. The Reject tells the recommender which of its suggestions the Case Owner declined. Without the answer, the recommender cannot tell a refusal from a decision that is not made yet.
CM-16-008 MUST When a second Offer(Actor)[target=VulnerabilityCase] for Actor X arrives while a pending decision for Actor X is still outstanding (no Accept or Reject yet received from the Case Owner), the CASE_MANAGER MUST record the duplicate recommendation in the ledger.

A second suggestion for the same actor is a case event, so the ledger records it. The Case Owner can use it as evidence for the pending decision (CM-16-016). The CASE_MANAGER records it but does not forward a second Offer. This keeps one pending decision for each actor (CM-16-017).
CM-16-009 MUST This rule covers a second Offer(Actor)[target=VulnerabilityCase] for Actor X after an Invite went to X, so the Invite is in flight or X participates. The CASE_MANAGER MUST commit the recommendation's ledger entry, fan it out, and auto-send the second recommender an Accept of its Offer, with in_reply_to naming it.

When the CASE_MANAGER has invited Actor X, the goal of the second recommender is complete. Thus the second recommender gets the answer that it would get after the Case Owner accepted.
CM-16-022 MUST NOT When a second Offer(Actor)[target=VulnerabilityCase] for Actor X arrives after an Invite went to Actor X, the CASE_MANAGER MUST NOT send Actor X a duplicate Invite.

A second Invite would create a second open stub for the same participant record, or the receiver would refuse it (CM-11-043). In both cases, nothing changes for X.
Extends: CM-16-009
CM-16-010 MUST In every step of the actor suggestion flow, the CASE_MANAGER MUST commit the ledger entry for a protocol event AFTER the corresponding message has been sent or received, never before.

Pre-announcing a decision in the ledger before communicating the decision creates a window where the ledger shows an effect without its cause. A sent message is sent once it is in the CASE_MANAGER's outbox (SYNC-09-002).
CM-16-016 MUST When a second Offer(Actor)[target=VulnerabilityCase] for Actor X arrives while a pending decision for Actor X is still outstanding, the CASE_MANAGER MUST record a Note for the Case Owner indicating that a reinforcing suggestion was received, including the Case Owner's identity, the second recommender's identity and any content from the Offer. The note is the CASE_MANAGER's own add_note_to_case entry, attached to the case, and reaches the Case Owner's inbox as that entry's Add(CaseLedgerEntry) (SYNC-02-001, SYNC-02-003); a direct Add(Note) to the Case Owner is refused there (HP-01-005).

A note about reinforcing suggestions gives the Case Owner more context for the pending decision, without a second offer workflow (CM-16-017). Participants send messages only to the CASE_MANAGER, and the Case Owner refuses a direct Add(Note) (HP-01-005). Thus the note goes as a ledger entry. Every active participant sees it, because the protocol has no private channel to the Case Owner.
See also: HP-01-005 — context for the reader
See also: SYNC-02-001 — context for the reader
See also: SYNC-02-003 — context for the reader
CM-16-017 MUST NOT When a second Offer(Actor)[target=VulnerabilityCase] for Actor X arrives while a pending decision for Actor X is still outstanding, the CASE_MANAGER MUST NOT send a second transformed Offer(CaseParticipant) to the Case Owner.

Sending a duplicate transformed Offer would create a second pending decision for the same actor, leading to conflicting state if the Case Owner responds to both.
CM-16-018 MUST When the CASE_MANAGER processes Accept(Offer(CaseParticipant)) from the Case Owner, the roles assigned to the new participant MUST be read from the stored outgoing Offer(CaseParticipant) that the CASE_MANAGER constructed and sent — not from the embedded CaseParticipant object inside the received Accept.

The received Accept is untrusted: the accepting actor may have modified or omitted roles, or sent only a bare ID reference. Reading roles from the received Accept would allow a malicious or minimally-conformant acceptor to substitute unauthorized roles. The stored Offer is the CASE_MANAGER's own record of the intended participant roles and is the authoritative source of truth.
Constrains: CM-16-006
CM-16-019 MUST The CASE_MANAGER MUST refuse Accept(Offer(CaseParticipant)) or Reject(Offer(CaseParticipant)) from any sender but the case's Case Owner, and then invite no one and notify no recommender.

The Case Owner decides about a recommendation (CM-16-006). If any sender could answer it, any actor that knows a recommendation id could accept it, and the CASE_MANAGER would invite whoever that actor chose (HP-01-006).
Refines: HP-01-006
Constrains: CM-16-006
CM-16-023 MUST The CASE_MANAGER MUST take the actor to invite from the Offer(CaseParticipant) it recorded, never from the Case Owner's reply.

The reply carries a copy of the Offer, and the copy is the sender's claim. Assume that the CASE_MANAGER checked only that the recommendation is recorded, and read the invitee from the reply. Then the reply could choose the invitee. The recorded Offer is the CASE_MANAGER's own record (CM-16-018).
Extends: CM-16-019
Invitation Flow — Enrichment and Roles
ID Priority Requirement Related
CM-17-001 MUST The stub Invite sent by the CASE_MANAGER to a new actor MUST be Invite(VulnerabilityCase preview)[target=Actor], with the stub shaped as CM-11-013 requires. This requirement is extended by CM-17-002 and CM-17-003.

An AS2 Invite names what one is invited to as its object, and the invited party as its target (ADR-0205). When the object carries only the case's preview, no case content goes to an invitee that is not yet entitled to it (CM-10-004, CM-17-022). The object's form lets a receiver tell this Invite from the full-case Invite (CM-11-013).
Uses definition from: CM-11-013
CM-17-002 MUST This rule covers a stub Invite sent while an embargo is in force. Then EM is ACTIVE or REVISE, and the case's embargo register holds an ACTIVE entry. Its case stub MUST carry the active embargo (activeEmbargo), inline or by an ID that the invitee can ask the inviter to resolve.

The invite-accept cycle is the only consent signal for a late joiner. An Accept without the embargo terms is not informed consent (CM-11-001). The invitee has only the invitation, so the invitation must let it learn the terms before it accepts: inline in the stub, or by the ID that the stub names. CM-17-011 says which form this prototype sends. In EM REVISE, the prior embargo stays in force (EP-05-002), so the invitee needs its terms then too.
Extends: CM-17-001
Derives from: CM-11-001
CM-17-013 MUST When an embargo is in force as the CASE_MANAGER sends a stub Invite, the case stub MUST carry the case's EM state (caseStatus.emState).

The EM state tells the invitee whether a revision of the embargo is open. In EM REVISE, the invitee learns from it that a proposal is pending, which it receives after it joins (EP-09-011). The caseStatus is a CaseStatus, so it also carries the published time every status carries (CLP-15-010).
Extends: CM-17-002
CM-17-014 MUST NOT A case stub MUST NOT carry an open embargo revision proposal. The invitee learns of the proposal from caseStatus.emState and receives it after joining (EP-09-011).

The revision is not yet binding, and CM-17-022 keeps other case content out of the stub. When the joiner holds the case, EP-09-011 relays to it each open proposal that it has not answered.
Extends: CM-17-002
See also: EP-09-011 — context for the reader
CM-17-004 MUST When the CASE_MANAGER receives Accept(Invite(VulnerabilityCase preview)[target=Actor]) from an invitee, it MUST, in this order: (1) commit a ledger entry for the Accept and fan it out to every active participant (CM-10-004); (2) record the Accept's effect on the participant (CM-11-001); (3) when the participant is now active, send it Announce(VulnerabilityCase) and replay all prior CaseLedgerEntry records to it in log-index order (CM-11-008); and (4) send it the full-case Invite (CM-11-010).

Each step needs the step before it. The ledger records the Accept before any step acts on it (CLP-10-006). The participant's record must show that it joined before the participant is active and entitled to content (CM-10-004). The participant must hold the case and its history before it can make a decision about the case. Delivery to each recipient is in order (ADR-0112). Thus the full-case Invite, which the CASE_MANAGER queues last, arrives when the participant can answer it (CM-11-010).
Uses definition from: CM-11-001
Uses definition from: CM-11-008
Uses definition from: CM-11-010
Uses definition from: CM-10-004
CM-17-005 MUST NOT Presence in the case participant list MUST NOT be treated as acceptance of the invitation or as entitlement to case content. An invitee is in the list from the stub Invite onward (CM-11-006); only an active participant (CM-10-004) is entitled to case content.

The CASE_MANAGER tracks every invitee from the moment it is invited, including one that declines, so the participant list holds inert participants. Any consumer that reads membership as "accepted" would hand case content to an actor that has not consented.
Uses definition from: CM-10-004
See also: CM-11-006 — context for the reader
CM-17-009 MUST Any canonical CaseLedgerEntry the CASE_MANAGER commits while processing a stub Invite's Accept whose fan-out reaches the joining participant — every entry committed once that participant is active (CM-10-004) — MUST be committed after CM-17-004 step (3), the Announce(VulnerabilityCase) and the start of the ledger replay, so the participant's first ledger entries arrive after its case seed and in log-index order.

CM-17-004 puts the announce and the replay in order, with no fan-out to the joiner between them. But an entry committed during the same admission can have a fan-out that includes the new active participant. That entry would then get to the participant before its case. A replica that receives a ledger entry before its case cannot anchor the entry. It rejects the entry and asks for a replay from genesis, and that replay can mix with the backfill (SYNC-15). When the CASE_MANAGER commits the entry last, the entry gets to the invitee as the next entry in chain order.
Extends: CM-17-004
Uses definition from: CM-10-004
CM-17-010 MUST A sender's case preview (CasePreview) MUST carry exactly id, type, a non-empty summary (MV-10-001) and, with an embargo in force, the CM-17-002 embargo terms. The JSON-LD @context is not content.

An invitee is not yet entitled to case content (CM-10-004, CM-17-005). For informed consent, the invitee needs the case's identity, a summary that a person can read of what it is asked to join, and the embargo terms (CM-17-002). The case's identity is the id of the case reference the stub is the preview of (CM-11-013, ADR-0205), so the stub names no case of its own.
Uses definition from: CM-11-013
Refines: MV-10-001
Uses definition from: CM-17-002
CM-17-020 MAY The sender chooses the stub's summary, which MAY be the case name or a deliberately less revealing string.

The case name can be an opsec risk. Thus the sender writes the summary for the invitee, and does not have to copy it from the case.
Uses definition from: CM-17-010
CM-17-021 MUST NOT The sender MUST NOT assume the case name is safe to share with an invitee not yet bound by the embargo.

The case name can reveal what the embargo protects. An invitee that has not joined has not agreed to the embargo, so the sender decides what the stub's summary reveals to it.
Extends: CM-17-020
CM-17-022 MUST NOT A sender MUST NOT put any other case content in a case stub.

An invitee is not yet entitled to case content (CM-10-004, CM-17-005). This constrains what is sent.
Derives from: CM-17-010
CM-17-023 MUST NOT A sender MUST NOT name the case's coordinator or Case Owner in a case stub.

The Invite that carries the stub already identifies the inviter in its actor and attributedTo. If the stub named the coordinator or the Case Owner, it would repeat what the Invite states.
Derives from: CM-17-010
Participant Embargo Consent (per-embargo rows)
ID Priority Requirement Related
CM-18-001 MUST Each participant record MUST hold one embargo consent row for every entry in the case's embargo register. Each row holds one of five states. The UNINVITED state means not asked, and is the start state. The INVITED state means asked, with no answer yet. The AGREED state records agreement, and DECLINED records an explicit refusal or a withdrawal. The TIMED_OUT state means invited, with the RSVP deadline passed and no answer. A participant is a signatory when its row for the register's ACTIVE entry is AGREED. A participant has lapsed when three things hold. An entry is ACTIVE, and the participant's row for it is neither AGREED nor DECLINED. Following replaces back from the ACTIVE entry, the first entry whose row is AGREED or DECLINED has an AGREED row. Both positions are read from the rows and the register, never stored (CM-18-016). With no ACTIVE entry, nobody is a signatory and nobody has lapsed.

One row for each pair of participant and embargo records each answer one time. To find if a participant is bound by the active embargo, a reader looks at the row for the active embargo. Thus there is no second record to reconcile, and a first proposal and a revision use the same rules (ADR-0122). TIMED_OUT is different from DECLINED, so that every reader can tell silence from a refusal (ADR-0118). A terminated embargo is a fact of the register, not a fact about each participant. A lapse follows the replaces chain. Thus only an embargo that was in force can bind, and a withdrawal from a later embargo ends the binding of an earlier embargo.
CM-18-019 MUST Proposing an embargo MUST write an UNINVITED consent row for it on every current participant.

A participant that was not asked holds a row that says so. Thus no reader infers "not asked" from a missing record, and a check can use the register to find a row for each participant and each embargo (CM-18-001).
Implements: CM-18-001
CM-18-020 MUST Creating a participant record MUST write an UNINVITED consent row on it for every entry already in the case's embargo register.

A participant that joins after embargoes were proposed was asked about none of them. A row for each entry records that, so the participant holds a row for every entry from its creation on (CM-18-001), and no reader meets a missing row.
Implements: CM-18-001
CM-18-021 MUST NOT A reader MUST NOT read a missing consent row as any consent state. A missing row is a defect.

Every row is written (CM-18-019, CM-18-020), so a missing row comes only from a fault. A reader that treated it as UNINVITED, or as any other state, would hide the fault, and could count a participant as asked, bound or free when it is not.
Extends: CM-18-001
CM-18-002 MUST When an invitation's RSVP deadline passes with no answer, the CASE_MANAGER MUST apply the TIME_OUT trigger to that invitation's row only, recording TIMED_OUT, never DECLINED. A lapse has no timer and is not a stored transition (CM-18-001, CM-18-016). A lapsed participant's deadline is the one on its re-invitation to the embargo in force (CM-28-013).

Per ADR-0093, ADR-0122 and notes/participant-embargo-consent.md, a participant has lapsed when the active embargo was replaced by longer terms it has not accepted. While a revision is only proposed, the prior embargo is still in force and binds every signatory, so nothing about their consent has changed. Per ADR-0118, a participant that did not answer has made no decision. Thus a timeout records TIMED_OUT, distinct from an explicit DECLINED, and both are re-invitable. Nothing stalls on a lapsed participant: the CM-10-004 gate already excludes it from embargoed content, and no invitation gives it a deadline. An RSVP deadline belongs to one invitation and is stored on that invitation's INVITED row (CM-28-013). Its passing times out only that row, never the participant's other invitations. Code, logs, demos and replicas read the consent row, not ledger provenance (ADR-0118), so the row itself carries the distinction. A late Accept the CASE_MANAGER honours returns a TIMED_OUT row to AGREED, a signatory only if that embargo is in force (EMB-17-002, MSM-07-003). ADR-0118 reverses ADR-0065's choice to record a lapsed invitation as DECLINED.
Uses definition from: CM-18-001
Uses definition from: CM-18-003
Refines: CM-28-005
See also: CM-18-016 — context for the reader
See also: CM-28-013 — context for the reader
CM-18-022 MAY A timer expiry (pocket veto) MAY drive a row's INVITED → TIMED_OUT transition, with no explicit participant action.

A pocket veto exists so that an unanswered invitation cannot stall coordination. A participant that does not answer has made no decision, so the transition needs no act from it (ADR-0118).
Refines: CM-18-002
CM-18-023 SHOULD The pocket-veto timer period SHOULD be a policy window of 7 days.

An Invite that names no deadline still needs one, or an unanswered invitation can stall coordination. A fixed default window gives every such invitation the same deadline, so every participant can predict when silence becomes TIMED_OUT.
Extends: CM-18-022
CM-18-003 MUST The consent row machine MUST implement exactly the following valid triggers, each applied to the row for one embargo: INVITE (from UNINVITED, DECLINED or TIMED_OUT, to INVITED), AGREE (from UNINVITED, INVITED, DECLINED or TIMED_OUT, to AGREED), DECLINE (from UNINVITED, INVITED, AGREED or TIMED_OUT, to DECLINED), TIME_OUT (from INVITED only, to TIMED_OUT) and CARRY_OVER (from every state except AGREED, to AGREED). No other trigger is valid from any state, and a row for an entry in a final register status (SUPERSEDED, REJECTED, CANCELLED, TERMINATED) accepts no trigger at all.

DECLINED and TIMED_OUT are not terminal. The CASE_MANAGER can invite again a participant that declined or that let an invitation time out, for example when the embargo terms change. AGREED does not accept a new invitation, so a second request does not cancel a consent that the participant gave. AGREE is valid from DECLINED, because an Accept after a decline is a change of answer by the participant. The participant has just said that it accepts. Thus its row moves directly, with no re-invite step. Only the participant's own answer moves a DECLINED row in this way. Seeding (CM-14-003, CM-14-005) and the Accept of the full-case Invite never cancel a decline. Per ADR-0048, AGREE and DECLINE are valid directly from UNINVITED, because consent does not always come through an invitation. A Finder who sets the embargo on its own case has no inviter. Participants added during case initialization already have an embargo in scope (ADR-0041). The reporter gives its consent when it submits the report (CM-14-005). A required synthetic INVITED step for these paths would record an invitation that did not occur. Per ADR-0093, DECLINE is also valid from AGREED. A participant bound by an embargo MAY withdraw its consent when it rejects the active embargo (VP-13-007, VP-13-008). A rejection of a proposed embargo declines only the row for that embargo. It does not change the participant's row for the embargo in force (MSM-07-004). Per ADR-0118, TIME_OUT is only the timer path (CM-18-002). A late Accept that the CASE_MANAGER honours moves TIMED_OUT → AGREED directly (EMB-17-002), and a late explicit Reject moves TIMED_OUT → DECLINED. Only the activation of a revision that ends at or before the end of the embargo it replaces causes CARRY_OVER (EP-05-003). CARRY_OVER also lifts a DECLINED row. An agreement to N days is an agreement to every shorter period. A decline of a shorter revision objects to the loss of time, not to the embargo. A row whose embargo is final records the past. Thus a participant cannot give more consent to it. The CASE_MANAGER answers a late Accept of such terms with an invitation to the case's current terms, which are the Active Embargo or, with none in force, the earliest-expiring open proposal (EMB-17-003, EP-08-002). A lapse and a termination are not triggers. They are derived (CM-18-001, CM-18-016).
Uses definition from: CM-18-001
CM-18-004 MUST NOT A participant's consent row MUST NOT move from AGREED to INVITED directly. The only paths back to INVITED from a resolved row are DECLINED → INVITED (re-invite after explicit decline) and TIMED_OUT → INVITED (re-invite after an unanswered invitation timed out); a participant that has lapsed is re-invited on its row for the new embargo (an INVITED row for it), which leaves its AGREED row for the old embargo alone.

Consent already given cannot be withdrawn by re-inviting the participant. A signatory to the active embargo is bound by it; only replacing that embargo with longer terms (which lapses the participant by derivation — ADR-0093, ADR-0122) or the participant's own withdrawal (DECLINE) ends that position.
Derives from: CM-18-003
Coordinator-as-Participant Role Constraints
ID Priority Requirement Related
CM-20-001 MUST A Coordinator invited to a case as a regular participant MUST hold COORDINATOR in their case_roles list.

CASE_OWNER confers case administration authority (CM-02-001, CM-02-004, CM-02-005). CASE_MANAGER is a distinct role: it grants single-writer authority over the canonical ledger (CLP-09) and is held by the case-creating actor enacting CVDRole.CASE_MANAGER, which SHOULD also carry CVDRole.COORDINATOR (CBT-01-015). It is not conferred merely for being invited as a facilitation participant, so a Coordinator invited as a regular participant holds neither CASE_OWNER nor CASE_MANAGER.
CM-20-002 MUST When the Case Owner approves a Coordinator suggested through the Offer(Actor)[target=VulnerabilityCase] path (CM-16), the Coordinator's roles MUST include COORDINATOR.

Role assignments at invite time must reflect the invited actor's actual function in the case, not its organizational identity. A Coordinator invited to facilitate holds the COORDINATOR role, so role checks find it as one.
Refines: CM-20-001
CM-20-006 MUST NOT When the Case Owner approves a Coordinator suggested through the Offer(Actor)[target=VulnerabilityCase] path (CM-16), the Coordinator's roles MUST NOT include CASE_MANAGER or CASE_OWNER.

Invitation and case ownership transfer are distinct protocol operations. An Offer(Actor)[target=VulnerabilityCase] invite adds a participant. It does not transfer CASE_OWNER authority (CM-02-005) or the CASE_MANAGER single-writer authority (CM-02-011). A suggestion that names either role is refused, not stripped (CM-20-008). Stripping would invite the actor with roles that nobody asked for, and the sender would not learn that its request was changed.
Extends: CM-20-002
CM-20-008 MUST The CASE_MANAGER MUST refuse two requests before it commits a ledger entry: an Offer(Actor)[target=VulnerabilityCase] whose suggested roles name CASE_MANAGER or CASE_OWNER, and an Accept(Offer(CaseParticipant)) whose recorded Offer names either role. It sends only the refusal notice.

No invitation confers either role: ownership moves by transfer (CM-21) and the CASE_MANAGER role by delegation (CM-02-014), as for a role Offer (CM-33-003). Removing the role and going on would invite the actor with roles that nobody asked for, and the sender would not know. The rule also covers the Case Owner's own Offer(Actor), which takes the same path (CM-17-007).
Refines: CM-20-006
CM-20-009 MUST NOT An actor MUST NOT send an Offer(Actor)[target=VulnerabilityCase] whose suggested roles name CASE_MANAGER or CASE_OWNER, or an Offer(CaseParticipantRole) that offers either role.

The CASE_MANAGER refuses both Offers (CM-20-008, CM-33-003). An actor that sends one only gets a refusal, so it does not send it.
Extends: CM-20-008
CM-20-003 MUST A Coordinator participant that holds COORDINATOR without CASE_MANAGER MUST route its Offer(Actor)[target=VulnerabilityCase] suggestion to add another actor through the CASE_MANAGER inbox, per ADR-0026 (CM-16-001).

A Coordinator-as-participant should be able to exercise their facilitation role (suggesting additional vendors) without requiring ownership transfer. The CASE_MANAGER-routed suggest flow (ADR-0026) already provides this: the Coordinator sends Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER, which records and forwards it to the Case Owner for approval.
Refines: CM-16-001
CM-20-007 MUST The Case Owner, not the Coordinator, MUST remain the sole decision-maker on approving or rejecting an invitation that a Coordinator participant suggests (CM-02-005).

A Coordinator facilitates the case; it does not own it. Approving a new participant is Case Owner authority (CM-02-005), and a suggestion transfers none of that authority.
Extends: CM-20-003
Refines: CM-02-005
CM-20-004 MUST NOT A Coordinator invited to a case as a regular participant MUST NOT hold the CASE_MANAGER role in its case roles.

CVDRole.CASE_MANAGER grants single-writer authority over the canonical ledger and is held by the actor that created the case and enacts that role (CBT-01-014, ADR-0088). It MUST NOT be conferred on an organizational or human actor invited to the case as a regular facilitation participant.
Extends: CM-20-001
Refines: CM-20-005
CM-20-005 MUST NOT The CASE_MANAGER role MUST NOT be assigned to any organizational or human participant joining a case as a facilitation actor rather than as the actor enacting the CASE_MANAGER role (CM-02-011).

CVDRole.CASE_MANAGER grants single-writer authority over the canonical ledger (CLP-09). Conferring it on a participant invited for facilitation would let them author ledger entries that only the actor enacting CVDRole.CASE_MANAGER is authorized to write.
Uses definition from: CM-02-011
Ownership Transfer Protocol Effects
ID Priority Requirement Related
CM-21-001 MUST A VulnerabilityCase MUST have at most one participant that holds CASE_OWNER at any point in time.

CASE_OWNER confers exclusive case administration authority (CM-02-004, CM-02-005). Two simultaneous holders would create conflicting authority: both could terminate embargoes, authorise invitations, and mutate case state independently. The invariant must be enforced at the data-layer level, not just assumed by convention.
CM-21-023 MUST When a new owner is designated, the system MUST remove CASE_OWNER from the previous holder before, or atomically with, granting it to the new owner.

A grant made before the strip would leave two holders for a moment, which CM-21-001 forbids. Stripping first, or in the same step, keeps the invariant at every point in time.
Implements: CM-21-001
CM-21-002 MUST When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST add CASE_OWNER to the accepting actor's case_roles.

Role-gated nodes such as CheckIsCaseOwnerNode read Case Owner authority from CaseParticipant.case_roles. A transfer that did not grant the role would leave a new owner whose CASE_OWNER-gated acts are refused, such as embargo teardown and case closure.
CM-21-024 MUST When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST update the case's attributed_to to the accepting actor's ID.

attributed_to is the owner that the case names to every reader (MSM-07-027). A transfer that grants the role (CM-21-002) but leaves attributed_to alone makes the case name an owner that no longer holds the role. Thus a transfer writes both.
Extends: CM-21-002
CM-21-003 MUST When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST remove CASE_OWNER from the previous owner's case_roles.

Transferring ownership does not evict the previous owner from the case; they continue to participate but no longer hold administrative authority. Stripping only CASE_OWNER (and not other roles) preserves their standing as a Coordinator, Vendor, or other role while satisfying the at-most-one invariant (CM-21-001).
Implements: CM-21-001
CM-21-005 MUST A Case Owner MUST propose an ownership transfer by sending Offer(Offer(VulnerabilityCase)), with the case as context, to the CASE_MANAGER only, never to the transferee (PCR-08-001).

Routing the transfer through the CASE_MANAGER lets it ledger the offer in flight and broadcast it to every active participant (CM-10-004), so no participant is unaware a transfer is being negotiated. The CASE_MANAGER cannot be the transferee: its Offer would have itself as its only recipient, which BT-17-008 forbids, the same ground on which CM-33-003 refuses a role offer to it.
Refines: PCR-08-001
CM-21-025 MUST The inner Offer of an ownership-transfer proposal MUST name the case as its object and the transferee as its target. It optionally carries the deadline to answer as its end_time (CM-21-016).

The inner Offer says what the owner asks the CASE_MANAGER to offer and to whom. Without the case and the transferee in it, the CASE_MANAGER cannot make the Offer the owner asked for (CM-21-028).
Extends: CM-21-005
Uses definition from: CM-21-016
CM-21-026 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal, with no ledger commit and no outbound Offer, unless its inner Offer passes two checks. The inner Offer's object is the proposal's case. Its target is an actor the CASE_MANAGER can address (present, neither itself nor the proposer) and an active participant of the case (CM-21-021).

A proposal is a request the CASE_MANAGER acts on. An inner Offer that names another case, or a transferee the CASE_MANAGER cannot address, would make an Offer nobody can answer, or one about a case the proposal did not concern.
Extends: CM-21-005
Uses definition from: CM-21-021
CM-21-027 MUST When it admits an ownership-transfer proposal, the CASE_MANAGER MUST ignore any id, actor or to inside the inner Offer.

The CASE_MANAGER makes the Offer itself (CM-21-028). An id, actor or recipient list that the owner wrote into the inner Offer would let the owner choose fields that only the CASE_MANAGER sets, such as an id that collides with a stored object.
Extends: CM-21-005
CM-21-028 MUST On admitting a proposal, the CASE_MANAGER MUST make the single ownership-transfer Offer(VulnerabilityCase) itself, under an id it derives from the proposal, addressed to the transferee. The Offer's actor is the CASE_MANAGER, its attributed_to the owner and its in_reply_to the proposal (CM-24-001, CM-24-002, CM-24-020).

Making the Offer itself rather than forwarding the owner's gives a transfer one Offer, under an id no other party chose, told apart from the proposal by its shape (ADR-0148, DL-06-006).
Extends: CM-21-005
Refines: CM-24-001
Refines: CM-24-002
Refines: CM-24-020
CM-21-029 MUST The CASE_MANAGER MUST ledger the Offer it made from a proposal once that Offer is in its outbox (SYNC-09-002). That Offer is the one that is ledgered, answered, closed and expired.

Ledgering the Offer after it is queued keeps the ledger from recording an Offer that was never sent. One ledgered Offer gives every reader one transfer to answer, close or expire (CM-21-014).
Extends: CM-21-028
Refines: SYNC-09-002
CM-21-006 MUST An actor emitting Accept(Offer(VulnerabilityCase)) (ownership-transfer variant) MUST address the activity only to the CASE_MANAGER (PCR-08-001), not directly to the offerer.

Routing the Accept through the CASE_MANAGER is required for the AcceptCaseOwnershipTransferReceivedUseCase to run on the authoritative CASE_MANAGER and trigger the post-transfer CaseLedgerEntry cascade (CM-21-007). Addressing the Accept to the offerer's inbox means the use case only runs there; the CASE_MANAGER never learns of the completed transfer and cannot broadcast it.
Refines: PCR-08-001
CM-21-007 MUST After the CASE_MANAGER applies the ownership-role changes of an admitted ownership-transfer Accept (CM-21-002, CM-21-003, CM-21-004), it MUST commit a CaseLedgerEntry recording the completed transfer.

The ledger is the record every replica follows (PCR-03-001). Without an entry for the completed transfer, no replica can learn from the ledger that the Case Owner changed.
Uses definition from: CM-21-002
Uses definition from: CM-21-003
Uses definition from: CM-21-004
CM-21-030 MUST After it commits the entry for a completed ownership transfer (CM-21-007), the CASE_MANAGER MUST broadcast Add(CaseLedgerEntry) to all case participants.

The CaseLedgerEntry broadcast is the only way that participants outside the transfer learn that the Case Owner changed. Examples are a Finder or a second Vendor. Without it, these participants cannot reliably find the actor that is responsible for the case. They then send messages to the wrong actor, and coordination fails.
Extends: CM-21-007
CM-21-008 MUST When an ownership transfer is processed, the previous owner MUST retain any other roles they held (e.g., COORDINATOR, VENDOR) in their case_roles.

Stripping only CASE_OWNER (and not other roles) preserves the previous owner's standing as a Coordinator, Vendor, or other role while satisfying the at-most-one CASE_OWNER invariant (CM-21-001).
Extends: CM-21-003
CM-21-009 MUST When an ownership transfer is processed, the previous owner MUST remain a participant in the case.

Ownership transfer is not case departure. The previous owner has institutional knowledge of the case and continues to participate; only their administrative authority is transferred.
Extends: CM-21-003
CM-21-010 MUST An actor emitting Reject(Offer(VulnerabilityCase)) (ownership-transfer variant) MUST address the activity only to the CASE_MANAGER (PCR-08-001), not directly to the offerer.

Rejection routing must be symmetric with the Accept path (CM-21-006): the transfer was proposed to the CASE_MANAGER (CM-21-005), so its rejection must be too. If the transferee's Reject goes only to the offerer, the CASE_MANAGER — the authoritative record of ownership — never learns the transfer was declined and its view of who owns the case can silently diverge from reality.
Refines: PCR-08-001
CM-21-011 MUST The CASE_MANAGER MUST refuse an Accept(Offer(VulnerabilityCase)), leaving the owner unchanged, unless its sender is the transferee of an unanswered Offer it recorded for the case. The owner is the case's attributed_to and every participant's CASE_OWNER role.

Without the match to a recorded, unanswered Offer, a receiver takes the sender of the Accept to be the new owner. Then any actor that knows a case id can claim ownership at every receiver that holds the case.
Refines: HP-01-006
Supersedes: CM-21-002
CM-21-031 MUST A participant replica MUST apply an ownership change only when it comes from the CASE_MANAGER (PCR-03-001).

A replica that takes the change only from the CASE_MANAGER keeps one authority for the owner of the case (PCR-03-001). A transferee's Accept sent to a replica would otherwise move ownership there without the CASE_MANAGER.
Refines: PCR-03-001
CM-21-012 MUST When the CASE_MANAGER admits an ownership-transfer Reject(Offer(VulnerabilityCase)) under CM-21-013, it MUST commit a CaseLedgerEntry recording the Reject, as it does for the Accept (CM-21-007). From that entry on, the Offer is closed and no longer pending on any replica (CM-21-014).

The Offer is ledgered and broadcast (CM-21-029), so every replica holds a transfer in progress. A Reject that adds no ledger entry never closes that transfer. The offerer does not receive the Reject (CM-21-010), so it never learns of the decline. A participant's Reject is a case event, as its Accept is. It is ledgered for the same reason (CLP-02-016).
Uses definition from: CLP-02-012
Uses definition from: CM-21-013
Uses definition from: CM-21-014
See also: CM-21-007 — context for the reader
CM-21-032 MUST After it commits the entry for an admitted ownership-transfer Reject (CM-21-012), the CASE_MANAGER MUST broadcast Add(CaseLedgerEntry) to all case participants.

The broadcast is how every replica learns the Offer is closed, as it learns of a completed transfer (CM-21-030). Without it, replicas keep showing a transfer in progress.
Extends: CM-21-012
CM-21-033 MUST NOT A replica that applies the entry of an ownership-transfer Reject MUST NOT change the case's attributed_to or any participant's CASE_OWNER role. The entry only closes the Offer (CM-21-014).

A Reject declines the transfer, so the owner stays who it was. A replica that moved any ownership state on the entry would disagree with the CASE_MANAGER about who owns the case.
Extends: CM-21-012
Uses definition from: CM-21-014
CM-21-013 MUST The CASE_MANAGER MUST refuse, with nothing committed or sent, a Reject(Offer(VulnerabilityCase)) whose sender is not the transferee of an open Offer it recorded. The Offer then stays pending. CM-21-014 defines when an Offer is open, read from the ledger.

The same standing CM-21-011 requires for the Accept. Without it any actor that knows an Offer id could close a transfer it is not party to, and the closed Offer could no longer be accepted by the transferee it names.
Refines: HP-01-006
Uses definition from: CM-21-014
CM-21-014 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal (CM-21-005) for a case while an ownership-transfer Offer for that case is open, making no Offer from it. An Offer is open until the ledger holds an Accept (CM-21-007), Reject (CM-21-012) or withdrawal (CM-21-015) entry for it. It is also closed once the end_time the ledgered Offer carries has passed (CM-21-017).

Two pending Offers would let two transferees accept the same case, and CM-21-001 allows one owner. Withdrawal and expiry exist so that a transferee who never answers cannot block every later transfer of the case.
Extends: CM-21-005
See also: CM-21-007 — context for the reader
CM-21-034 MUST A reader MUST read whether an ownership-transfer Offer is open from the case ledger (CLP-11-001).

Reading "open" from the ledger rather than from local offer records keeps the CASE_MANAGER and every replica in agreement (CLP-07-014).
Refines: CLP-11-001
Uses definition from: CM-21-014
CM-21-035 MUST Once a case's ownership-transfer Offer is closed, the CASE_MANAGER MUST admit a new proposal for the case, to any transferee, with no waiting period. This includes the transferee that declined, and nothing has to be cleared first. A redelivered proposal whose Offer the ledger already records is not a new proposal: it changes nothing (HP-01-014).

A decline does not bar a later offer, so no memory of who declined is needed. A closed Offer no longer blocks the case (CM-21-014), so the owner can try again at once.
Extends: CM-21-014
See also: HP-01-014 — context for the reader
CM-21-015 MUST When the CASE_MANAGER admits the proposing Case Owner's Undo(Offer(Offer(VulnerabilityCase))), it MUST commit a CaseLedgerEntry recording the withdrawal. The entry closes the Offer the CASE_MANAGER made from that proposal.

Without a withdrawal, one open Offer per case (CM-21-014) lets a transferee who never answers block every later transfer of the case. Ledgering the withdrawal tells the transferee and every replica that the Offer can no longer be accepted, the same way the Reject entry does (CM-21-012).
Uses definition from: CM-21-014
Uses definition from: CLP-02-012
Uses definition from: CM-21-036
CM-21-036 MAY The proposing Case Owner MAY withdraw the Offer made from its proposal while that Offer is open (CM-21-014), by sending the CASE_MANAGER Undo(Offer(Offer(VulnerabilityCase))).

The owner names its own proposal, the one activity of the transfer it holds, so it needs nothing it learned from the ledger to withdraw (ADR-0148).
Uses definition from: CM-21-014
CM-21-037 MUST The CASE_MANAGER MUST resolve the Offer that an owner's Undo withdraws by the id it derived for that Offer from the proposal (CM-21-028).

The owner names only its proposal. The derived id links the proposal to the one Offer made from it, so the CASE_MANAGER closes that Offer and no other.
Extends: CM-21-015
Uses definition from: CM-21-028
CM-21-038 MUST After it commits a withdrawal entry (CM-21-015), the CASE_MANAGER MUST broadcast Add(CaseLedgerEntry) to all case participants.

The broadcast is how the transferee and every replica learn that the Offer can no longer be accepted.
Extends: CM-21-015
CM-21-039 MUST The CASE_MANAGER MUST refuse, with nothing committed or sent, an ownership-transfer Undo from any sender but the proposing owner, or for a closed Offer.

Only the owner that proposed the transfer may withdraw it. An Undo of a closed Offer has nothing left to close, so recording it would add an entry that changes nothing.
Extends: CM-21-015
CM-21-016 MUST The CASE_MANAGER MUST refuse a late Accept or Reject of an ownership-transfer Offer, with no role change and no ledger entry for the answer. An answer is late when the CASE_MANAGER processes it after the Offer's end_time. That end_time is the deadline to answer: the instant after which the Offer can no longer be accepted or rejected.

An embargo deadline is a strong suggestion, so participants may still answer late (CM-28-001). A transfer deadline has to hold, so that the offerer, the transferee and every other participant know who decides for the case once it passes. end_time keeps the meaning CM-28-001 gives it on an Invite — the deadline to answer — so it adds no new meaning to the field.
Extends: CM-21-011
Extends: CM-21-013
CM-21-040 MAY An ownership-transfer Offer(VulnerabilityCase) MAY carry an activity-level end_time. An Offer without one stays open until it is answered or withdrawn (CM-21-014).

An owner may want the transfer settled by a date, or may leave it open. A deadline lets a transfer end without an answer (CM-21-017).
Uses definition from: CM-21-016
Uses definition from: CM-21-014
CM-21-041 MUST When the inner Offer of the owner's proposal carries an end_time, the CASE_MANAGER MUST copy it onto the Offer it makes (CM-21-028).

The deadline is the owner's choice, stated in its proposal. The Offer the transferee answers is the CASE_MANAGER's, so the deadline must travel onto it.
Extends: CM-21-028
CM-21-017 MUST The CASE_MANAGER, never a replica, MUST evaluate ownership-transfer Offer expiry, lazily, from the ledgered Offer's end_time and its own clock, behind its role gate (BT-17-001). Lazily means when it processes an Accept, Reject or Undo of the Offer, or a new proposal for the case, with no scheduler. An Offer past its end_time is closed: a late answer is refused (CM-21-016), an Undo is refused (CM-21-039) and a new proposal admitted (CM-21-035).

Expiry evaluated in one place keeps the decision about a late answer with the actor that judges answers. Lazy evaluation needs no timer, and the next act on the case is the first moment the expiry matters. Unlike an embargo Invite's expiry, which moves a consent row (CM-28-009), an Offer's expiry changes no case-file record.
Uses definition from: CM-21-014
Implements: CM-21-016
Refines: BT-17-001
See also: CM-21-035 — context for the reader
See also: CM-21-039 — context for the reader
CM-21-043 MUST NOT The CASE_MANAGER MUST NOT commit a ledger entry or send an activity to record an ownership-transfer Offer's expiry (ADR-0152).

The expiry is an observation, not an act. Anything that holds the case and its ledger can read the deadline from the Offer, and no receiver changes on it. An expiry entry would record a fact every holder of the ledger can already derive, so it would be noise on the wire and in the ledger (ADR-0152).
Extends: CM-21-017
CM-21-019 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal (CM-21-005), writing nothing, unless its sender holds CASE_OWNER on the case when the proposal is processed. Writing nothing means no ledger commit, no Offer made, and the case's attributed_to and every CASE_OWNER role unchanged. A redelivered proposal the CASE_MANAGER already made its Offer from keeps the standing it was admitted with (HP-01-014).

CM-21-011 admits an Accept from the transferee of a recorded Offer. Thus the actor that gets an Offer recorded chooses the next owner. Without a sender rule, any actor that knows a case id can propose the case to itself and accept it, even from outside the roster. Only the Case Owner has the authority to transfer the case (CM-02-005). The redelivery clause makes a late copy of an answered proposal a duplicate, not a refusal, after its sender transfers ownership.
Refines: HP-01-006
Uses definition from: CM-21-005
See also: HP-01-014 — context for the reader
CM-21-044 MUST The CASE_MANAGER MUST refuse every ownership-transfer Offer(VulnerabilityCase) it receives, from any sender. It makes that Offer itself (CM-21-028).

An Offer the CASE_MANAGER admitted from another sender would be a second Offer for the transfer, under an id it did not derive, and would bypass the owner's proposal and its sender rule (CM-21-019).
Refines: HP-01-006
Derives from: CM-21-028
CM-21-045 MUST NOT A participant replica MUST NOT admit an ownership-transfer proposal (CM-21-005).

A proposal is sent to the CASE_MANAGER alone (CM-21-005). A replica that admitted one would act for the CASE_MANAGER, which only the CASE_MANAGER may do.
Uses definition from: CM-21-005
CM-21-046 MUST A participant replica MUST take an ownership-transfer Offer only from the case's CASE_MANAGER (PCR-03-001), refusing it before anything is written. A replica that holds no such case, or whose case names no CASE_MANAGER, has none to recognise, so it refuses the Offer.

The CASE_MANAGER makes the one Offer of a transfer (CM-21-028). An Offer from any other sender is not that Offer, and a replica that took it would hold a transfer the CASE_MANAGER never offered.
Refines: PCR-03-001
CM-21-021 MUST The CASE_MANAGER MUST refuse an ownership-transfer proposal (CM-21-005) whose transferee may not act on the case, with no ledger commit and no Offer made. A transferee may act when it is an active participant (CM-10-004) whose closure the case's ledger does not record (CM-23-018). An owner that means to transfer a case to an actor not active in it invites that actor first.

The new owner administers the case, its active embargo included, so it must first have agreed to that embargo and be entitled to the case content, as joining requires. An active participant holds the case, which is also what lets the Offer name the case by reference rather than carry it (ADR-0165). CASE_OWNER is held on a participant record (CM-21-002), so only a transferee with one can end the transfer as the single owner CM-21-001 requires. A closed participant stays active by CM-10-004, but it receives no further case content (CM-23-004) and may not act on the case (CM-23-018), so it cannot take the case on. The test is the one every sender guard and case-content selection uses, may_act_on_case in vultron/core/participants/recipients/sender_standing.py.
Extends: CM-21-005
Uses definition from: CM-10-004
Uses definition from: CM-23-018
CM-21-022 MUST The CASE_MANAGER MUST refuse, with ownership unchanged, the transferee's Accept(Offer(VulnerabilityCase)) (CM-21-011) when the transferee may no longer act on the case (CM-21-021) as the Accept is processed. Ownership unchanged means the case's attributed_to and every participant's CASE_OWNER role stay as they were.

The proposal check (CM-21-021) runs when the Offer is made. A participant can be removed, lapse by an embargo revision, or close between the Offer and its answer, so the Accept is checked again with the same test, may_act_on_case. A closed transferee's Accept is also refused by its sender check (CM-23-018).
Extends: CM-21-011
Uses definition from: CM-21-021
CASE_MANAGER-Authoritative Case Creation

Two CASE_MANAGER obligations for a case created from a CaseProposal, per ADR-0041: whom it addresses the Create(VulnerabilityCase) to, and in whose ledger the initialization entries are committed. CP-09 states the case creation itself: the case, its first participants, its default embargo and the actor of the Create(VulnerabilityCase).

ID Priority Requirement Related
CM-22-006 MUST When the CASE_MANAGER is not the report receiver, it MUST address that Create(VulnerabilityCase) (CP-09-011) to the report receiver, the CASE_OWNER, only. The report receiver introduces the CASE_MANAGER to the reporter (CBT-01-001, ADR-0132).

The report receiver proposed the case and owns it. The reporter has not yet met the CASE_MANAGER, so the report receiver introduces it (ADR-0132), and a Create sent to the reporter first would come from an actor it does not know.
Extends: CP-09-011
See also: CBT-01-001 — context for the reader
CM-22-003 MUST The CASE_MANAGER MUST commit every canonical ledger entry for case initialization natively in its own ledger, never authored by the report receiver and back-filled. The entries are create_case, create_embargo_event, add_report_to_case, the participant-record and participant-status entries, and add_case_status_to_case.

The ledger of the CASE_MANAGER is the authority for case state (CLP-07-003). Only the store that holds the canonical ledger may assign its indexes and extend its hash chain. An entry that the report receiver writes and then copies in gives the case a second writer. Its ids, times and chain positions then come from outside the CASE_MANAGER. Replicas that copy the ledger then cannot agree on the first entries of the case.
Extends: CP-09-001
RM Case Closure via Leave(VulnerabilityCase)

Requirements for the canonical RM case closure path: Leave(VulnerabilityCase) is the sole mechanism for advancing a participant's RM state to CLOSED. An Add(ParticipantStatus) whose status carries rmState=CLOSED is not a valid closure trigger. See ADR-0050 (Leave is canonical for RM closure) and ADR-0051 (CASE_MANAGER RM lifecycle). Decided: the maintainer decided the closure semantics in CM-23-002, CM-23-013 and CM-23-014 (what the owner's close does to pending Invites and to later Leaves) on 2026-10-12. ADR-0085 sets the owner-close write boundary. ADR-0131 sets the CM-23-013 reply to late traffic: by default it is dropped, and only a late Leave may get an as:Reject (#4065). The CM-23-014 settle step is #4066 (PR #4489).

ID Priority Requirement Related
CM-23-001 MUST The CASE_MANAGER MUST close a participant's RM state only in response to a Leave(VulnerabilityCase), never to a participant-sent Add(ParticipantStatus) whose status carries rmState=CLOSED. Its ledger commits are the authority for the closure.

The Leave round trip makes the CASE_MANAGER the authority for closure. It also prevents false departures that lost messages cause. A participant cannot silently reach RM.CLOSED at its peers unless the CASE_MANAGER commits and broadcasts a ledger entry (ADR-0108). See ADR-0050.
CM-23-021 MUST On a Leave(VulnerabilityCase), the CASE_MANAGER MUST commit a close_case entry that records the received Leave.

The close_case entry is the ledger's record that the participant asked to leave. Every replica learns of the departure from it, and the closure steps that follow are its recorded consequence (CLP-07-001, CLP-07-002, CLP-07-003).
Extends: CM-23-001
CM-23-022 MUST After the close_case entry, the CASE_MANAGER MUST commit one add_participant_status_to_participant entry per RM transition it writes for the leaver, in write order. A Leave from RM.VALID, recorded V → D → C (CM-23-038), gives two entries.

These status entries are the Leave's recorded consequence. The CASE_MANAGER writes them as its own RM writes for the leaving participant (CLP-07-001, CLP-07-002, CLP-07-003). The ledger records each change when the CASE_MANAGER makes it. Thus a replica applies changes and cannot add a step that no entry supports (ADR-0114, ADR-0124).
Extends: CM-23-021
See also: CM-23-038 — context for the reader
CM-23-023 MUST A replica that still receives case content (CM-23-004) MUST move a leaving participant to RM.CLOSED only by applying the ledger's status entries, in ledger order.

The status entries reach the replica in the Add(CaseLedgerEntry) fan-out. A replica that works out a closure path from its own stored state can write an RM step the ledger never recorded, so it diverges from the CASE_MANAGER (ADR-0114, ADR-0124).
Extends: CM-23-022
Uses definition from: CM-23-004
Refines: CM-23-016
CM-23-024 MUST NOT A replica applying a close_case entry MUST NOT change any participant's RM state from that entry.

The close_case entry records the request to leave. The status entries after it carry the RM steps (CM-23-022). If the close_case entry moved RM state too, a replica would write a step that no status entry records.
Extends: CM-23-021
CM-23-025 MUST The CASE_MANAGER MUST take back each RM transition, the leaver's or its own, whose status entry for a Leave did not commit (CLP-07-013).

A status entry that cannot be committed leaves its RM transition unwritten. If the CASE_MANAGER kept the transition, its RM state would be ahead of the ledger that the replicas copy (ADR-0146).
Extends: CM-23-022
Refines: CLP-07-013
CM-23-026 MUST NOT The CASE_MANAGER MUST NOT report a Leave as applied while any status entry for it failed to commit.

A Leave reported as applied tells the sender that its departure is on the ledger. If a status entry did not commit, that is false, and a redelivery of the Leave would not walk the closure again.
Extends: CM-23-025
CM-23-002 MUST When the CASE_MANAGER receives Leave(VulnerabilityCase) from the Case Owner, it MUST run the following steps in order. Step (0): it commits the close_case entry recording the Leave (CLP-10-006), then expires every embargo Invite still awaiting a reply (CM-23-014). Step (1): it advances the Case Owner participant to RM.CLOSED, with one status entry per RM transition, in order (CM-23-022). Step (2): it advances its own CaseParticipant to RM.CLOSED in the same way (CM-23-005). In each step it fans each entry out to every active participant whose closure the ledger does not already record (CM-10-004, CM-23-004). The owner-close write boundary (ADR-0085) is the CASE_MANAGER's own status entry reaching RM.CLOSED. It is the last entry of step (2), or of step (1) when the Case Owner is the CASE_MANAGER itself. Once the ledger holds it, the case is fully closed, and no later entry records an external participant's act (CM-23-013).

The Case Owner's departure is the authoritative termination event for a case. The CASE_MANAGER's own RM.CLOSED is the last thing the closure changes, so its entry marks the boundary. See ADR-0050, ADR-0051, ADR-0085.
Refines: CM-23-001
Uses definition from: CM-23-005
Uses definition from: CM-10-004
Uses definition from: CM-23-004
See also: CLP-10-006 — context for the reader
See also: CM-23-022 — context for the reader
CM-23-027 MUST NOT The CASE_MANAGER MUST NOT commit a separate entry that marks a case's closure.

The CASE_MANAGER's own RM.CLOSED status entry already marks the boundary (CM-23-002). A marker entry records nothing that a replica does not already hold, because every holder of the ledger could derive it (ADR-0152).
Extends: CM-23-002
CM-23-029 MUST NOT A ledger consumer MUST NOT treat the owner-close boundary entry as the case's highest logIndex, or as proof that a replica holds the whole ledger.

ADR-0085's boundary refuses external participants' appends, not the CASE_MANAGER's own housekeeping. Thus a consumer that stopped reading at the boundary could miss an entry that the CASE_MANAGER writes later. The guarantee is the boundary, not chain finality.
Uses definition from: CM-23-002
CM-23-003 MUST When the CASE_MANAGER receives Leave(VulnerabilityCase) from a non-owner participant while the case is open, it MUST advance only that participant's RM state to RM.CLOSED. It records the departure as CM-23-021 and CM-23-022 require: the close_case entry first (CLP-10-006), then one status entry per RM transition, in order. A non-owner Leave that arrives after owner close falls under CM-23-013.

Non-owner departure is a participant-scoped event, not a case termination event. Treating a non-owner Leave identically to an owner Leave would prematurely close the case and violate the Case Owner's authority over the case lifecycle. See ADR-0050.
Refines: CM-23-001
See also: CLP-10-006 — context for the reader
See also: CM-23-013 — scope boundary: CM-23-003 covers an open case, CM-23-013 the post-close write boundary
See also: CM-23-021 — context for the reader
See also: CM-23-022 — context for the reader
CM-23-030 MUST When a non-owner participant leaves an open case, the CASE_MANAGER MUST keep the case open for the remaining participants.

Only the Case Owner's Leave ends the case (CM-23-002). A non-owner Leave ends one participant's part in it, and the other participants still coordinate.
Extends: CM-23-003
CM-23-004 MUST NOT The CASE_MANAGER MUST NOT send any case content to a participant whose closure an earlier ledger entry records, except as CM-23-031, CM-31-009 and CM-31-030 allow. That entry is the participant's status entry with rmState=CLOSED. Case content is CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements. A participant that has left receives no entry after those that record its departure, the CASE_MANAGER's own closure included.

RM.CLOSED is the participant's own statement that it stops its work on the case, possibly while the case is still open. Its replication process is then assumed to have stopped, as the CASE_MANAGER's is once the case is fully closed (CM-23-013). A closed participant receives no more content, so it does not see embargoed material after it leaves. Only the ledger advances a replica, so a closed replica does not converge on later closures, by design.
Extends: CM-10-004
CM-23-031 MUST The CASE_MANAGER MUST send each entitled leaver the entries that record its own closure, chosen by their subject, not by the leaver's status. These are the close_case entry and each status entry after it, up to the one reaching RM.CLOSED (CM-23-021, CM-23-022). They never widen entitlement (CM-10-004): an inert or removed leaver is not sent them.

The entries that record a participant's own closure come before it stops, so its replica still receives every step, the one that reaches RM.CLOSED included. The leaver's status is already RM.CLOSED when the last of them is fanned out. Thus a choice by status would withhold that last step.
Supersedes: CM-23-004
Uses definition from: CM-10-004
Uses definition from: CM-23-021
Uses definition from: CM-23-022
CM-23-032 MUST NOT A closing participant MUST NOT write its own RM.CLOSED to its replica in place of the CASE_MANAGER's closure entries (CM-23-031).

The CASE_MANAGER writes the leaver's closure and commits each step (CM-23-022). A participant that wrote its own RM.CLOSED would hold a step that no ledger entry records, and its replica would diverge from the CASE_MANAGER (ADR-0114).
Extends: CM-23-031
CM-23-005 MUST The CASE_MANAGER MUST track its own RM lifecycle on a CaseParticipant record, through RM.RECEIVED, RM.VALID and RM.ACCEPTED during case initialization and RM.CLOSED on owner Leave.

Uniform RM lifecycle tracking across all participants (including the coordinator) enables case-level RM state to be read consistently from the ledger without special-casing the CASE_MANAGER. See ADR-0051.
CM-23-033 MUST The CASE_MANAGER MUST record each transition of its own RM state as a CaseLedgerEntry.

A ledger entry for each of the CASE_MANAGER's own RM transitions lets every replica read its RM lifecycle from the ledger, the same way as any other participant's. Its own RM.CLOSED entry is also the owner-close write boundary (CM-23-002). See ADR-0051.
Extends: CM-23-005
CM-23-006 MUST For the CASE_MANAGER's CaseParticipant, RM.RECEIVED MUST denote that a CaseProposal has been received and is being evaluated.

The RM state machine models a lifecycle that applies to any actor processing a case, but its transition labels map to case-level events for the coordinator rather than to report-validation events as for other participants. See ADR-0051.
Refines: CM-23-005
CM-23-007 MUST During case initialization (after accepting a CaseProposal), the Case Actor MUST emit CaseLedgerEntry records for each of its own RM transitions: (a) CASE_MANAGER→RM.RECEIVED when the CaseProposal arrives, (b) CASE_MANAGER→RM.VALID when the proposal is validated and case creation begins, (c) CASE_MANAGER→RM.ACCEPTED when the VulnerabilityCase is successfully created and initialized.

Ledger entries for the CASE_MANAGER's own RM transitions create a traceable, timestamped protocol-significant history of case initialization, consistent with CM-02-009 (CASE_MANAGER applies its own timestamp to every state-changing event). See ADR-0051.
Refines: CM-23-005
CM-23-008 MUST For the CASE_MANAGER's CaseParticipant, RM.VALID MUST denote that the CaseProposal is correctly formatted and actionable by this CASE_MANAGER, and that case creation has begun.

RM.VALID is the CASE_MANAGER's signal that the proposal passed structural validation and that initialization is in progress; it distinguishes a validated-but-incomplete case from one still under evaluation. See ADR-0051.
Refines: CM-23-005
CM-23-009 MUST For the CASE_MANAGER's CaseParticipant, RM.ACCEPTED MUST denote that the case has been successfully created and is being coordinated.

RM.ACCEPTED marks the end of the initialization phase and the start of active coordination; it is the CASE_MANAGER's counterpart to a reporter's or vendor's RM.ACCEPTED (engagement decision). See ADR-0051.
Refines: CM-23-005
CM-23-010 MUST For the CASE_MANAGER's CaseParticipant, RM.CLOSED MUST denote that the Case Owner has left the case and the case is fully closed.

RM.CLOSED on the CASE_MANAGER's own participant record is the terminal state; it signals that no further ledger entries will be authored for this case. See ADR-0051.
Refines: CM-23-005
CM-23-011 MUST When the Case Owner's Leave(VulnerabilityCase) arrives while the case's EM state is EM.ACTIVE or EM.REVISE, the CASE_MANAGER MUST refuse it. Its answer is the refusal notice, a Refuse of the Leave (CLP-02-005, CLP-05-001).

Owner-close is a hard, terminal write boundary (ADR-0085). VP-13-009 keeps an embargo alive across a participant close only while others remain engaged. Owner-close leaves none, and no authority to lift it, so an embargo left active could never end. This raises the participant-level VP-13-005 guidance to a hard refusal. The CASE_MANAGER refuses an understood act on a precondition, so the answer is a Refuse, not a Reject or a Create(ProcessingFault) (ADR-0196).
Supersedes: CM-23-002
Refines: VP-13-005
Uses definition from: MSM-05-001
Uses definition from: CLP-02-005
Uses definition from: CLP-05-001
CM-23-034 MUST NOT When it refuses an owner-close under CM-23-011, the CASE_MANAGER MUST NOT run the CM-23-002 closure sequence: no participant reaches RM.CLOSED, itself included.

If any step of the closure ran, the Case Owner or the CASE_MANAGER would be closed while the embargo is still active. Then no authority would remain to end the embargo (CM-23-011).
Extends: CM-23-011
Uses definition from: CM-23-002
CM-23-035 MUST The CASE_MANAGER MUST suppress the receipt commit of an owner-close it refuses (CM-23-011), so the ledger holds no close_case entry for it.

The receipt commit opens the closure. It is committed before any role-specific effect (CLP-10-006), and the status entries after it (CM-23-022) advance the departing participant to RM.CLOSED on each replica (CLP-10-001, CM-23-003). Skipping only the CM-23-002 steps while still committing the receipt would leave a recorded departure that the case then refused (ISSUE-3137).
Extends: CM-23-034
See also: CM-23-011 — context for the reader
CM-23-036 MUST To close a case that holds an active embargo, the Case Owner MUST first terminate the embargo and then send its Leave(VulnerabilityCase) again.

The CASE_MANAGER refuses an owner-close while an embargo is active (CM-23-011). Thus the only path to a closed case is to end the embargo first through the normal EM path.
Derives from: CM-23-011
CM-23-037 MUST NOT The CASE_MANAGER MUST NOT terminate the embargo as part of refusing an owner-close (CM-23-011). The embargo stays active until the normal EM path ends it.

The refusal answers the close; it is not a decision on the embargo. Only the EM path ends an embargo, so its participants see the termination in the usual way.
Extends: CM-23-011
CM-23-012 MUST NOT Case closure MUST NOT advance the RM state of a participant that did not send a Leave(VulnerabilityCase): such a bystander keeps its last RM state. On an owner Leave, only the Case Owner and the CASE_MANAGER advance to RM.CLOSED (CM-23-002).

A participant's RM state is its own record of how it handled the report (ADR-0121). A bystander that never sent Leave has made no closure declaration, and forcing it to RM.CLOSED would fabricate one. It stays at its last rung when the case ends around it. The demos' "all participants RM.CLOSED" milestone (DEMOMA-07-003) holds because each participant closes its own handling before the Case Owner closes the case (CM-23-013).
Refines: CM-23-001
Constrains: CM-23-002
CM-23-038 MUST The CASE_MANAGER MUST advance a leaving actor to RM.CLOSED from any RM rung it holds, using only transitions the RM transition function permits. Thus a Leave from RM.VALID is recorded V → D → C (RMB-14-005). A Leave from RM.START, by an actor that has not yet recorded receiving the case, is recorded S → R → C.

A Leave is the participant's own closure act, so closing it from any rung is self-declaration, not an imposed jump (ADR-0121). The RM transition function closes from Received, Invalid, Accepted and Deferred (ADR-0114). A Leave from Valid passes through Deferred, and one from Start through Received, since S → C is not a transition. Thus no write site overrides the transition table (RMB-14-005).
Refines: RMB-14-005
CM-23-013 MUST NOT Once the CASE_MANAGER has committed its own status entry reaching RM.CLOSED (CM-23-002 step 2), the case is fully closed. For any later inbound activity for the case, the CASE_MANAGER MUST NOT commit any CaseLedgerEntry, the receipt entry included. Any inbound activity includes a non-owner participant's Leave(VulnerabilityCase), and every activity class: RM (R), EM, CS and general-inquiry (GI) traffic such as Add(Note).

A deployment's process for a closed case can exit once closure has fanned out. The prototype's CASE_MANAGER behaves toward the case as if its process had exited: nothing reaches the ledger. The boundary is a hard kill switch, not a selective gate (ADR-0085). The receipt commit is suppressed because it opens the closure whose status entries would close the sender on the replicas (CLP-10-006, CM-23-022). A participant that wants its departure recorded leaves first (CM-23-015).*
Refines: CM-23-002
CM-23-039 MUST NOT Once a case is fully closed (CM-23-013), the CASE_MANAGER MUST NOT change any case or participant state for an inbound activity for the case. The sender's RM state on the canonical ledger stays at its last rung (CM-23-012).

A state change with no ledger entry would leave the CASE_MANAGER's store ahead of every replica, which can no longer catch up. The closed case behaves as if its process had exited (ADR-0085).
Extends: CM-23-013
See also: CM-23-012 — context for the reader
CM-23-040 MAY Once a case is fully closed (CM-23-013), the CASE_MANAGER MAY answer an inbound activity for it with a Refuse (CLP-05-001), or drop it unanswered.

A reply is a courtesy, since nothing reaches the ledger either way. The CASE_MANAGER refuses the activity on the post-close boundary; it does not decline a request, so a reply is a Refuse, not a Reject (ADR-0196). A drop is what an exited process does.
Uses definition from: CM-23-013
Uses definition from: MSM-05-001
Uses definition from: CLP-05-001
CM-23-041 MUST NOT A participant MUST NOT rely on receiving a reply to an activity it sends after the case is fully closed (CM-23-013).

The CASE_MANAGER may drop a late activity with no reply (CM-23-040), so a participant that waits for one may wait forever.
Derives from: CM-23-040
Uses definition from: CM-23-013
CM-23-042 MAY Once a case is fully closed (CM-23-013), the CASE_MANAGER MAY still answer a replica's resync request (Reject(CaseLedgerEntry)) by replaying entries the ledger already holds.

A replay appends nothing, so it does not cross the boundary. The CASE_MANAGER still appends no new entry on behalf of an external participant (CM-23-013).
Uses definition from: CM-23-013
CM-23-014 MUST This rule covers the CM-23-002 owner-close sequence, after the close_case entry and before any closure step. There the CASE_MANAGER MUST expire every embargo Invite on the case still awaiting a reply, without waiting for its RSVP deadline. Each consent row that is INVITED moves to TIMED_OUT. A pending case Invite carries no RSVP deadline and needs no settling. An answer to it after close is an external append, refused at the ADR-0085 boundary.

After close a pending Invite can only expire. Waiting for its RSVP deadline would keep the CASE_MANAGER running for a closed case, possibly for years, only to write one more entry after the write boundary. Settling first leaves no timer, so the CASE_MANAGER can stop once the closure has fanned out. This keeps the boundary clean in practice; it does not promise chain finality (CM-23-002).
Refines: CM-23-002
CM-23-043 MUST The CASE_MANAGER MUST commit each owner-close expiry (CM-23-014) as its own Update(EmbargoConsent) that carries the TIMED_OUT row (CM-28-009, CM-28-014).

Each expiry changes one consent row, and every case-file change is its own ledger entry (CLP-07-013). Thus the replicas copy each TIMED_OUT row, and the expiries are on the ledger before the write boundary.
Extends: CM-23-014
Uses definition from: CM-28-014
Uses definition from: CM-28-009
CM-23-015 SHOULD The Case Owner SHOULD leave a case last, or nearly last, after the other participants have left, so that their departures are recorded before the case is fully closed; a departure sent after closure is not recorded (CM-23-013).

The owner's Leave closes the case for everyone (CM-23-002), and nothing a participant sends afterwards reaches the ledger. A participant that has not left by then keeps its last RM state on every replica that receives it, which is harmless but leaves the ledger without a record of its departure. Leaving last is the owner's normal course, not a hard ordering: a participant that never leaves cannot hold a case open. Every demo scenario closes through close_case_owner_last (vultron/demo/helpers/closure.py), which sends the owner's Leave only once the CASE_MANAGER has recorded each other departure.
Derives from: CM-23-013
CM-23-016 MUST A participant's case replica is the case as it stood when the replica was seeded, plus the ledger entries since. A replica MUST apply the entries in ledger order by copying the objects they carry, so replicas at one ledger position hold identical case files.

The CASE_MANAGER is the single writer (ADR-0108), and the ledger records each change when the CASE_MANAGER makes it (CLP-07-013). If each replica copies what the entries carry, in the same order, two replicas at the same position hold the same case file as each other and as the CASE_MANAGER. CM-23-023 gives the rule for closure. This requirement gives it for every replicated change (ADR-0124).
CM-23-044 MUST NOT A replica applying an entry MUST NOT mint an id, read a clock, read local policy or state outside the case, or run lifecycle logic. Walking the RM transition table from its own stored state to a target state is such logic.

A replica can find its own path from its own state, which can be out of date. It can then write an RM state that the ledger never recorded. A replica that builds a record itself gives it an id and a time that differ from those of the CASE_MANAGER. In both cases, the replicas diverge from the CASE_MANAGER (ADR-0124).
Extends: CM-23-016
CM-23-018 MUST The CASE_MANAGER MUST refuse every activity for a case from a sender whose closure that case's ledger records, committing no entry and sending nothing. That record is the sender's status entry with rmState=CLOSED. On a tree whose act may close its sender, the closed-sender door refuses it; on every other tree the sender guard does (HP-01-006). Either way no refusal notice is sent (CLP-05-006). CM-23-048, CM-23-049 and CM-23-050 give the exceptions.

RM.CLOSED is terminal (ADR-0085). The CASE_MANAGER sends no more case content to a closed participant (CM-23-004). Thus an act from that participant would be recorded in a case that it cannot see. CM-23-013 stops writes only when the case is fully closed.
Refines: HP-01-006
See also: CLP-05-006 — context for the reader
CM-23-048 MUST The CASE_MANAGER MUST answer a closed sender's Reject(CaseLedgerEntry) with a replay of only the entries that record that sender's own closure (CM-23-031). The active check of SYNC-03-005 admits that resync request, so it is not refused as a closed sender's (CM-23-020).

The resync request stays available to a closed participant whose replica missed one of its own closure entries. Its replay adds nothing to the ledger and has a limit: the entries that record the sender's own closure.
Supersedes: CM-23-018
Uses definition from: SYNC-03-005
Uses definition from: CM-23-031
See also: CM-23-020 — context for the reader
CM-23-049 MUST The CASE_MANAGER MUST report as SKIPPED a repeated act that would close a closed sender, whatever its activity id, committing no entry and sending nothing. Such an act is a Leave(VulnerabilityCase), or a Reject of the sender's stub or full-case Invite. A Reject(Offer(VulnerabilityReport)) closes no sender on a case, so it is not such a repeat (CM-23-019).

A second closing act changes nothing, whichever act closed the sender first: its effect is already in place (ID-05-003). The effect of an act, not its activity id, decides if it is a repeat.
Supersedes: CM-23-018
See also: CM-23-019 — context for the reader
CM-23-050 MUST While a case is not fully closed, the CASE_MANAGER MUST process a closed Case Owner's Leave(VulnerabilityCase) to complete the case's closure (CM-23-002).

The Case Owner's Leave includes the case's closure, which is not in place while the case is open, so it is not a repeat. A failed owner Leave keeps none of the closure (CLP-07-015). Thus this owner's closure was recorded by an act other than its Leave, and only its Leave can close the case.
Supersedes: CM-23-018
Uses definition from: CM-23-002
CM-23-019 MUST Once a report belongs to a case, only that case's Case Owner holds the report. The Case Owner closes the case by Leave(VulnerabilityCase) (CM-23-001, CM-23-002), never by Reject(Offer(VulnerabilityReport)). The CASE_MANAGER, and each participant holding a case replica, MUST refuse a Reject(Offer(VulnerabilityReport)) for a report that belongs to the case, from every sender. From the Case Owner it is the wrong closing act. From any other sender it is a message about a report that sender does not hold. A Reject(Offer(VulnerabilityReport)) for a report that belongs to no case is unaffected.

A Reject(Offer(VulnerabilityReport)) moves its sender to RM.CLOSED without the Leave round trip. Thus a Case Owner that sends one can close itself while its case stays open. It can then continue to act as Case Owner, and the case is never fully closed. If the Case Owner's Reject(Offer(VulnerabilityReport)) became a full close, the case would have two closing messages. If only the later acts of a closed Case Owner were refused, the wrong message would stay admitted (ADR-0144).
Refines: CM-23-001
See also: CM-23-002 — context for the reader
CM-23-051 MUST On refusing a Reject(Offer(VulnerabilityReport)) (CM-23-019), the CASE_MANAGER or replica holder MUST write no RM state, commit no entry and send nothing, a refusal notice included. The refusal is the sender guard's: no sender is entitled to send it to a case actor (CLP-02-005, HP-01-006).

A sender guard refuses before any write (HP-01-006), so the refused act leaves no trace. A refusal notice would answer a message that no sender may send.
Extends: CM-23-019
Refines: HP-01-006
See also: CLP-02-005 — context for the reader
CM-23-052 MUST NOT An actor MUST NOT send Reject(Offer(VulnerabilityReport)) for a report that belongs to a case it holds.

Every case actor refuses such a Reject(Offer(VulnerabilityReport)) (CM-23-019). The actor closes its part in the case by Leave(VulnerabilityCase) instead (CM-23-001).
Extends: CM-23-019
CM-23-053 MUST An actor's report-closing trigger MUST fail, before it writes or sends anything, for a report that belongs to a case the actor holds.

The trigger is where the actor would build the Reject(Offer(VulnerabilityReport)) that CM-23-052 forbids. Failing there, before any write, leaves no local closure that the case never recorded.
Implements: CM-23-052
CASE_MANAGER-Delegated Activity Authorship Contract

Requirements for how trigger use cases and received trees assign actor, attributed_to and in_reply_to when the CASE_MANAGER emits an Activity on behalf of a requesting participant (delegated message). The reference implementation is delegated_authorship() (vultron/core/behaviors/delegated_authorship.py). Codified from CONCERN-2170.

ID Priority Requirement Related
CM-24-001 MUST When the CASE_MANAGER emits a protocol Activity on behalf of a requesting participant (delegated message), the actor field of the emitted Activity MUST be set to the CASE_MANAGER's actor ID, not the requesting participant's actor ID.

Receiving actors authenticate messages: they compare the actor field with the known case participants. Case-scoped messages come to participants from the CASE_MANAGER (PCR-08-001). An Activity whose actor names the requesting participant is not a delegation that the CASE_MANAGER authorized. Thus the receiver can reject it or route it incorrectly. For example, a Coordinator refuses an ownership-transfer Offer whose actor names the Finder.
CM-24-002 MUST When the CASE_MANAGER emits a delegated Activity for a requesting participant other than the Activity's actor, the attributed_to field MUST be set to that participant's actor ID so that receivers can recover the originating identity.

AS2 defines attributedTo only as the entities an object is attributed to, and it says nothing of delegation. Vultron uses it to name the actor that asked for the act, so a receiver can recover the originating identity, and the audit trail credits the right participant. An act the actor asked for itself has no one else to credit (ADR-0199).
Extends: CM-24-001
CM-24-014 MUST An actor that finds no CASE_MANAGER for a case MUST fail the act, never sending the activity directly to another participant instead (CM-24-008).

An actor that finds no CASE_MANAGER reads a corrupt roster, since a case always has one (CM-02-014). A direct send to a participant would bypass the ledger and the recipient rules (PCR-08-001). It would also hide the corruption behind an apparent success. A failed act shows the corruption (ADR-0113).
CM-24-007 MUST When the CASE_MANAGER forwards a recorded activity for its sender (CM-33-008), the forward MUST carry one id, derived from that activity, on every attempt.

One id makes a resend safe. The outbox holds one pending entry for each id (OX-06-002). The addressee commits nothing, and it builds its answer again with the same id.
Uses definition from: CM-33-008
CM-24-016 MUST A forwarded activity's record and its forward (CM-24-007) MUST commit as one act (CLP-07-015), so a failure to build or send the forward keeps neither.

The record comes before the forward (CLP-10-006). If a forward fails after the CASE_MANAGER keeps its record, the ledger holds a request that its addressee never received and cannot answer. When the record and the forward are in one act, every recorded request has its forward.
Extends: CM-24-007
Refines: CLP-07-015
CM-24-017 MUST NOT The CASE_MANAGER MUST NOT report a failure to build or send a forward (CM-24-016) as a refusal of the sender (HP-01-003).

A failed forward is a fault of the CASE_MANAGER, not of the sender. A refusal would tell the sender that its request is not valid, which is false.
Extends: CM-24-016
Refines: HP-01-003
CM-24-018 MUST The CASE_MANAGER MUST process a redelivery of an activity whose first delivery failed to forward (CM-24-016) as a new delivery.

The failed act kept nothing, so the redelivery has no record or forward to complete. Processing it afresh records the activity once and sends its forward.
Extends: CM-24-016
CM-24-019 MUST The CASE_MANAGER MUST send nothing for a redelivery of an activity it has already recorded and forwarded (CM-24-007).

Every recorded request already has its forward (CM-24-016). Thus a redelivery never has a forward to complete, and a second forward would only repeat the first.
Extends: CM-24-016
See also: CM-24-007 — context for the reader
CM-24-020 MUST When the CASE_MANAGER emits a delegated Activity other than a replacement stub Invite, the in_reply_to field MUST be set to the id of the request the CASE_MANAGER received from the requesting participant. A replacement stub Invite names the Invite it supersedes instead (CM-11-044).

VOC inReplyTo names what an object answers. A receiver reads both who asked (attributedTo, CM-24-002) and which request the act carries out. A distinct asker reaches the CASE_MANAGER only by message (ADR-0109), so every delegated act has a request to name (ADR-0199). Stub Invites to one invitee form a thread: the first names the request, and each replacement names the Invite before it, so the request stays reachable along the thread and the CASE_MANAGER finds the one live stub by it (CM-11-015). The maintainer chose this in the #6464 build.
Extends: CM-24-002
See also: CM-11-044 — the replacement stub Invite this rule leaves to it
CM-24-021 MUST NOT An Activity whose requesting actor is its actor MUST NOT carry the delegation's attributed_to or in_reply_to (CM-24-002, CM-24-020).

An actor that asks for its own act does it directly, and there is no one else to credit and no received request to name (ADR-0199). An Owner that also holds the CASE_MANAGER role sends its ask straight to the answering actor.
Refines: CM-24-002
See also: CM-24-020 — the in_reply_to the self-asked act omits
Observer Participant Semantics

Requirements for the CVDRole.OBSERVER role (formerly CVDRole.OTHER): what an Observer IS, how it is admitted, what content it receives, and how the RM lifecycle applies. Codified by ADR-0057 (docs/adr/0057-observer-participant-role.md). Source: CONCERN-2093.

ID Priority Requirement Related
CM-25-001 MUST An Observer (OBSERVER) is a Tier-1 case participant: it MUST hold a CaseParticipant record, run the standard RM lifecycle, and satisfy the same embargo-consent gate (MV-10-005) as any other participant. OBSERVER is the base role — the lowest non-null privilege set in the Vultron protocol. All other CVD roles are additive to it.

Defining Observer as a full participant (not a passive consumer or an external T0 actor) ensures it is subject to the same admission and embargo-consent rules as Vendors and Coordinators. The "base role" framing establishes OBSERVER as the correct fallback when no other role applies, rather than leaving CVDRole.OTHER as an unspecified catch-all. See ADR-0057.
Uses definition from: MV-10-005
CM-25-002 MUST An Observer MUST be admitted to a case via the standard Invite/Accept flow defined in CM-17.

Requiring a non-empty case_roles value is load-bearing: the participant record created with the stub Invite (CM-11-026) carries the roles that Invite names. A missing or empty list would create an Observer participant with no role — indistinguishable from a defect.
CM-25-003 MUST An Observer MUST receive full case content once it is an active participant (CM-10-004). That check is the sole gate on case content for an Observer. No additional or reduced delivery tier applies.

An Observer that accepts the stub Invite consents to the active embargo (CM-11-001). The absence of a remediation function does not change what the Observer is entitled to receive once it is active. Introducing a separate reduced delivery tier for Observers is deferred: notes/selective-disclosure.md describes the potential future mechanism but it is not yet implemented.
Uses definition from: CM-10-004
CM-25-004 SHOULD After accepting a case invitation and receiving the full case replica, an Observer SHOULD run the standard RM triage cycle (CM-11-002): RM.VALID or RM.INVALID, then RM.ACCEPTED or RM.DEFERRED. For an Observer, RM.ACCEPTED means "I am actively engaged with / monitoring this case" — it does NOT imply commitment to develop or deploy a fix.

The RM triage cycle represents an Observer's assessment of whether the case is relevant to them and whether they intend to remain engaged. An Observer that determines the case is outside their scope should transition to RM.INVALID or RM.DEFERRED, not silently stay at RM.RECEIVED. This preserves the RM machine's semantics as a participation-intent signal.
Refines: CM-11-002
CM-25-005 MUST NOT A participant whose only case role is OBSERVER MUST NOT emit VFD state-transition messages (CV, CF, or CD). An Observer has no vendor-fix-deployment obligations and no authority to advance the VFD dimension on behalf of a product or service.

An Observer joined the case to monitor it, not to own a fix path. Permitting VFD emissions from a role with no fix obligations would corrupt the VFD state machine for the case (e.g., a monitoring actor falsely claiming fix deployment).
CM-25-006 MUST The Invite activity sent by the CASE_MANAGER for an Observer MUST carry case_roles naming OBSERVER only.

The stub Invite creates the participant record and gives it the roles that the Invite names (CM-11-006). An Invite without CVDRole.OBSERVER would create a participant with an empty role list. Role checks cannot tell that record from a record that lost its roles. An Invite that names other roles would give the Observer obligations or authority that it was not invited to hold.
Extends: CM-25-002
Refines: CM-17-003
CM-25-007 MUST NOT An Observer invitation MUST NOT carry an empty case-roles list: an empty list names no role, so the invitee's participant record would violate the CM-16-003 non-empty invariant.

[] provides no role information to the CASE_MANAGER's participant-creation path on the stub Invite (CM-11-006), producing a participant record that violates the non-empty role invariant enforced by CM-16-003.
Derives from: CM-25-006
See also: CM-16-003 — context for the reader
Role Stacking — Union of Permissions

Requirement governing how conflicting obligations are resolved when a participant holds multiple CVD roles simultaneously. Codified by ADR-0057. Source: CONCERN-2093.

ID Priority Requirement Related
CM-26-001 MUST Each actor MUST judge a participant's permitted and obligated actions by the union of what its case roles permit. A MUST NOT attached to one role gives way when another of its case_roles carries a MAY, SHOULD or MUST for the same action class.

CVD roles represent orthogonal functions a participant may perform. When a participant holds more than one function (e.g., a security researcher who is also a Deployer for an affected product), restricting them based on their least-capable role would incorrectly limit their protocol participation. The union model prevents role restrictions from blocking obligations that exist under a co-role.
Embargo Invite RSVP Deadlines

Requirements for the optional RSVP-by deadline carried on an embargo invitation, the authority relationship between that wire value and the CM-18-023 pocket-veto policy window, and how an expiry is recorded. Codified by ADR-0065. Source: IDEA-2066.

ID Priority Requirement Related
CM-28-001 MUST An actor that reads an Invite(EmbargoEvent) MUST read its activity-level end_time, when present, as the RSVP-by deadline for that invitation. After that instant the invitation is no longer open.

as_Object.end_time is inherited by as_Activity and therefore by every Vultron activity, so no vocabulary extension is required. On an Activity, AS2 end_time already means "valid until", making the RSVP reading idiomatic rather than a repurposing. Placing the deadline on the activity rather than on the embargo object is what allows the same embargo to be offered to several actors with different deadlines, and to one actor twice. See ADR-0065.
CM-28-017 MAY An Invite(EmbargoEvent) activity MAY carry an activity-level end_time.

Every AS2 activity inherits end_time from as_Object, so a sender can state the RSVP-by deadline with no vocabulary extension. The field stays optional: without it, the CM-18-023 policy window sets the deadline (CM-28-019). See ADR-0065.
Uses definition from: CM-28-001
CM-28-018 MUST NOT An actor that reads an Invite(EmbargoEvent) MUST NOT read its activity-level end_time as the embargo's expiry.

An embargo invitation carries two end_time fields one nesting level apart: the Invite's is the RSVP-by deadline, and the nested EmbargoEvent's is when the embargo ends. A reader that takes one for the other lapses the invitation or the embargo at the wrong instant. See ADR-0065.
Extends: CM-28-001
CM-28-002 MUST When an Invite(EmbargoEvent) carries an end_time, that value MUST be authoritative for the invitation's expiry, superseding the receiver's local policy window. The resulting deadline stays subject to the EP-07-006 ceiling.

An explicit wire value lets both parties calculate the same lapse time from the same field, with no more messages. A window that only the receiver knows does not let the two parties agree if an invitation is still open. See ADR-0065.
Supersedes: CM-18-023
Refines: EP-07-006
CM-28-019 MUST When an Invite(EmbargoEvent) carries no end_time, the CM-18-023 policy window MUST set the invitation's expiry. The resulting deadline stays subject to the EP-07-006 ceiling.

An Invite without a deadline still needs one, and a sender that predates ADR-0065 sends none. The policy window keeps the behaviour those invitations had before the wire value existed. See ADR-0065 and ADR-0096.
Extends: CM-28-002
Refines: EP-07-006
Uses definition from: CM-18-023
CM-28-003 MUST The actor holding CASE_MANAGER MUST be the enforcement authority for embargo invite expiry.

Centralising enforcement at the CASE_MANAGER matches the case-communication model (PCR-08) and the CASE_MANAGER's role as canonical ledger author (ADR-0019, ADR-0021). See ADR-0065.
CM-28-020 MUST A consent row MUST reach DECLINED only by an explicit refusal.

Reserving DECLINED for an explicit refusal lets the consent row tell "never responded" from "explicitly declined". Code, logs, demos and replicas read the row, not ledger provenance, so the row must carry the difference (ADR-0118).
Extends: CM-18-002
CM-28-005 MUST An expired embargo invitation MUST be distinguishable from an explicit refusal both in the participant's consent row (TIMED_OUT versus DECLINED, CM-18-002) and in the canonical case ledger (CM-28-009).

The canonical ledger is the project's history mechanism (ADR-0019), so expiry-versus-refusal is recoverable from it; since ADR-0118 the consent row carries the distinction too, so a reader that consults only the participant record also sees it. See ADR-0065, ADR-0118.
CM-28-009 MUST When an RSVP deadline passes unanswered, the CASE_MANAGER MUST record the expiry as its own Update(EmbargoConsent) with the invitee's full TIMED_OUT row, committed as sent. The entry differs from the invitee's Reject(Invite(EmbargoEvent)), whose row is DECLINED.

The expiry is the occasion and the Update is the CASE_MANAGER's act on it, a real AS2 activity (ADR-0140). The TIMED_OUT row it carries makes expiry-versus-refusal distinguishable in the ledger (CM-28-005), and it is how a replica learns the TIMED_OUT state without computing it (CM-28-014). A second, invitee-attributed entry would record an act nobody sent. See ADR-0065, ADR-0118.
Refines: CM-28-005
CM-28-022 MUST NOT The CASE_MANAGER MUST NOT record an invitation's expiry as an activity attributed to the invitee, which sent nothing.

An invitee-attributed entry would record an act that nobody sent, and a reader of the ledger would take the silence for the invitee's answer. The expiry is the CASE_MANAGER's own act on its own clock (ADR-0140). See ADR-0065, ADR-0118.
Extends: CM-28-009
CM-28-012 MUST When the CASE_MANAGER relays an Invite(EmbargoEvent) to a participant (EP-09-002) it MUST set the Invite's end_time to that Invite's published time plus the configured RSVP window, subject to the EP-07-002 minimum and the EP-07-006 ceiling. The Invites of one relay round are emitted in sequence and need not share one deadline.

If the wire carries no deadline, each receiving store uses the EP-07-001 window from its own ActorConfig. Two replicas can then disagree about when the same invitation closes. The relaying CASE_MANAGER is the enforcement authority (CM-28-003). It states the deadline one time, and every participant reads the same value from the same object. ASK-03-004 requires the same of an ask (ADR-0065, ADR-0113).
Uses definition from: EP-09-002
Refines: EP-07-002
Refines: EP-07-006
CM-28-013 MUST The CASE_MANAGER MUST record an Invite's RSVP deadline on the invitee's INVITED row for that embargo, in an Update(EmbargoConsent) entry right after the Invite's (CLP-07-013).

The deadline is case state about the invitee. As with all other case state, the CASE_MANAGER writes it one time, and it gets to replicas through the ledger (ADR-0108, ADR-0124). A deadline that a receiver writes would be in one store only. Replicas could then disagree about whether the invitation is open (ADR-0113).
Extends: CM-28-012
Refines: CLP-07-013
CM-28-023 MUST Every replica MUST record an Invite's RSVP deadline by copying the CASE_MANAGER's CM-28-013 Update(EmbargoConsent) entry (EP-09-007, ADR-0124).

The deadline is case state about the invitee, so it reaches replicas through the ledger like all other case state (ADR-0108, ADR-0124). A replica that copies the entry holds the same deadline as the CASE_MANAGER, so the two agree on whether the invitation is open (ADR-0113).
Depends on: CM-28-013
Refines: EP-09-007
CM-28-024 MUST NOT A participant MUST NOT derive or store an RSVP deadline on receipt of an Invite (EP-09-003).

A deadline that a receiver writes would be in one store only, and replicas could then disagree about whether the invitation is open. The CASE_MANAGER writes the deadline once (CM-28-013), and replicas copy it (CM-28-023; ADR-0113).
Extends: CM-28-013
Refines: EP-09-003
CM-28-014 MUST Only the CASE_MANAGER evaluates invite expiry (CM-28-003). Its Update(EmbargoConsent) carrying the invitee's TIMED_OUT row (CM-28-009) MUST be committed by the CASE_MANAGER before the row is written (ADR-0124, CLP-07-013), and reaches replicas as that ledger entry (CM-28-030). A replica learns an expiry from that entry, copying the row, and never computes one.

Only the CASE_MANAGER can write a ledger entry. Thus an expiry that another store calculates has one of two results. It is an entry that the store has no authority to commit, or it is a private difference that no replica shares. The CASE_MANAGER commits the expiry first, and replicas copy it by replay. Thus the consent row of every replica is equal to that of the CASE_MANAGER, and one clock decides (ADR-0113, ADR-0124).
Extends: CM-28-009
Refines: CLP-07-013
See also: CM-28-003 — context for the reader
Case Status Recency Resolution

Rules for determining which CaseStatus snapshot is current when multiple snapshots exist in the case_statuses history, and how their times follow that order.

ID Priority Requirement Related
CM-29-004 MUST A receiver MUST reject at message validation an inbound activity carrying a VulnerabilityCase with no caseStatuses.

Every case has a current status (CM-29-001), and the sender holds it. A receiver that seeded a missing history would invent the case's first status and stamp it with its own clock, a time no sender claimed (CLP-15-007). A case named by its id and type alone is a reference, not a case, so this does not apply to it.
Derives from: CM-29-001
Derives from: CLP-15-007
CM-29-005 MUST The CASE_MANAGER MUST give each CaseStatus it appends to a case a published strictly later than the published of the status appended before it.

The current status is the last appended (CM-29-001), so a status's place in the history is its order. Its published then agrees with that order, and a reader who sorts the history by time gets the same order. The clock alone does not ensure this: two statuses stamped in one act share its instant (ADR-0176), and a clock can step back.
Supersedes: SM-05-003
CM-29-007 MUST NOT A replica MUST NOT refuse a ledgered CaseStatus because its published is not later than that of the status before it.

Append order decides the current status (CM-29-001), so an out-of-order time cannot make the wrong status current. Refusing the entry would stall the replica's ledger for a fault that changes nothing it reads. Claimed times are reported, never refused, as the ledger treats them (CLP-15-005).
Sender Entitlement for Case Content Changes

Who may remove a note from a case or attach a report to it. Neither message has a trigger today; these entries name the sender a receiver accepts (HP-01-006).

ID Priority Requirement Related
CM-30-001 MUST The CASE_MANAGER MUST act on Remove(Note)[origin=VulnerabilityCase] only when the sender is the note's author and an active participant (CM-10-004), or the case's Case Owner.

A note is a participant's contribution to the case record. If any sender could remove any note, a participant could delete evidence or advice that it disagrees with. An author can withdraw its own note. The Case Owner decides what the case holds, so it can remove any note. No other participant has a reason to remove a note.
Refines: HP-01-006
Uses definition from: CM-10-004
CM-30-003 MUST Every receiver, the CASE_MANAGER included, MUST refuse each Remove(Note)[origin=VulnerabilityCase], leaving the note attached and committing no ledger entry.

The case ledger is append-only, and the protocol does not yet define what removing ledgered content means. A removal could need a tombstone, could only hide the note while its entry stays, or could suit a ledger that keeps the order of events but not their content. Until that question is settled (#6430), a receiver that applied a Remove would erase what a committed entry records. The message type stays known, so the receiver refuses it rather than treating it as unknown.
Refines: HP-01-005
CM-30-004 MUST The CASE_MANAGER MUST refuse a Remove(Note)[origin=VulnerabilityCase] from any sender that CM-30-001 does not name, with the note left in the case.

A refusal that still removed the note would give the unentitled sender what it asked for. The REFUSED result tells the sender that nothing changed.
Extends: CM-30-001
CM-30-002 MUST The CASE_MANAGER MUST act on Add(VulnerabilityReport)[target=VulnerabilityCase] only when the sender is the case's Case Owner.

A report defines what the case is about. A new report makes the scope of the case larger and adds to the content that every participant receives. That is the decision of the Case Owner. If another sender could add a report, a participant could change the scope of the case alone.
Refines: HP-01-006
CM-30-005 MUST A participant replica MUST apply an Add(VulnerabilityReport)[target=VulnerabilityCase] only when the CASE_MANAGER sent it (PCR-03-001).

Replicas take case changes from the CASE_MANAGER only (PCR-03-001). A replica that applied an addition from another sender would widen the case's scope on that replica alone.
Refines: PCR-03-001
CM-30-006 MUST The CASE_MANAGER MUST refuse an Add(VulnerabilityReport)[target=VulnerabilityCase] from any sender other than the Case Owner, with the case's reports unchanged.

A refusal that still attached the report would give the unentitled sender what it asked for. The REFUSED result tells the sender that nothing changed.
Extends: CM-30-002
Participant Removal and Reinstatement

Removing a participant withdraws its entitlement to case content and keeps its record. The Case Owner requests removal and reinstatement; the CASE_MANAGER applies them, records each as one ledger entry, and tells the affected participant directly (ADR-0116).

ID Priority Requirement Related
CM-31-001 MUST An actor that applies a participant's removal MUST record a removal fact on the participant's CaseParticipant.

Removal is a decision about entitlement to case content, not about membership. Thus it is a fact on the record that the active check reads (ADR-0116).
CM-31-015 MUST NOT An actor that applies a participant's removal MUST NOT delete the participant's record from case_participants.

If the record is deleted, the case loses the history of who took part. Ledger entries then name an actor that is not on the roster (ADR-0116).
Extends: CM-31-001
CM-31-016 MUST An actor that applies a participant's removal MUST keep the participant's status history and the ledger entries it authored.

The status history and the authored entries are the record of what the participant did in the case. Removal withdraws entitlement from now on; it does not rewrite the past (ADR-0116).
Extends: CM-31-001
CM-31-017 MUST Every actor MUST treat a removed participant as inert (CM-10-004).

A removed participant has lost its entitlement to case content. If any actor still treated it as active, it would keep receiving embargoed content.
Extends: CM-31-001
Uses definition from: CM-10-004
CM-31-003 MUST VulnerabilityCase MUST carry a computed activeParticipants collection on the wire holding exactly the participants the CM-31-002 check finds active, computed from the participant records (CM-31-014).

case_participants stays the full roster that role resolution and actor_participant_index read (CM-19-001). Publishing the active set as its own collection makes Remove(CaseParticipant) literally true: the participant leaves that collection.
Uses definition from: CM-31-002
CM-31-020 MUST A receiver reading a case MUST recompute its activeParticipants collection rather than refuse it as an unknown key.

Core types refuse unknown keys on input, so a computed field in the dump would refuse the case's own serialized form unless input handles it.
Extends: CM-31-003
CM-31-021 MUST A receiver reading a case MUST refuse a supplied activeParticipants value that contradicts the one it recomputes (ARCH-23-005).

A supplied collection that disagrees with the participant records it travels with would give two answers to who is active. The records are the facts, so the contradicting value is refused.
Extends: CM-31-003
See also: ARCH-23-005 — context for the reader
CM-31-004 MUST Remove(CaseParticipant)[target=VulnerabilityCase] is the Case Owner's request to the CASE_MANAGER to remove a participant from active participation. The CASE_MANAGER MUST refuse such a request in three cases. The sender does not hold CASE_OWNER, the named participant holds CASE_MANAGER or CASE_OWNER, or the request names no participant of the case.

The Case Owner decides who takes part in the case; the CASE_MANAGER applies case changes and decides none (ADR-0108). The CASE_MANAGER role is never unfilled (CM-02-014), and the Case Owner leaves only by transferring ownership (CM-21). A participant that wants to stop taking part sends Leave(VulnerabilityCase) (CM-23), not Remove.
CM-31-022 MUST The CASE_MANAGER MUST report a removal of an already-removed participant as skipped.

A repeated removal changes nothing, so it is neither applied nor refused. A skipped result tells the Case Owner that the participant is already removed, and the CASE_MANAGER commits no second entry and sends no second notice.
Extends: CM-31-004
CM-31-023 MUST NOT The CASE_MANAGER MUST NOT remove a participant on its own initiative.

The Case Owner decides who takes part in the case; the CASE_MANAGER applies case changes and decides none (ADR-0108).
Extends: CM-31-004
CM-31-005 MUST The CASE_MANAGER MUST record an accepted removal by committing the Case Owner's received Remove(CaseParticipant) as its entry, on receipt (CLP-10-006).

The Remove states the change, so it is the change's entry (CLP-07-013), authored by the actor that made it. The ledger therefore shows the removal as the Case Owner's decision rather than the CASE_MANAGER acting alone (ADR-0108).
See also: CLP-10-006 — a pointer for "on receipt"; committing the received Remove does not need the receive-tree commit ordering
CM-31-024 MUST Remove(CaseParticipant) MUST be a ledgered activity, with a canonical ledger signature.

Without the canonical signature a removal cannot be committed, so it never reaches a replica.
Extends: CM-31-005
CM-31-025 MUST NOT The CASE_MANAGER MUST NOT commit a second entry of its own for a removal that it records under CM-31-005.

The Case Owner's Remove is already the change's entry. A second entry would record the same move twice and show it as the CASE_MANAGER's own act.
Extends: CM-31-005
CM-31-006 MUST After a removal commits, the CASE_MANAGER MUST send the removed participant a direct Remove(CaseParticipant) naming it. The notice's actor is the CASE_MANAGER, its attributedTo the Case Owner and its inReplyTo the Case Owner's request (CM-24).

Learning of removal only from silence is indistinguishable from a network fault, and the removed party needs to know it is still bound and how it will hear of the embargo's end.
Extends: CM-31-005
CM-31-026 MUST NOT The CASE_MANAGER MUST NOT ledger its CM-31-006 removal notice.

The notice is delivery, not a second record of the move. The Case Owner's Remove is already the move's entry (CM-31-005).
Extends: CM-31-006
CM-31-027 MUST The CASE_MANAGER MUST include the removed participant in the removal entry's fan-out.

The ledger entry keeps the removed party's replica continuous up to the removal, so that replica records its own removal like every other replica.
Extends: CM-31-005
CM-31-028 MUST The removal entry MUST be the last canonical entry that the CASE_MANAGER sends the removed participant, by fan-out or by replay, until it is reinstated.

A removed participant has lost its entitlement to case content. An entry sent after the removal would leak case content to it.
Extends: CM-31-005
CM-31-007 MUST A replica MUST apply a removal from its ledger entry, recording the same removal fact the CASE_MANAGER recorded.

Replicas take case state from the ledger. The entry is what changes every replica, the removed party's included.
CM-31-029 MUST NOT A replica MUST NOT apply a removal from a directly received Remove(CaseParticipant) (RSH-08-003).

The direct notice tells the removed party what happened; it is not the change. A replica that applied it would take case state from outside the ledger.
Extends: CM-31-007
Refines: RSH-08-003
CM-31-008 MUST Removal MUST NOT change the participant's embargo consent rows. A removed signatory remains bound by the embargo it accepted.

Releasing a removed participant from the embargo would reward the conduct that got it removed. Consent is the participant's own statement (CM-18-005); removal is a separate fact.
Extends: CM-31-001
CM-31-009 MUST This rule covers each signatory that the ledger fan-out does not reach: one removed (CM-31-001), or one at RM CLOSED that the CM-23-004 fan-out skips. When the active embargo is terminated, the CASE_MANAGER MUST send each such signatory a direct Remove(EmbargoEvent). Termination includes the case becoming public.

A participant that stopped receiving case content while bound stays bound, and without this it never learns that the obligation ended early. A past-dated Announce(EmbargoEvent) is not used: its meaning would depend on the receiver's clock, and an early end is an event, not a date that passed.
Uses definition from: CM-31-001
Supersedes: CM-23-004
CM-31-030 MUST When a shorter revision replaces the active embargo, the CASE_MANAGER MUST send each signatory that CM-31-009 covers a direct Announce(EmbargoEvent) with the new terms. No notice is owed for a longer revision, or for expiry on the agreed date.

A participant bound by the embargo must learn that its obligation shortened, and a paused replica cannot learn it from the ledger. A longer revision does not bind a participant that never agreed to it, and expiry on the agreed date is already known to it. A revision that ends at the same time as the embargo it replaces is on the EP-05-003 carry-over arm, so it is sent like a shorter one.
Extends: CM-31-009
Supersedes: CM-23-004
CM-31-031 MUST NOT The CASE_MANAGER MUST NOT put any other case content in a CM-31-009 or CM-31-030 notice.

The notice exists only to tell a bound participant that the embargo ended or shortened. The recipient has stopped receiving case content, so anything more would leak content it is not entitled to.
Extends: CM-31-009
Extends: CM-31-030
CM-31-010 MUST This rule covers a participant whose ledger stream is paused: withheld under CM-10-005, removed (CM-31-001), or skipped at RM CLOSED (CM-23-004). It MUST apply a CM-31-009 or CM-31-030 notice that the CASE_MANAGER sends for the case.

A paused replica cannot take the change from the ledger, so the notice is its only channel.
Supersedes: RSH-08-003
Uses definition from: CM-10-005
Uses definition from: CM-31-001
Uses definition from: CM-23-004
Uses definition from: CM-31-009
Uses definition from: CM-31-030
CM-31-032 MUST A participant whose ledger stream is paused (CM-31-010) MUST ignore a CM-31-009 or CM-31-030 notice from any sender other than the CASE_MANAGER.

The exception is to the channel, not the authority: the notice still originates from the CASE_MANAGER (PCR-03-001).
Extends: CM-31-010
See also: CM-31-009 — context for the reader
See also: CM-31-030 — context for the reader
CM-31-033 MUST After a paused participant becomes active again, replaying the ledger entry that matches an applied CM-31-009 or CM-31-030 notice MUST change nothing further.

The notice already made the change, so the entry, which states the same change, must not apply it twice when the participant's ledger stream resumes.
Extends: CM-31-010
See also: CM-31-009 — context for the reader
See also: CM-31-030 — context for the reader
CM-31-042 MUST A CM-31-010 paused replica can receive a CM-31-009 Remove(EmbargoEvent) naming a revision it has not activated. When its register holds that revision at no final status, the replica MUST activate the revision and then terminate it.

The CASE_MANAGER terminates only the embargo in force, so the named revision replaced the replica's. Its CM-31-030 Announce was overtaken (SYNC-19-003), or none was owed for a longer revision. Skipping the Remove leaves the replica bound for good (SYNC-19-001). A named embargo at a final status is a stale Remove and changes nothing (ADR-0122).
Refines: CM-31-010
See also: CM-31-009 — context for the reader
CM-31-011 MUST The Case Owner MUST reinstate a removed participant by sending Add(<Actor>, target=VulnerabilityCase) to the CASE_MANAGER only. The Add names the participant's actor as a typed reference, not its CaseParticipant.

Owners make mistakes and disputes resolve, so removal is reversible. The reinstatement is the Case Owner's decision, so it sends the act itself, and the CASE_MANAGER admits or refuses it (ADR-0199). The case holds one record per actor, so the actor names the record, and reinstatement reuses it (CM-31-034).
Uses definition from: CM-31-004
CM-31-043 MUST Not yet in the reference implementation (tracked by #6465)

The CASE_MANAGER MUST refuse a CM-31-011 reinstatement from a sender that does not hold CASE_OWNER, with a refusal notice, committing nothing.

Reinstatement is the Case Owner's decision, as removal is (CM-31-004).
Extends: CM-31-011
CM-31-044 MUST Not yet in the reference implementation (tracked by #6465)

The CASE_MANAGER MUST commit an admitted CM-31-011 reinstatement as one ledger entry carrying the Case Owner's Add(<Actor>), and announce that Add to the reinstated actor. The Announce's id is derived from the Add.

The Case Owner's act is its decision, and the entry is the CASE_MANAGER's admission of it, so the CASE_MANAGER sends no Accept and makes no Add of its own (ADR-0199). The reinstated actor's replica is paused when the entry is made, so the Announce tells it, and its actor is the CASE_MANAGER the receiver trusts; the entry reaches it with the backfill of what it missed (CM-10-006), and it applies the change from there (CM-31-045). A derived id makes a retry resend the same notice (SYNC-09-002).
Extends: CM-31-011
CM-31-045 MUST Not yet in the reference implementation (tracked by #6465)

A replica MUST apply a reinstatement only from its ledger entry, never from the Announce of it.

The Announce and the entry's fan-out carry the same act, so applying from the entry alone applies it once, in ledger order (RSH-08-003), as for a removal (CM-31-007).
Extends: CM-31-044
CM-31-034 MUST A reinstatement MUST clear the participant's removal fact.

The removal fact is what makes the participant inert (CM-31-017). Clearing it lets the active check count the participant again.
Extends: CM-31-011
CM-31-035 MUST NOT A reinstatement MUST NOT require the participant to accept again.

The participant never withdrew, so it does not rejoin; Leave remains open to it. A participant reinstated into a case whose embargo it has not accepted stays inert, and its CM-10-006 backfill waits for its consent.
Extends: CM-31-011
CM-31-036 MUST The CASE_MANAGER MUST refuse a CM-31-011 reinstatement naming an actor whose participant is not removed or never joined, or that is not in the case. It sends the Case Owner a refusal notice and commits nothing.

Joining requires accepting a stub Invite (ADR-0114), and a reinstatement must not become a way around that. An actor whose participant is not removed has nothing to reinstate.
Extends: CM-31-011
CM-31-012 MUST NOT The CASE_MANAGER MUST NOT emit Add(CaseParticipant), or commit an add_case_participant_to_case ledger entry, when an invitee accepts the stub Invite. The invitee's Accept (accept_invite_actor_to_case) is already the ledger entry for the consent row it signs and the joined mark.

The invitee's record was added to the case when the stub Invite went out (CM-11-023), so the Accept adds no record. CM-17-004 does not call for a second entry, and the Accept message is already the entry for its effects. A second Add would record one move twice.
Constrains: CM-17-004
CM-31-041 MUST This rule covers a VENDOR-only invitee that accepts the stub Invite. The CASE_MANAGER MUST commit its VF Vf status entry (CM-11-009) after it announces the case to the invitee and backfills the prior ledger (#2898).

The Accept is not the entry for the VF move, so the CASE_MANAGER records it as its own add_participant_status_to_participant entry. Committing it after the announce and the backfill lets the invitee's replica apply it on top of the case it already holds.
Extends: CM-17-004
Refines: CM-11-009
CM-31-037 MUST A replica MUST apply the stub-Invite Accept entry's consent-row and joined writes as the CASE_MANAGER does, setting updated to the Accept's published as received.

The Accept is the one entry for both writes (CM-31-012), so a replica that applied them differently would hold a participant record that differs from the CASE_MANAGER's. Taking updated from the Accept as received keeps the record equal on every replica (ADR-0103, ADR-0124).
Uses definition from: CM-31-012
CM-31-038 MUST NOT A replica seeded with the case MUST NOT move a record it holds backwards when it replays an older entry over the seed (ADR-0124). Moving backwards means clearing joined, or changing a consent row by a move that CM-18-003 does not allow.

A replica seeded with the case already holds a later state than an older entry describes. Replaying that entry must not undo what the seed holds, or the replica would fall behind the CASE_MANAGER.
Uses definition from: CM-18-003
CM-31-039 MUST When a replica holds no record for the invitee, its apply of the stub-Invite Accept entry MUST fail.

The Accept entry changes an existing record; it does not create one. A replica that created a record from the Accept would hold a participant the CASE_MANAGER never seated.
Extends: CM-31-037
CM-31-013 MUST NOT The CASE_MANAGER MUST NOT send a removed participant a stub Invite, a full-case Invite or an embargo Invite. The CM-31-009 and CM-31-030 notices are its only exception.

Invites reach inert participants because they ask them to join or consent (CM-10-007). A removed participant was taken out by the Case Owner's decision; inviting it to vote on embargo revisions would undo that decision.
See also: CM-31-009 — context for the reader
See also: CM-31-030 — context for the reader
CM-31-040 MUST When the Case Owner reinstates a participant that has not accepted the case's active embargo, the CASE_MANAGER MUST send it that embargo's Invite.

A reinstated participant that is not a signatory stays inert until it consents, so it must be asked.
Extends: CM-31-011
Case Split — Child Case Creation, Links, Inheritance, and Sibling Notices

How the parent case's Case Owner splits off a child case through the parent's CASE_MANAGER, what the child records and inherits, how its participants stay apart from the parent, and how the cases of one split family tell each other about embargo changes (ADR-0125, VP-10).

ID Priority Requirement Related
CM-32-001 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

To split a case, the parent case's Case Owner MUST send Create(CaseProposal) to the parent's CASE_MANAGER, with the activity's context naming the parent case.

The parent's Owner decides what the parent's coordination becomes, as it does for an ownership transfer or a merge (ADR-0053, ADR-0105). The parent context is what tells a split apart from a report-born proposal, whose sender entitlement differs (HP-01-006).
CM-32-017 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST refuse a split proposal whose sender does not hold CASE_OWNER on the parent case, creating no case and leaving the parent unchanged.

Only the parent's Owner may decide to split the parent (CM-32-001). A refusal that created a case, or changed the parent, would let any participant reshape a case it does not own.
Extends: CM-32-001
Refines: HP-01-006
CM-32-002 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST answer a split proposal (CP-05) to the Owner with Reject(CaseProposal), or with Accept(CaseProposal) naming the child in result and then Create(VulnerabilityCase).

Reusing the proposal answer gives the split the admission decision and the one-act creation the creation flow already has, rather than a second creation path to keep in step with it.
Refines: CP-05-002
Extends: CP-05-003
CM-32-018 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT create a second child case for a redelivered split proposal with the same proposal identifier (CP-05-013).

A split proposal is a Create(CaseProposal), so it takes the duplicate handling the creation flow already has. A second child for one request would split one family into two.
Extends: CM-32-002
Refines: CP-05-013
CM-32-003 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The parent's CASE_MANAGER MUST create the child case in its own store.

The split creates a case like any other (CP-09-001, ADR-0041). Creating it in the store that already holds the parent keeps the whole family at one CASE_MANAGER (CM-32-019).
Refines: CP-09-001
CM-32-019 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The parent's CASE_MANAGER MUST be the CASE_MANAGER of each child case it creates.

The child has a CASE_MANAGER from creation (CM-02-014). Hosting the whole family at one CASE_MANAGER (CM-32-016) is what lets siblings be read from the parent (CM-32-006).
Extends: CM-32-003
CM-32-020 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST set the child case's attributed_to to the Case Owner that requested the split.

As in any case creation, the proposer owns the case it asked for (CP-09-001). The splitter is the Owner the child's ledger and roster start from.
Extends: CM-32-003
CM-32-021 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST derive the child case's genesis hash from the child's own ID, creation time and Owner (CLP-08-002), never from the parent's.

The child has a ledger of its own that shares no chain with the parent's. A genesis hash taken from the parent would tie the two chains together.
Extends: CM-32-003
Refines: CLP-08-002
CM-32-004 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST create a child case with parent_cases holding exactly the parent case's ID, and with child_cases and sibling_cases empty.

The child must know the case its embargo came from, so its CASE_MANAGER can route VP-10 notices.
CM-32-022 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST record a split's case cross-references as case IDs, never as embedded cases.

Related cases are the exception ADR-0017 made to the full-object rule. An embedded parent would also carry the parent's content into the child (CM-32-009).
Extends: CM-32-004
CM-32-005 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

After it commits the child case's creation entry, the CASE_MANAGER MUST add the child's ID to the parent's child_cases, committed as one parent ledger entry.

Ordering the parent entry after the child's creation means the parent never names a case that does not exist. One write per split keeps the links consistent.
CM-32-023 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

A replica of the parent case MUST take the child link from the parent ledger entry of CM-32-005.

A replica copies the case from the CASE_MANAGER's ledger and never writes the case itself (ADR-0124). A link a replica wrote on its own could name a child the CASE_MANAGER never committed.
Depends on: CM-32-005
CM-32-024 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT write sibling_cases on any case as part of a split.

No existing sibling changes when a new child appears, because siblings are read from the parent (CM-32-006). That leaves sibling_cases free for the merge spec (ADR-0105).
Extends: CM-32-005
CM-32-006 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST read a split family as a parent case with the cases its child_cases lists. A child's siblings are the other cases in its parent's child_cases. A case that is both a child and a parent belongs to both families. A notice it owes under CM-32-013 or CM-32-014 goes to every other member case of each.

The parent stays open after a split, so it is coordinated alongside its children and counts as their sibling for VP-10-002 and VP-10-003. Reading siblings from the parent needs no stored sibling list, because one CASE_MANAGER hosts the parent and every child (CM-32-019, CM-32-016).
CM-32-025 MUST NOT Not yet in the reference implementation (tracked by #3702)

When it merges cases, the CASE_MANAGER MUST NOT record a merged case in any case's child_cases.

Only a split writes child_cases (CM-32-005), so a merged case never joins a split family. Keeping merges out of child_cases leaves the merge spec the other two link fields (ADR-0105).
Derives from: CM-32-006
CM-32-007 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

This rule covers a split whose parent case has an active embargo. The CASE_MANAGER MUST give the child a new EmbargoEvent, scoped to the child, with the active embargo's end time, active from creation.

VP-10-005 transfers the embargo; ADR-0125 limits the transfer to its terms. A new embargo object keeps consent per (participant, embargo) (ADR-0122): a child participant consents to the child's embargo, and its answer says nothing about the parent's.
Refines: VP-10-005
Supersedes: CM-14-010
Part of: CM-32-011
CM-32-026 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

When the CASE_MANAGER gives a child case a new embargo under CM-32-007, it MUST write the child Owner's consent row for that embargo as AGREED.

The Owner asked for the split and so agrees to the terms the child inherits. Its AGREED row is what makes it read as the new embargo's signatory (ADR-0122).
Extends: CM-32-007
CM-32-027 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

When it splits a case with an active embargo, the CASE_MANAGER MUST NOT carry the parent embargo's consent rows over to the child.

Consent is per (participant, embargo) (ADR-0122). A parent participant's answer to the parent's embargo says nothing about the child's.
Extends: CM-32-007
CM-32-028 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

When it splits a case with an active embargo, the CASE_MANAGER MUST NOT give the child the parent's open embargo proposals or revisions.

ADR-0125 limits the transfer to the active embargo's terms. A proposal still open in the parent belongs to the parent's negotiation.
Extends: CM-32-007
CM-32-008 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

When the parent case has no active embargo at the split, the CASE_MANAGER MUST NOT give the child an embargo.

The child inherits the parent's embargo state, not a default: a parent whose embargo has ended or was never agreed must not gain an embargoed child the parent's participants never agreed to.
Part of: CM-32-011
CM-32-029 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

When a split's parent case has no active embargo, the CASE_MANAGER MUST NOT run the creation-time default embargo initialization (CM-14-010, EP-04-012) for the child.

The default would give the child an embargo that CM-32-008 forbids. The parent's participants never agreed to an embargoed child.
Extends: CM-32-008
Supersedes: CM-14-010
See also: EP-04-012 — context for the reader
CM-32-009 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT give a child case any of the parent's reports, notes, ledger entries, participants, case statuses, vulnerability items or case references.

The split exists to keep the child's participants apart from the parent's content. Creating the child empty and adding only what the splitter wrote makes isolation the default; copying and pruning would disclose whatever the pruning missed.
CM-32-030 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST begin a child case's ledger at the child's own genesis hash.

A child ledger that chained from a parent entry would carry the parent's history into the child (CM-32-009).
Extends: CM-32-009
CM-32-010 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The Case Owner MUST include in its split proposal a new VulnerabilityReport attributed to itself, and the stub summary for the child's stub Invites (CM-17-010).

Every case has a report (CM-05-002). A report the splitter writes for the child is the child's fresh description. The splitter, not the CASE_MANAGER, decides how much an invitee not yet bound by the embargo may learn from the stub (CM-17-010).
Uses definition from: CM-17-010
CM-32-031 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST make the split proposal's report the child case's only report.

The splitter's report is the child's description. Any other report would come from the parent (CM-32-009).
Extends: CM-32-010
CM-32-032 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST put the split proposal's stub summary in each stub Invite it sends for the child case.

The splitter chose what an invitee not yet bound by the embargo may learn (CM-17-010). A summary the CASE_MANAGER chose for itself could reveal more.
Extends: CM-32-010
Uses definition from: CM-17-010
CM-32-033 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST refuse a split proposal whose report is one of the parent case's reports, or that carries no stub summary.

Refusing a parent report keeps the parent's description out of the child (CM-32-009). With no stub summary, the child's stub Invites could carry nothing the splitter chose (CM-17-010).
Extends: CM-32-010
CM-32-011 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST initialize a child case by the sequence of CM-14-001, with CM-32-007 or CM-32-008 in place of its embargo step (CM-14-010).

A child is a case like any other, so it starts from the same sequence. Its embargo comes from the parent, not from the creation-time default.
Supersedes: CM-14-001
See also: CM-14-010 — context for the reader
CM-32-034 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST skip the reporter steps of case initialization (CM-14-011, CM-14-012) when it initializes a child case.

The child has no outside reporter; the Owner wrote its description.
Extends: CM-32-011
Supersedes: CM-14-011
Supersedes: CM-14-012
CM-32-035 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST seat only itself and the Owner when it initializes a child case, the Owner holding CASE_OWNER at RM.RECEIVED (CM-14-009). These two are the participants seated by case initialization for CM-10-004.

Every other participant joins the child by accepting its stub Invite (ADR-0114), so it gets the child's content only once it is active (CM-10-004).
Extends: CM-32-011
Uses definition from: CM-10-004
Refines: CM-14-009
CM-32-036 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT give the splitter the Reporter role for authoring the child's report.

The splitter wrote the child's description as its Owner, not as an outside reporter. A Reporter role would claim a report the child never received from outside.
Extends: CM-32-011
CM-32-037 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT invite a participant to a child case before it commits the child's creation entry (CM-14-007).

An Invite sent before the creation entry would name a case the ledger does not yet hold, as for any case (CM-14-007).
Refines: CM-14-007
CM-32-012 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT add a participant to the parent case's roster because of a child-case activity.

Joining the child is joining the child only. A participant in both cases, such as the Owner, is a participant of each separately.
CM-32-038 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The parent case's recipient selection (CM-10-007) MUST NOT return a participant of the child case that is not separately a participant of the parent.

The recipient selection is the one place that decides who gets case content (CM-10-007). A child participant it returned would get the parent's content.
Uses definition from: CM-10-007
CM-32-039 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT send a parent ledger entry to a child-case participant that is not separately a participant of the parent.

Parent content reaches a participant in both cases only as a parent participant. Keeping the child apart from the parent's content is why the split exists.
Refines: CM-10-004
CM-32-013 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

This rule covers a child case's CASE_MANAGER that commits an embargo proposal or revision ending earlier than the end time the child inherited. Before the proposal is activated, it MUST commit a split-family embargo notice to each other member case's ledger in the child's family (CM-32-006).

This is how VP-10-002 is carried out. An earlier end in one child can reveal the vulnerability in the products the others cover (VP-10, split discussion), so the other cases hear of it while it is still a proposal.
Implements: VP-10-002
Uses definition from: CM-32-006
CM-32-040 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

A split-family embargo notice under CM-32-013 MUST carry the child's ID, the proposed end time and the proposer's rationale.

The other cases need to know which case wants the earlier end, how much earlier, and why, to weigh the risk to their own products.
Extends: CM-32-013
CM-32-041 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

For a proposal under CM-32-013, the child's CASE_MANAGER MUST commit the proposer's rationale to the child's ledger.

The reason for the earlier end is then on record in the case that asked for it, as well as in the cases it was sent to.
Extends: CM-32-013
CM-32-042 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The rationale of a proposal under CM-32-013 is the proposing activity's content. The child's CASE_MANAGER MUST refuse such a proposal whose content is empty.

The activity's content carries the rationale because embargo proposals have no rationale field of their own. With no rationale, the notice would tell the other cases nothing about why.
Extends: CM-32-013
CM-32-014 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

When the active embargo of any member of a split family changes — a revision is activated or the embargo is terminated — the family's CASE_MANAGER MUST commit a split-family embargo notice to the ledger of every other member case of the family (CM-32-006), carrying the changed member's ID, its new end time or the fact of termination, and the rationale when the change's proposal gave one.

This is how VP-10-003 is carried out. Participants address case messages only to their CASE_MANAGER (PCR-08-001), and every member case has the same CASE_MANAGER (CM-32-016), so a change agreed in one case reaches the others' participants through their own ledgers rather than from participant to participant.
Implements: VP-10-003
Uses definition from: CM-32-006
CM-32-015 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER of a member case MUST be the only actor that commits a split-family embargo notice to that case's ledger.

Committing the notice to the receiving ledger delivers it through the shared recipient selection (CM-10-004). The participants of one case thus learn of another's change without ever being addressed by it.
Constrains: CM-32-014
CM-32-043 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT change the receiving case's EM state or any consent row when it commits a split-family embargo notice.

A notice informs and proposes nothing: a case's embargo changes only through its own negotiation (ADR-0125).
Extends: CM-32-015
CM-32-044 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST NOT put content of the reported case in a split-family embargo notice beyond three items. These are that case's ID, its new end time or the fact of termination, and the rationale.

The participants of the receiving case may not be participants of the reported one. They learn of its change, and nothing else of that case.
Extends: CM-32-015
CM-32-016 MUST NOT Not yet in the reference implementation (tracked by #4241 and #4242)

While a case belongs to a split family, its CASE_MANAGER role MUST NOT be delegated to any actor but the CASE_MANAGER of the other members.

Siblings are read from the parent (CM-32-006), and notices are ledger commits by the one CASE_MANAGER hosting the family (CM-32-013, CM-32-014). A member moved to another CASE_MANAGER could neither find its siblings nor reach them. ADR-0125 leaves a family spread across CASE_MANAGERs to a later decision.
Extends: CM-02-014
CM-32-045 MUST Not yet in the reference implementation (tracked by #4241 and #4242)

The CASE_MANAGER MUST refuse a delegation that CM-32-016 forbids, leaving the case's CASE_MANAGER unchanged.

A refusal tells the requester that the delegation did not happen, rather than leaving it to find out from a family split across CASE_MANAGERs.
Extends: CM-32-016
Role Delegation Offers

How a role offer, Offer(CaseParticipantRole) (ADR-0039), and its answer travel through the CASE_MANAGER, which records both. The offer adds a role to an actor that is already a participant; the roles an Invite carries at joining are CM-17. The routing follows PCR-08 and the ownership-transfer model (CM-21).

ID Priority Requirement Related
CM-33-001 MUST A Case Owner offering a role MUST address Offer(CaseParticipantRole) to the case's CASE_MANAGER only, never to the target.

A participant sends case-scoped messages only to the CASE_MANAGER (PCR-08-001). An Offer that goes directly to the target bypasses the CASE_MANAGER. The CASE_MANAGER then cannot check the answer against a recorded Offer, and cannot ledger it.
Refines: PCR-08-001
CM-33-007 MUST When the CASE_MANAGER admits a role Offer, it MUST commit a CaseLedgerEntry for that Offer.

The recorded Offer is what the CASE_MANAGER checks the target's answer against (CM-33-005). An Offer it never ledgered could not be answered.
Extends: CM-33-001
CM-33-008 MUST After it commits an admitted role Offer, the CASE_MANAGER MUST forward the Offer to the target, with inReplyTo set to the recorded Offer's id. The forward's actor is the CASE_MANAGER and its attributed_to the Case Owner (CM-24-001, CM-24-002).

The target takes case messages from the CASE_MANAGER only (PCR-03-001), so it learns of the Offer from the forward. The inReplyTo lets the CASE_MANAGER resolve an answer to the forward back to the Offer it recorded (CM-33-005).
Extends: CM-33-001
Refines: CM-24-001
Refines: CM-24-002
CM-33-009 MUST NOT The CASE_MANAGER MUST NOT grant an offered role when it receives the role Offer. It grants the role when it commits the Accept (CM-02-016).

An Offer is a proposal, not the grant. A role granted on the Offer would hold even if the target declined it.
Extends: CM-33-001
See also: CM-02-016 — context for the reader
CM-33-002 MUST The CASE_MANAGER MUST refuse a received Offer(CaseParticipantRole) whose sender is not the case's Case Owner, committing no ledger entry and sending no forward.

A role grant decides who runs part of the case. That is the decision of the Case Owner, as ownership transfer is (CM-02-005).
Refines: HP-01-006
Refines: CM-02-005
CM-33-010 MAY Where its policy delegates role offers to it, a CASE_MANAGER MAY commit a role Offer on its own case and send it to the target. The checks of CM-33-003 apply to that Offer.

A Case Owner can delegate its decisions to the CASE_MANAGER in advance. The Offer is then the CASE_MANAGER's own, so it has no Case Owner's Offer to forward.
Uses definition from: CM-33-003
CM-33-011 MAY An implementation MAY omit the CASE_MANAGER-originated role Offer path of CM-33-010.

The Case Owner path alone lets every case grant roles. Thus a path that starts at the CASE_MANAGER adds convenience, not capability, and an implementation can omit it.
Uses definition from: CM-33-010
CM-33-003 MUST The CASE_MANAGER MUST refuse a role Offer in any of five cases. In two, the Offer carries no readable CVD role, or it offers CASE_OWNER or CASE_MANAGER. In three, its target is not a participant in the case, already holds the offered role, or is the CASE_MANAGER itself.

A grant only adds a role. Thus an accepted CASE_OWNER or CASE_MANAGER offer would give the case two holders of a role that it has exactly one of (CM-21-001, CM-02-001). Ownership moves by ownership transfer (CM-21). The CASE_MANAGER role moves only by delegation (CM-02-014), never by a role Offer, because it carries ledger authority. The CASE_MANAGER takes no other role by Offer. The forward of CM-33-008 would go to itself (BT-17-008), and the answer of CM-33-004 would also go to itself.
Constrains: CM-02-016
CM-33-012 MUST NOT The CASE_MANAGER MUST NOT commit a ledger entry for a role Offer that it refuses under CM-33-003.

The ledger records what the case admitted. An entry for a refused Offer would read as an open Offer that the target could answer.
Extends: CM-33-003
CM-33-013 MUST NOT The CASE_MANAGER MUST NOT forward a role Offer that it refuses under CM-33-003.

A forward invites the target to answer. A forwarded refused Offer would ask the target about a grant the case will never make.
Extends: CM-33-003
CM-33-014 MUST NOT An actor handling a role Offer MUST NOT read a missing CVD role as any default role.

If a missing role were read as a default, the case would grant a role that nobody offered.
Extends: CM-33-003
CM-33-004 MUST An actor named as the target of a role Offer MUST refuse it, sending no answer, when the CASE_MANAGER did not send it.

A replica takes case changes from the CASE_MANAGER only (PCR-03-001). An Offer from any other actor was never recorded by the CASE_MANAGER, so an answer to it could not be ledgered.
Refines: PCR-03-001
Refines: HP-01-006
CM-33-015 MUST The target of a role Offer MUST address its Accept or Reject to the CASE_MANAGER only, never to the Case Owner that made the Offer.

The answer is a case-scoped message (PCR-08-001). An answer that goes only to the Case Owner is never ledgered.
Refines: PCR-08-001
Extends: CM-33-004
CM-33-005 MUST The CASE_MANAGER MUST act on an answer to a role Offer only when its sender is the target of an open Offer it recorded. An Offer is open until the ledger holds an Accept or Reject entry for it (CLP-11-001).

The answer decides if the role is granted. Thus only the actor that received the Offer can give the answer, and only one time. The check uses the Offer that the CASE_MANAGER recorded, never the copy in the answer. CM-11-017 and CM-21-011 do the same check.
Refines: HP-01-006
Refines: CLP-11-001
CM-33-016 MUST The CASE_MANAGER MUST refuse an answer that CM-33-005 does not let it act on, committing no ledger entry and changing no role.

An entry or a role change made for a refused answer would grant, or record as decided, an Offer its target never answered.
Extends: CM-33-005
CM-33-017 MUST The CASE_MANAGER MUST resolve an answer that names its forward to the recorded role Offer through the forward's inReplyTo.

The target answers the forward it received, which the CASE_MANAGER sent, not the Case Owner's Offer. Only the stored forward's inReplyTo links that answer to the recorded Offer.
Extends: CM-33-005
CM-33-018 MUST The CASE_MANAGER MUST report a redelivery of the answer that closed a role Offer as SKIPPED (HP-01-014).

A redelivery is the same answer again, not a new one. Reporting it REFUSED would tell the target its answer was declined after it was admitted.
Extends: CM-33-005
Refines: HP-01-014
CM-33-006 MUST When the CASE_MANAGER admits an answer to a role Offer under CM-33-005, it MUST commit a CaseLedgerEntry for it (accept_case_participant_role or reject_case_participant_role).

A participant's answer to an Offer is a case event (CLP-02-016), so it is ledgered as all other case events are.
Uses definition from: CLP-02-012
Refines: PCR-08-003
Extends: CM-33-005
CM-33-019 MUST When the CASE_MANAGER commits an answer to a role Offer under CM-33-006, it MUST broadcast Add(CaseLedgerEntry) to the case's participants.

Replicas learn of a granted role only when they replay the announced entry (CM-02-016, RSH-08-004). Thus if the answer is not announced, the roles in every replica are out of date.
Extends: CM-33-006
CM-33-021 MUST NOT The CASE_MANAGER MUST NOT change any role when it commits a Reject of a role Offer.

A Reject declines the Offer, so the target's roles stay as they were.
Extends: CM-33-006
Vulnerability Items and References Offered to a Case

A participant proposes a new vulnerability item, a change to one, or a new case reference by offering it to the case. The CASE_MANAGER records the offer, then admits or declines it, and answers the sender either way; a deployment may admit offers automatically (ADR-0187). An item or reference offer is an Offer of the act it proposes: an Add of a new VulnerabilityItem to the case, an Update of one, or an Add of a new CaseReference to the case.

ID Priority Requirement Related
CM-34-001 MUST Not yet in the reference implementation (tracked by #6236)

A participant that proposes a new vulnerability item for a case MUST send the CASE_MANAGER an Offer whose object is an Add of the VulnerabilityItem with the case as the Add's target.

A participant's statement about what the case is about is a claim until the CASE_MANAGER admits it, as with the other things participants assert. Offering the act itself means the change the CASE_MANAGER applies on admission is exactly what the offered Add states, recorded as its own entry carrying the new item in full (CLP-07-021, ADR-0187).
CM-34-002 MUST Not yet in the reference implementation (tracked by #6237)

A participant that proposes a change to a vulnerability item MUST send the CASE_MANAGER an Offer whose object is an Update of that item.

A CVE ID is usually assigned after the item exists, so the case learns of it as a change to that item, a new ids entry whose system_name is CVE, not as a second item for the same vulnerability (ADR-0187).
CM-34-003 MUST Not yet in the reference implementation (tracked by #6236)

A participant proposing a new case reference MUST send the CASE_MANAGER an Offer of an Add that carries the CaseReference object and targets the case.

A reference is a claim about the case like an item, so it takes the same path (ADR-0187). The Add carries the CaseReference object, not its bare as:Link: a Link has no id, so the case could not list it, nor the ledger name it.
CM-34-004 MUST Not yet in the reference implementation (tracked by #6236)

The CASE_MANAGER MUST answer an item or reference offer with an Accept when it admits the offer and a Reject when it declines it.

The sender cannot tell an ignored offer from one still under review. An answer either way closes the ask (ADR-0187).
CM-34-005 MUST Not yet in the reference implementation (tracked by #6236)

When the CASE_MANAGER admits an item or reference offer, it MUST apply the offered change to the case and commit the change as its own ledger entry after the offer's entry.

Every change to the case file is its own entry, and replicas learn of items and references only from the entries they replay (CLP-07-013, CLP-07-021).
Extends: CLP-07-021
CM-34-006 MUST NOT Not yet in the reference implementation (tracked by #6236)

The CASE_MANAGER MUST NOT change the case when it declines an item or reference offer.

A decline means the claim was not admitted, so the case stays as it was.
CM-34-007 MUST Not yet in the reference implementation (tracked by #6237)

An admitted update of a vulnerability item MUST change only the fields it supplies, replacing a single-valued field and merging a list (CM-34-011).

This is the partial-update meaning ActivityStreams gives Update, so two admitted updates to different fields of one item both survive. A list is merged, not replaced, because a sender that holds a partial or stale view of the item would otherwise erase entries it cannot see (ADR-0187).
Refines: CM-34-011
CM-34-008 MUST Not yet in the reference implementation (tracked by #6237)

The CASE_MANAGER MUST decline an offered update of a vulnerability item the case does not hold.

An update needs an item to change. Admitting one for an unknown item would create the item by a path meant only for changes.
CM-34-009 MUST Not yet in the reference implementation (tracked by #6236)

The CASE_MANAGER MUST decline an item or reference offer from a sender that is not an active participant of the case.

Only the case's active participants may make claims about it, as with their other assertions (ADR-0187).
CM-34-010 MAY Not yet in the reference implementation (tracked by #6237)

A CASE_MANAGER MAY admit item and reference offers automatically.

Many deployments trust their participants' identifiers and references, and a human review of each would only delay the case. Others want the review, so admission is a choice, not a rule (ADR-0187).
CM-34-011 MUST Not yet in the reference implementation (tracked by #6237)

On admitting an offered update of a case-file object, the CASE_MANAGER MUST keep held list entries and append each supplied entry a list lacks.

A sender's view may be partial, such as a case preview (ADR-0217), or stale, and two updates may cross, so replacing a list would drop entries silently. An entry equal to a held one, or a reference with a held one's id, is not added again. Taking an entry out needs an act that names it, as removing a note from a case does; none exists yet for an item's lists (ADR-0187). A replica copies the result the ledger carries, so this binds only the admission.

CaseProposal Protocol

Requirements for the CaseProposal protocol flow, which separates the act of requesting case initialization from the act of creating the case. Covers the wire vocabulary type, the Create/Accept/Reject message flow, and the corresponding MessageSemantics values and received-side use cases.

Wire Vocabulary
ID Priority Requirement Related
CP-01-006 MAY A CaseProposal MAY include an optional summary field with a human-readable description of the proposal.

A person who reviews proposals at the Case Actor Service may need to know why the report receiver asks for a case. A short description gives that context. The field is optional because the proposal is complete without it.
CP-01-009 MAY The actor of Create(CaseProposal) MAY be the proposing actor's full actor profile inline, or a reference to that profile which the CASE_MANAGER dereferences by an API call (AKM-05-003, AKM-05-004).

The proposing actor becomes the CASE_OWNER (CP-09-001), and its published embargo policy lives on its profile (EP-01-001), in its own store, which the CASE_MANAGER cannot read (PCR-01-003). That policy is the CASE_OWNER's actor default at case creation (EP-04-003), so it has to reach case creation; whether the profile travels inline or is fetched is an implementation choice. This codebase sends the inline form and accepts either (CP-01-010).
Uses definition from: AKM-05-003
See also: AKM-05-004 — context for the reader
CP-01-011 MUST A CaseProposal MUST carry, as proposerCaseRoles, the CVD roles the proposing actor holds in a case it owns. An absent or empty proposerCaseRoles states no role beyond CASE_OWNER.

The CASE_MANAGER seats the proposer with these roles (CP-09-007) and has no other source for them: it may run in a different container, and it cannot read another actor's configuration or store (ADR-0073). Carrying them follows the rule CP-01-010 applies to the proposer's embargo policy.
Extends: CP-01-001
CP-01-012 MUST A Create(CaseProposal) whose proposerCaseRoles names CASE_MANAGER MUST be refused before anything is written, with a reason naming the fault.

Only the CaseActor holds CASE_MANAGER. A proposer that could state it would seat itself as the manager of the case it proposes.
Uses definition from: CP-01-011
Protocol Flow — Sending
ID Priority Requirement Related
CP-04-001 MUST A report receiver that wishes to request case initialization at a dedicated case-actor service MUST send Create(CaseProposal) to the case-actor service's inbox, with actor set to the receiver's own URI.

Using Create with the report receiver as actor accurately declares that the receiver created the proposal object, not the case itself. Sending Create(VulnerabilityCase) from the receiver would violate AS2 semantics because the receiver is not the authoritative creator of the case.
CP-04-003 MUST A report receiver MUST address Create(CaseProposal) to the case-actor service's own actor identity, never to an identity derived per case or per report. That identity exists before the report does.

A derived identity names an actor that no container hosts. The sender computes it, so no container has registered it, and delivery to it fails with a permanent 404. It also cannot be set up in advance, because the sender can compute it only after the report exists, and by then the proposal is already sent. A container identity comes from configuration, so the container can register it once, when it is seeded. The proposal loses nothing: it carries its report (CP-01-004), and every later case-scoped message carries activity.context.
Refines: CP-04-001
Derives from: BT-10-008
Protocol Flow — Receiving (Case-Actor Side)
ID Priority Requirement Related
CP-05-002 MUST The case-actor service MUST evaluate each Create(CaseProposal) it receives and either accept or reject the proposal, emitting an Accept(CaseProposal) or Reject(CaseProposal) activity accordingly.

A report receiver that sends a proposal treats the case as absent until the CASE_MANAGER's Create(VulnerabilityCase) arrives (PCR-01-003), and it holds the proposal open until an answer comes (CP-06-003). If the CASE_MANAGER stays silent, the receiver waits until its deadline (CP-05-007). Each proposal needs a decision because the CASE_MANAGER can refuse one, for example a proposal for a fully closed case (CP-05-008).
CP-05-003 MUST When accepting a proposal, the case-actor service MUST send two activities in sequence: first Accept(CaseProposal) (with the CaseProposal, inline or by reference, as object), then Create(VulnerabilityCase) (with actor set to the case-actor URI, context set to the URI of the new VulnerabilityCase, and inReplyTo set to the URI of the Accept(CaseProposal) activity).

Accept(CaseProposal) acknowledges the report receiver's proposal. Create(VulnerabilityCase) with actor=case-actor preserves AS2 "I created this" semantics: only the authoritative creator MUST be the actor of a Create activity. context MUST be the case URI (consistent with all other case-scoped activities; required for inbox deferral routing). in_reply_to carries the causal antecedent (the Accept URI) in the AS2-correct field for responses. See ADR-0045.
CP-05-004 MUST When rejecting a proposal, the case-actor service MUST send Reject(CaseProposal) with the CaseProposal, inline or by reference, as object.

The Reject is how the report receiver learns that no case will be created for its proposal, so it can stop waiting (CP-06-004). The object names which proposal the answer is for, because one receiver can have more than one proposal open.
CP-05-005 MUST The case-actor service MUST queue Accept(CaseProposal) and Create(VulnerabilityCase) for an accepted proposal together or not at all, never sending the Accept without the Create.

The two sends are not atomic on the network, so they are made atomic where they are queued: an Accept with no Create behind it tells the report receiver of a case nothing announces. Once both are queued, the outbox retries each one, so a failed Create needs no retry of its own. A second Accept reads as a second, independent decision.
CP-05-011 MUST The case-actor service MUST retry each queued Accept(CaseProposal) and Create(VulnerabilityCase) until it is delivered or its delivery attempts are exhausted (OX-13).

The two sends are made atomic where they are queued, not on the network. Once both are queued, the outbox retries each one, so a failed Create needs no retry of its own and still reaches the report receiver.
Extends: CP-05-005
CP-05-012 MUST On a retry or re-send, the case-actor service MUST send the same Accept(CaseProposal) under its original identifier, never a second one (CP-05-006).

The Accept is irrevocable once sent. A second Accept under a new identifier reads as a second, independent decision, which the report receiver cannot tell from the first.
Extends: CP-05-005
See also: CP-05-006 — context for the reader
CP-05-006 MUST For a duplicate Create(CaseProposal) of a proposal it has already accepted, the CASE_MANAGER MUST re-send the stored Accept(CaseProposal) unchanged, with its original identifier. The one exception is a fully closed case (CP-05-014). A duplicate carries the same proposal identifier.

A duplicate proposal is the only signal the CASE_MANAGER gets that its acceptance was lost, so the answer to it is how the proposer recovers. The stored original, sent again unchanged (VM-08-003), reads as the first acceptance arriving late. A new Accept reads as a second, independent decision, which CP-05-005's irrevocability rule forbids.
Refines: ASK-08-001
CP-05-013 MUST NOT The CASE_MANAGER MUST NOT create a second VulnerabilityCase for a duplicate Create(CaseProposal) of a proposal it has already accepted.

A duplicate is a re-delivery of an ask already answered, not a new ask. A second case for it would split the one proposal's coordination across two cases.
Extends: CP-05-006
CP-05-014 MUST This rule covers a duplicate of an accepted proposal whose case is fully closed, with the CASE_MANAGER's own RM.CLOSED status entry in its ledger (CM-23-013). The CASE_MANAGER MUST answer that duplicate with Reject(CaseProposal).

The stored Accept would reach the accept path, which writes to the case, and a fully closed case accepts no writes (CM-23-013). The Reject declines only the re-delivery: it does not revoke the stored Accept (CP-05-005).
Supersedes: CP-05-006
Uses definition from: CM-23-013
CP-05-015 MUST NOT For a duplicate under CP-05-014, the CASE_MANAGER MUST NOT commit any CaseLedgerEntry for the closed case or change its state (CM-23-013).

A fully closed case accepts no further writes (CM-23-013, ADR-0085). The decline is recorded on the proposal, so declining needs no write to the case.
Extends: CP-05-014
Refines: CM-23-013
CP-05-007 MUST Not yet in the reference implementation (tracked by #2890)

A report receiver that has sent Create(CaseProposal) and has no reply by the proposal's deadline MUST stop waiting and treat the proposal as expired. A reply is an Accept(CaseProposal) or a Reject(CaseProposal).

Without a deadline, a lost Accept stops the handshake for good, because no party waits with a timeout. The proposal is an ask (ASK-01-001), so it carries a deadline (ASK-03-004) and the report receiver records it with its other outstanding asks (ASK-04-001). That record belongs to the actor, so it works before a case exists. To propose again is a new decision, not an automatic retry (ASK-05-005), and a repeated proposal is also how the CASE_MANAGER gets a chance to answer again (CP-05-006).
Refines: ASK-05-001
CP-05-008 MUST The case-actor service MUST subject a Create(CaseProposal) under a new proposal identifier to the admission decision (CP-05-002), even when its report already has a case. That decision begins with the closed-case decline of CP-05-018.

The report identifier is chosen by the sender. A reuse keyed on the report alone lets a proposer join another party's case by naming its report, and collapses the one-case-per-recipient rule (CBT-06-002) into a shared case. The proposer is the second half of the key that makes the reuse safe: the same proposer re-proposing after its first proposal expired (CP-05-007) converges on its own case, and a different proposer gets its own.
Refines: CP-05-002
CP-05-016 MUST The case-actor service MUST answer each Create(CaseProposal) under a new identifier with its own Accept(CaseProposal) or Reject(CaseProposal), even if its report has a case.

A new proposal identifier is a new request the proposer is tracking on its own (CP-05-007). The stored answer to an earlier proposal does not answer it.
Extends: CP-05-008
CP-05-017 MUST This rule covers a new proposal whose proposer owns the report's existing case. The case-actor service MUST reuse that case, never creating a second VulnerabilityCase. The one exception is a fully closed case (CP-05-018).

The same proposer re-proposing after its first proposal expired (CP-05-007) converges on its own case. The proposer is the second half of the key that makes the reuse safe.
Extends: CP-05-008
CP-05-018 MUST This rule covers a new proposal whose proposer owns the report's existing case, when that case is fully closed. A case is fully closed when its ledger holds the CASE_MANAGER's own RM.CLOSED status entry. The case-actor service MUST answer the proposal with Reject(CaseProposal), deciding so before any other step of the admission decision.

A fully closed case accepts no further writes (CM-23-013, ADR-0085), so the owner's new proposal is declined rather than answered from the closed case. The closure is part of the admission decision and comes first, because no answer from the rest of the decision can change the Reject (ADR-0131).
Extends: CP-05-008
Uses definition from: CM-23-013
Supersedes: CP-05-017
CP-05-019 MUST NOT For a new proposal declined under CP-05-018, the case-actor service MUST NOT commit any CaseLedgerEntry for the closed case or change its state (CM-23-013).

The decline is recorded on the proposal, not the case, so writing it is neither a CaseLedgerEntry nor a change to case or participant state. CM-23-013 bars every write to a fully closed case.
Extends: CP-05-018
Refines: CM-23-013
CP-05-020 MUST This rule covers a new proposal whose proposer does not own the report's existing case. The case-actor service MUST create a separate case for it, never adding the proposer to the existing case.

The report identifier is chosen by the sender. A reuse keyed on the report alone lets a proposer join another party's case by naming its report, and collapses the one-case-per-recipient rule (CBT-06-002) into a shared case.
Extends: CP-05-008
CP-05-010 MUST The CASE_MANAGER MUST act on a Create(CaseProposal) under a proposal identifier it has already recorded only when the sender is that identifier's recorded proposer. Acting on it means admitting, declining or storing the proposal. A proposal identifier it has not recorded is a new proposal, which any actor may send (CP-05-002).

The sender chooses the proposal identifier, and every record the CASE_MANAGER keys on a proposal uses that identifier alone. If any sender could reuse an admitted identifier, the CASE_MANAGER would treat the delivery as a redelivery: the other actor could get a stray case, or a closed case's decline could be recorded under the first proposer's identifier.
Refines: HP-01-006
See also: CP-05-002 — context for the reader
CP-05-022 MUST The CASE_MANAGER MUST refuse without effect a Create(CaseProposal) that reuses a recorded proposal identifier from any sender but its recorded proposer. Without effect means no case created, no proposal-keyed record written and nothing sent.

If the refusal left any effect, another actor could get a stray case, or record a closed case's decline under the first proposer's identifier, by reusing that identifier.
Extends: CP-05-010
Protocol Flow — Receiving (Report-Receiver Side)
ID Priority Requirement Related
CP-06-005 MUST The report receiver MUST act on Accept(CaseProposal) or Reject(CaseProposal) only when the sender is the actor it addressed the CaseProposal to (CP-06-006).

The accept handler records the replying actor as the report's CASE_MANAGER, and routing and Announce trust both read that record. If the report receiver acted on a reply from any sender, an actor that knows a report id could redirect the receiver's case traffic to itself.
Refines: HP-01-006
Depends on: CP-06-006
CP-06-006 MUST The report receiver MUST record the actor it addressed each CaseProposal to.

The sender check of CP-06-005 compares each reply's sender with this record. A receiver that kept no record could only trust what the reply claims about itself.
CP-06-007 MUST NOT Once a case is established for the report, the report receiver MUST NOT let a reply to the proposal replace the trusted CASE_MANAGER.

Routing and Announce trust read the trusted CASE_MANAGER from the report's case link. A late reply that could rewrite it, even from the addressee, would move trust away from the actor that created the case.
Extends: CP-06-005
CP-06-008 MUST The report receiver MUST refuse a reply to its proposal from any other sender, leaving the report's case link unchanged.

An actor that knows a report id could otherwise redirect the receiver's case traffic to itself. Leaving the link unchanged keeps a refused reply from having any effect.
Extends: CP-06-005
CASE_MANAGER-Authoritative Initialization on Accept(CaseProposal)

Requirements for the CASE_MANAGER to perform all case initialization natively when accepting a CaseProposal, per ADR-0041. These replace the receiver-side case-creation and prologue back-fill that ADR-0015 introduced.

ID Priority Requirement Related
CP-09-001 MUST When the CASE_MANAGER accepts a Create(CaseProposal), it MUST create the VulnerabilityCase in its own store, with attributedTo naming the proposing actor, never itself. The proposing actor is the report receiver, who becomes the CASE_OWNER.

The CASE_MANAGER is the case's authoritative creator, so the case starts in its store (CP-09-005). attributed_to records the Case Owner (CM-02-008), which ownership checks and ownership transfer read and write (MSM-07-027, CM-21-024). AS2 carries "I created this" on the actor of Create(X) (ADR-0023), not on the object's attributedTo, so the CASE_MANAGER's creation and the report receiver's ownership are both recorded without conflict (ADR-0041).
Extends: CP-05-003
Refines: CM-02-008
CP-09-011 MUST When the CASE_MANAGER accepts a Create(CaseProposal), it MUST itself be the actor of the Create(VulnerabilityCase) it emits.

AS2's "I created this" is carried by the actor of Create(X) (ADR-0023). The CASE_MANAGER creates the case, so it is the actor, while the created object's attributedTo names the owner (ADR-0041).
Extends: CP-09-001
CP-09-002 MUST When the CASE_MANAGER creates the VulnerabilityCase on proposal acceptance, it MUST add the report receiver as a CASE_OWNER participant at RM.RECEIVED and the reporter as a participant at RM.ACCEPTED to the case.

The receiver's replica is seeded from the embedded participant objects in Create(VulnerabilityCase). If participants are absent at emission time the replica starts with no participant records and downstream operations that require them (e.g. embargo consent, role guards) fail. Hard-coding CVDRole.VENDOR for the receiver additionally mislabels coordinators, which makes VFD fix-lifecycle checks demand a fix they never produce.
Extends: CP-09-001
CP-09-007 MUST The CASE_MANAGER MUST seat the report receiver with only the additional CVD roles its proposal states in proposerCaseRoles (CP-01-011), never roles from its own configuration.

Only the report receiver knows the roles it holds; a report receiver may be a coordinator rather than a vendor, so role inference is unsound. The CASE_MANAGER is a different actor and may run elsewhere, so nothing it holds of its own says anything about the receiver (ADR-0133).
Extends: CP-09-002
Uses definition from: CP-01-011
CP-09-008 MUST NOT Additional CVD roles for the report receiver MUST NOT be inferred.

Inferring roles (e.g. hard-coding CVDRole.VENDOR) mislabels coordinators and causes VFD fix-lifecycle checks to demand a fix they never produce.
Extends: CP-09-007
CP-09-003 MUST The CASE_MANAGER MUST initialize the default embargo for the new case before emitting Create(VulnerabilityCase).

Embargo state is protocol-significant. Deferring initialization to the report receiver or to a later message would produce a window in which embargo-gated operations are undefined (ADR-0041). The CASE_MANAGER is the only actor that can initialize it authoritatively at case creation; the actor default it applies is the CASE_OWNER's policy, carried on the proposal (CP-01-009, CP-01-010).
CP-09-004 MUST The Create(VulnerabilityCase) activity emitted by the CASE_MANAGER MUST carry the case's participant records inline, so that the report receiver can seed its replica's participants (CP-09-002).

The report receiver seeds its Participant Case Replica from the Create(VulnerabilityCase), and it cannot read the CASE_MANAGER's store (PCR-01-003). Without the participant records, the replica starts with no participants, and checks that need them, such as role checks and embargo consent, fail. It seeds from this Create before it trusts the CASE_MANAGER, so it has no trusted source to fetch a record from (CBT-01-007, ADR-0170).
Extends: CP-09-002
CP-09-009 MUST When the CASE_MANAGER accepts a Create(CaseProposal), it MUST enqueue Accept(CaseProposal) and Create(VulnerabilityCase) before it fans out any Add(CaseLedgerEntry) for the new case. The canonical ledger entries that record the initialization are committed after the Create(VulnerabilityCase) is queued, so that every recipient holds the case object before its first ledger entry arrives.

The outbox is FIFO (OX-01-002), so the order of the queue is the order on the wire. If a ledger entry is committed before the Create is queued, its Add reaches each recipient before the case does. Each recipient then holds an entry for a case it does not have and takes the SYNC-15 path for such entries (hold the entry, Reject, replay from the genesis entry), while the Create waits behind the whole fan-out. That path, meant for recovery, would then run for every case creation and delay the Create. This is CM-14-011's rule applied to the CASE_MANAGER path: the receiver must hold the case object before any fan-out that references it. It is also SYNC-09-002's order: the entries record a case whose creation was sent, and only the Add(CaseLedgerEntry) fan-out follows the commit. The create-case trigger uses the same order. On both paths, the case, its records, the queued Accept and Create, and every creation entry are written in one DataLayer transaction (ADR-0146). If any creation entry fails, all of them roll back before delivery is told of either activity (DL-02-004, CLP-07-013). If the Create were held back until after the commit, the genesis entry's fan-out would go ahead of it, which is the path this rule prevents.
Extends: CP-05-003

Participant Role Management

Defines the API for reading and mutating CVD roles on CaseParticipant, the one participant class shared by the core domain and the wire layer (ADR-0211). Requires the role-management methods, prohibits direct attribute mutation after construction, and mandates test coverage for each method.

Assertion Authority and On-Behalf Exceptions
ID Priority Requirement Related
PRM-06-001 MUST Participant status is self-declaratory by default: each participant asserts its own RM and VFD state without external approval. This is why they are participant status items (ADR-0121). The one write about a participant that the participant does not make is its birth: the CASE_MANAGER creates the record at RM RECEIVED (and VF vf for a vendor) when it sends the stub Invite (CM-11-006, ADR-0114).

The self-declaratory model keeps state authority with the role holder. Deviations must be narrow, externally evidenced, and explicitly named (ADR-0121).
See also: CM-11-006 — context for the reader
PRM-06-002 MUST NOT A participant holding the VENDOR role MUST NOT self-report a vendor-fix state of vf (vendor unaware). A vendor's valid self-reports are Vf and VF. The only vf a vendor participant carries is the one the CASE_MANAGER writes when the stub Invite creates its record (CM-11-006); any reply to that Invite sets V (CM-11-009) (ADR-0121, ADR-0114).

A vendor that has answered its Invite, or otherwise acknowledged a message about the case, is aware of it. Allowing a vendor to self-report the vendor-unaware state would create an impossible protocol record.
See also: CM-11-006 — context for the reader
See also: CM-11-009 — context for the reader
PRM-06-003 MAY A CASE_MANAGER or Case Owner MAY assert v→V (Vf) on behalf of a Vendor-role participant when the notification or invite is evidenced. Any vendor acknowledgement, including Read(Invite(VulnerabilityCase preview)[target=Actor]), is evidence. The target is typically an inert invitee that has not yet replied, and it must already be a participant (PRM-06-006). This move is the whole of what the status asserts: it cannot be asserted in the same status as the d→D of PRM-06-004.

Without this path, the case cannot record that an invited vendor is aware until the vendor replies to the Invite. A vendor acknowledgement already shows that the vendor is aware. The stub Invite creates the record (ADR-0114), so the assertion has a target. RM stays the same, so the assertion does not speak for the report decisions of the vendor. The pair with d→D is excluded: together they are VfD, which CSB-17-001 does not enumerate, and PRM-06-008 already has the entailments refuse it.
PRM-06-007 MUST NOT An on-behalf v→V write by a CASE_MANAGER or Case Owner MUST NOT change the target's RM state (ADR-0121).

RM records the vendor's own report decisions. The on-behalf assertion speaks only for the vendor's awareness, which its acknowledgement shows, so it leaves RM where the vendor put it. This holds for an inert invitee written before it replies (CM-11-029): awareness of the case is not a decision about it.
Extends: PRM-06-003
PRM-06-004 MAY A CASE_MANAGER or Case Owner MAY assert d→D (D) on behalf of a Deployer-role participant, under the same externally-evidenced pattern as PRM-06-003. The target must already be a participant (PRM-06-006). This move is the whole of what the status asserts: it cannot be asserted in the same status as the v→V of PRM-06-003.

Usually the deployer reports its own deployment. But a deployer that joined and has since gone quiet can leave the case unable to record a deployment the case has evidence of. The on-behalf limit keeps this narrow exception from becoming a general proxy capability, and a deployer that did not join is not in the case at all. The pair with v→V is excluded: together they are VfD, which CSB-17-001 does not enumerate, and PRM-06-008 already has the entailments refuse it.
Uses definition from: PRM-06-003
PRM-06-008 MUST The actor processing an on-behalf d→D assertion MUST apply the cross-machine entailments, so it succeeds only for a deployer whose RM state fits deployment.

The on-behalf path is an exception to self-declaration, not a way around the rules every status write obeys. Without the entailments, it could record a deployment for a deployer that never accepted the report.
Extends: PRM-06-004
PRM-06-006 MUST An actor processing an on-behalf status assertion MUST refuse it before any write if its target is not a case participant, creating no participant.

A status update is never a way into a case; joining is the Invite flow (CM-11, ADR-0114). If a status update creates the participant that it names, it is a second path into a case. That path skips the Invite flow and its consent and entitlement checks. If the record is created before the status write, and the write is then refused, a stray participant stays. For example, the RM-to-D entailment refuses d to D for a target that did not accept the report.
Constrains: PRM-06-003
Constrains: PRM-06-004
PRM-06-005 MUST NOT The f→F transition (fix ready, VF) MUST NOT be asserted by any actor other than the Vendor-role holder. Fix readiness is not externally knowable; no on-behalf assertion is ever permitted for this transition (ADR-0121).

Allowing a non-vendor to assert fix-readiness would let the CASE_MANAGER fabricate protocol-visible fix state, undermining the meaning of the F event.

Protocol Asks and Outstanding-Ask Registers

Requirements for the protocol-ask primitive: how an actor requests something it lacks authority to do, how outstanding asks are recorded and enumerated in both directions, how asks expire, and how a receiver reports that it could not process an inbound message. Derived from ADR-0080 and the G01 planning session (CONCERN-2829).

Ask and Terminate

An ask is an ordinary protocol message that completes the asking behavior. Nothing suspends awaiting a reply.

ID Priority Requirement Related
ASK-01-001 MUST Not yet in the reference implementation (tracked by #2885)

An actor that cannot perform an action on its own authority MUST request authorization with an ask activity addressed to the authorizing actor.

Separates requesting authority from holding it, so the action cannot occur on the asker's own initiative.
ASK-01-005 MUST NOT An actor that asks for authorization of an action MUST NOT perform the action before it has recorded a reply that authorizes it.

An ask suspends nothing, so the action would otherwise run on the asker's own initiative while the answer is still pending.
Extends: ASK-01-001
ASK-01-004 MUST Not yet in the reference implementation (tracked by #2883)

An actor MUST determine the action that a reply authorizes from the ask the reply answers, not from the content of the reply.

Generalizes ADR-0026's trust rule; reading the action from the reply lets the answerer unilaterally alter what it authorizes.
Conversation-State Routing

A gated interaction is one tree that determines where the conversation stands before taking any action.

ID Priority Requirement Related
ASK-02-003 MUST Not yet in the reference implementation (tracked by #2883)

When an ask for the same kind and subject is already outstanding and unexpired, the actor MUST NOT emit a second ask.

Re-asking an open question produces duplicate decisions for the answerer and duplicate register entries for the asker.
ASK-02-004 MUST NOT An actor MUST NOT decide whether a gated action is authorized from its record of outstanding asks, but only from the case ledger.

The register is a working set that may be rebuilt or corrupted; making it authoritative for authorization would let a forged entry permit an action.
ASK-02-005 MUST Not yet in the reference implementation (tracked by #2885)

While an ask for authorization (ASK-01-001) is outstanding, the asking actor MUST leave the case in a state the protocol defines.

An ask suspends nothing, so the case sits in the pre-authorization state for the whole deadline; that state must be legitimate.
Uses definition from: ASK-01-001
ASK-02-006 MUST Not yet in the reference implementation (tracked by #2885)

An actor MUST refuse, not ask about, an action whose not-yet-authorized state the protocol cannot represent.

Asking would leave the case in an undefined state for the whole ask deadline (ASK-02-005), so such an action can only be refused.
Derives from: ASK-02-005
Ask Kinds

Each kind of ask declares the replies that close it, its expiry consequence, and a default deadline.

ID Priority Requirement Related
ASK-03-001 MUST Not yet in the reference implementation (tracked by #2884)

Each ask kind MUST declare the set of reply semantic types that close it.

Pairing a reply to an ask requires a declared closing set rather than hard-coded reply names at call sites; ProtocolPair already carries this field.
ASK-03-002 MUST Each ask kind MUST declare whether a reply arriving after the ask's deadline authorizes the action (stale) or does not (void).

Admitting a participant remains useful when authorized late; adopting a case status does not, because the case state the decision was made against has moved on.
ASK-03-003 MUST NOT The expiry consequence of an ask kind MUST NOT be deployment-configurable.

Two actors disagreeing about whether a late reply authorized an action is a divergence in canonical case state, not a deployment preference.
ASK-03-009 MUST NOT An ask activity MUST NOT carry the expiry consequence of its ask kind.

Letting the asker declare the expiry consequence would let it extend its own authorization, and two actors could then disagree about a late reply.
Extends: ASK-03-003
ASK-03-004 MUST Not yet in the reference implementation (tracked by #2884)

An ask activity MUST carry its own deadline in the AS2 endTime field.

Placing the deadline on the wire means the answerer reads the same value as the asker, so a configurable duration cannot cause disagreement.
ASK-03-006 MUST NOT Not yet in the reference implementation (tracked by #2884)

An action gated by an ask whose kind declares void expiry MUST NOT be performed on the strength of a reply recorded after the ask's deadline.

An authorization granted against a case state that no longer holds is a standing permission, which is the hazard ADR-0026's trust rule addresses in the identity dimension.
ASK-03-007 MUST Not yet in the reference implementation (tracked by #2884 and #3918)

Invite(EmbargoEvent) is an ask kind. Its closing replies are Accept(Invite(EmbargoEvent)) and Reject(Invite(EmbargoEvent)) from the invitee; its deadline is the Invite's endTime (CM-28-001, CM-28-012); its expiry consequence is stale, not void: a reply after the deadline is still honoured under EMB-17 once the expiry has been recorded as TIMED_OUT (CM-18-002).

The embargo invitation already has every property an ask kind declares, and the relay (EP-09) emits one per participant per proposal, so the outstanding-ask register must track it without a special case. Declaring the kind here keeps find_protocol_pair's one-open-request assumption from being applied to N simultaneous Invites of one semantic type.
Uses definition from: CM-28-001
Uses definition from: CM-18-002
See also: CM-28-012 — context for the reader
ASK-03-008 MUST Invite(VulnerabilityCase preview)[target=Actor] (the stub Invite) is an ask kind. Its closing replies are Accept(Invite(VulnerabilityCase preview)[target=Actor]) and Reject(Invite(VulnerabilityCase preview)[target=Actor]) from the invitee; its deadline is the Invite's endTime (CM-11-014); its expiry consequence is stale, not void: expiry only means the CASE_MANAGER stops waiting, so a reply that arrives after the deadline is processed like a live one (an Accept joins the invitee, a Reject closes the record). Expiry closes the ask only; it writes no participant state and refuses no later reply (CM-11-014).

The hazard a late Accept could carry is joining on stale embargo terms, and the supersede rule already covers it: an embargo change or a re-invite replaces the stub, naming the old one in inReplyTo, and an Accept of a superseded stub is refused (CM-11-045). Voiding a late reply would add no protection and would turn away an invitee that answered after the CASE_MANAGER stopped waiting.
Uses definition from: CM-11-014
Outstanding-Ask Register

A durable, actor-scoped record of asks outstanding in both directions.

ID Priority Requirement Related
ASK-04-010 MUST Not yet in the reference implementation (tracked by #2883 and #3918)

This rule covers the CASE_MANAGER relaying an ask on a participant's behalf (CM-24-001, CM-24-002; EP-09-002). It MUST record each relayed ask in its own outstanding-ask register as the asker.

ASK-04-001 says the emitter records; a relayed Invite's actor is the CASE_MANAGER with the proposer in attributedTo, so the manager is the emitter and the one that owes the bookkeeping.
Uses definition from: CM-24-001
See also: CM-24-002 — context for the reader
See also: EP-09-002 — context for the reader
ASK-04-013 MUST NOT Not yet in the reference implementation (tracked by #2883 and #3918)

A participant whose proposal the CASE_MANAGER relays MUST NOT record the relayed Invites in its outstanding-ask register. It records only its own proposal to the CASE_MANAGER.

The participant did not emit the relayed Invites (ASK-04-001). Giving it a register entry for each one would let it reap or re-ask on the manager's behalf.
Extends: ASK-04-010
Expiry and Reaping

How an expired ask is noticed, given that elapsed time is not an event.

ID Priority Requirement Related
ASK-05-004 MUST NOT Not yet in the reference implementation (tracked by #2887)

Reaping an expired ask MUST NOT re-emit it automatically.

Mirrors CLP-06-005 — a timeout is a signal, not an instruction to retry.
ASK-05-005 MUST Not yet in the reference implementation (tracked by #2887)

After an ask expires, the actor MUST re-ask only when it decides anew to perform the gated action.

The tree owns the decision because only it knows whether the action is still wanted.
Extends: ASK-05-004
Ask Visibility

Asks replicate like any other canonical entry, which constrains what they may carry.

ID Priority Requirement Related
ASK-06-001 MUST Not yet in the reference implementation (tracked by #2883)

A case-scoped ask MUST be recorded as a canonical CaseLedgerEntry.

An outstanding decision, and a stalled one, is protocol-relevant to every participant.
ASK-06-003 MUST Not yet in the reference implementation (tracked by #2883)

The ledger entry of a case-scoped ask MUST replicate to case participants on the normal fan-out path.

Every participant needs to see an outstanding decision. A directed-delivery variant would require redaction with proofs, which does not exist.
Extends: ASK-06-001
ASK-06-002 MUST NOT Not yet in the reference implementation (tracked by #2883)

An ask MUST NOT carry content that cannot be disclosed to every participant of its case.

Asks replicate to all participants (ASK-06-001), so private rationale must travel by a directed Note instead.
Processing Faults

How a receiver tells an authenticated sender that it could not process what was sent.

ID Priority Requirement Related
ASK-07-001 MUST An actor that cannot process an inbound activity from an authenticated sender MUST notify that sender by emitting Create(ProcessingFault). The exception is an inbound Create(ProcessingFault), which ASK-07-019 leaves unanswered.

Without a notice, a failure that took milliseconds costs the sender its full ask deadline in silence.
ASK-07-002 MUST NOT An actor MUST NOT emit a processing fault in response to an inbound activity whose sender is not authenticated, or whose failure occurred before authentication.

Explaining a parse or validation failure to an unauthenticated sender is a parser oracle, and an unauthenticated sender identity cannot be trusted as a reply address.
ASK-07-003 MUST ProcessingFault MUST be a single dedicated object type carrying a machine-readable failure class, rather than a reason field on an existing reply activity.

SE-08-003 prefers a dedicated object type over field-level discrimination; Reject additionally presupposes a rejectable object, which unreadable traffic does not provide.
ASK-07-004 MUST ProcessingFault MUST identify the activity that failed by reference.

A reference names the failed activity without the receiver having to rebuild or echo it.
ASK-07-012 MUST NOT ProcessingFault MUST NOT require an inline copy of the activity that failed.

When a payload fails validation, a typed copy of it cannot be constructed — constructing it is what failed — and echoing sender-supplied content is a reflection hazard.
Extends: ASK-07-004
ASK-07-005 MUST Each failure class of ProcessingFault MUST be identified by a URI minted in the Vultron namespace.

A URI-identified, dereferenceable problem type is extensible without a schema change and lets a receiver that does not recognise a class resolve its meaning.
ASK-07-013 MUST Not yet in the reference implementation (tracked by #2889)

A ProcessingFault MUST be structured according to RFC 9457 Problem Details.

RFC 9457 is the standard for machine-readable error reporting over HTTP.
Extends: ASK-07-005
ASK-07-006 MUST NOT ProcessingFault MUST NOT carry implementation diagnostics such as stack traces, parser internals, or the identity of the failing code path.

Faults replicate to all case participants and are also read by an untrusted-by-default peer; the diagnosis of a failure belongs in the actor's own log, governed by specs/structured-logging.yaml.
ASK-07-007 MUST Not yet in the reference implementation (tracked by #2889)

Receiving a processing fault that refers to an outstanding ask MUST close that ask's register entry.

The exchange cannot complete, so leaving the entry open costs the asker its whole deadline for a failure already reported.
ASK-07-008 MUST NOT A processing fault MUST NOT be recorded as a canonical CaseLedgerEntry, by the actor that sends it or by the CASE_MANAGER that receives it.

A fault reports how a message was handled and changes nothing in the case (CLP-02-013). Its sender already holds its own record of the failed message, so an entry adds no fact that a case holder needs. A ledgered fault also loops for a fault about applying a ledger entry, because the replica that sent it cannot apply the entry that records it (SYNC-16-002).
ASK-07-009 MUST NOT The activity that could not be processed MUST NOT be recorded as a canonical CaseLedgerEntry.

There is no legible assertion to record; a snapshot of an unreadable payload cannot satisfy CLP-02-003, and CLP-03-002 already excludes unrouteable inbound from the ledger.
ASK-07-010 MUST This rule covers a receiver that fails on its own internal error while it processes an inbound activity from an authenticated sender. The receiver MUST answer that sender with an internal-error Create(ProcessingFault). It sends the fault only after it has undone every change the failed processing made. The exception is an inbound Create(ProcessingFault), which ASK-07-019 leaves unanswered.

A failed received act keeps only intake's record, in holding (CLP-07-015, CLP-10-074), and the inbox answered before processing, so without this fault the sender waits out its ask deadline in silence. Emitting after the rollback keeps the fault from being undone with the act. The fault is never ledgered (ASK-07-008), as for any fault.
Refines: ASK-07-001
ASK-07-014 MUST NOT A receiver MUST NOT answer a failure that it will retry until it stops retrying that failure.

Answering only when no retry follows keeps a retry that later succeeds from sending a false fault that closes the ask early (ASK-07-007).
Extends: ASK-07-010
ASK-07-015 MUST NOT A repeated failure of the same activity MUST NOT produce a second fault. A fault sent again carries the identifier of the first.

One fault per failed activity answers the sender once, however often the activity fails.
Extends: ASK-07-010
ASK-07-019 MUST NOT An actor MUST NOT answer a received Create(ProcessingFault) with another Create(ProcessingFault), whatever the reason it cannot process the fault.

Each answering fault is a new activity, so the one-fault-per-activity bound (ASK-07-015) does not stop the exchange. Two actors that cannot process each other's faults, such as two actors that do not hold the case a fault names, would otherwise answer each other without end.
Supersedes: ASK-07-001
Supersedes: ASK-07-010
Supersedes: ASK-07-011
Lost-Reply Recovery

What an answerer does when a request is repeated because its reply was lost.

ID Priority Requirement Related
ASK-08-001 MUST An actor that receives a duplicate request it has already replied to MUST re-send its stored reply unchanged, with its original identity, rather than producing a new reply.

Re-sending the frozen original (VM-08-003) reads to the requester as the original arriving late rather than a second decision, which is what CP-05-012's irrevocability rule requires.
ASK-08-002 MUST NOT An actor that receives a duplicate request it has already replied to MUST NOT create a second instance of the object the request concerned.

A repeated proposal after acceptance is a re-send, not a new request; treating it as new produces duplicate cases or duplicate participants.

14.5 Case Ledger and Replication

The requirements on the case ledger and its copies: how the CASE_MANAGER records case events, how the ledger is synchronized, how a participant keeps its case replica, and the trust a new replica starts from.

Case Ledger Processing

Requirements for participant assertions, CASE_MANAGER canonicalization, local case audit ledgering, recorded-history projection, and replication-facing CaseLedgerEntry objects. Covers the commit authorization model, per-case genesis hash derivation, the canonical entry criteria that separate the case ledger from the process log, the CASE_MANAGER inbox routing path that enables ledger entry authorship, and the causal-ordering model that makes log_index order the authoritative causal sequence.

Assertion Intake
ID Priority Requirement Related
CLP-01-001 MUST Non-CASE_MANAGER activities that participate in a report, proto-case, or case workflow MUST be treated as participant assertions awaiting CASE_MANAGER processing

A participant can only claim that it did something. Only the CASE_MANAGER can make that claim part of the shared case history. If a receiver treats a participant's activity as settled fact, two receivers can disagree about the same case. Treating it as an assertion keeps one place where the case history is decided.
CLP-01-002 MUST A receiver MUST read a participant's ordinary activity in a case or proto-case flow as an assertion from the sender's role and the message's path alone; the protocol defines no separate "asserted mode" marker for it.

The sender's role and the path of the message already show that a participant's activity is an assertion. A separate marker adds a field that every sender must set and every receiver must check, and a missing marker would then change the meaning of an ordinary message.
CLP-01-003 MUST The CASE_MANAGER MUST be the only actor that emits canonical case-history entries used by replicas

Replicas agree only when they copy one history. If more than one actor can write entries that replicas apply, two actors can write different entries at the same position, and the replicas fork. One writer gives one order with no consensus step.
CLP-01-004 MUST NOT Participant replicas MUST NOT project shared case state directly from peer assertions

A peer's activity is an assertion that the CASE_MANAGER has not yet admitted. A replica that applies it directly can hold state that the ledger never records, so it drifts from every other replica. Replicas stay equal only when each change comes from a ledger entry.
Canonical CaseLedgerEntry
ID Priority Requirement Related
CLP-02-001 MUST For each case-resolvable assertion the CASE_MANAGER admits at the case layer, it MUST append a canonical CaseLedgerEntry

The ledger is the case history that every replica copies. An admitted assertion with no entry changes the case at the CASE_MANAGER only, and no replica can learn of it. One entry for each admitted assertion keeps the replicas complete.
CLP-02-002 MUST CaseLedgerEntry MUST be a canonical content object distinct from any transport envelope used to replicate it

The transport envelope changes from one delivery to the next. It has a different id, recipient and time each time. The hash chain must cover content that is the same for every holder. If the entry and its envelope are one object, a redelivery changes the content that the hash covers.
CLP-02-003 MUST CaseLedgerEntry MUST include the asserted activity payload as its payloadSnapshot, containing all fields required for deterministic replay: the received body for an activity the CASE_MANAGER received, or the body it delivered for one it emits (CLP-07-011, VM-08-003).

A replica rebuilds the case only from what the entry carries. If the entry holds a reference or a summary in place of the activity, a replica must find the rest somewhere else, and two replicas can find different things. The full activity lets every replica replay the same change.
Uses definition from: CLP-07-011
See also: VM-08-003 — context for the reader
CLP-02-004 MUST Every CaseLedgerEntry records a canonical admitted assertion; a CaseLedgerEntry MUST NOT carry a disposition, a reason code or a reason detail, because the ledger contains only admitted entries (see CLP-04-007).

A refusal never becomes an entry (CLP-04-007), so a disposition field could only ever hold one value. A field like this invites code to write refused entries and readers to filter them. Without it, every entry is a change that every replica must apply.
Derives from: CLP-04-007
CLP-02-005 MUST When a precondition guard at the CASE_MANAGER refuses an incoming assertion, the CASE_MANAGER MUST send a Refuse protocol activity to the asserting participant (CLP-05-001). The refusal itself is never written to the ledger (CLP-04-007). A refusal at a door guard gets no Refuse — the post-close boundary (CM-23-013), the addressee check (HP-01-005), the path stage (HP-01-039) or the closed-sender door (CM-23-018) — and neither does a refusal by the sender guard (HP-01-006). The one exception is the optional reply to a late Leave at the post-close boundary (CM-23-040, CM-23-057), which is a Refuse too. A CASE_MANAGER that refuses its own activity sends itself no refusal notice.

The refused participant must learn that it was refused and why, so it can stop waiting for its entry. A refusal changes nothing in the case, and a ledgered refusal would put a non-event into every replica's hash chain. A sender that is not entitled to make the assertion is owed no answer (HP-01-006, ADR-0141). A closed case's CASE_MANAGER acts like an exited process, and a Reject of a late activity could read as a protocol decision (CM-23-013, ADR-0131). A CASE_MANAGER that refuses its own activity (a Leave under CM-23-010, or under CM-23-011 when it is also the Case Owner) already knows the reason, and a notice to itself would be refused on arrival.
Uses definition from: CM-23-013
Uses definition from: HP-01-005
Uses definition from: CM-23-018
Uses definition from: HP-01-006
See also: CLP-04-007 — context for the reader
See also: HP-01-039 — a link would close a loop through HP-01-039, HP-01-038, HP-01-035 and CLP-10-010
See also: CM-23-040 — context for the reader: the post-close reply that is a Refuse
See also: CM-23-057 — context for the reader: the post-close reply that is a Refuse
CLP-02-006 MUST CaseLedgerEntry MUST include a log_index field corresponding to SYNC-01-002.

A replica uses the index to find its position in the ledger and to see a missing entry. Without an index on each entry, a replica cannot tell a gap from the end of the ledger.
Uses definition from: SYNC-01-002
CLP-02-008 MUST The log_index field of a CaseLedgerEntry MUST be assigned by the CASE_MANAGER alone, when it commits the entry.

Centralising log_index assignment in the single authoritative write path prevents gaps, duplicates, and out-of-order index values that would break hash-chain integrity.
CLP-02-009 MUST NOT The log_index field of a CaseLedgerEntry MUST NOT be assigned by external parties.

Allowing external parties to set log_index would enable index spoofing, enabling forked or replayed ledger entries that corrupt the canonical append-only history.
CLP-02-007 MAY CaseLedgerEntry MAY include an optional term field reserved for Raft cluster use.

In Raft, each entry carries the term of the leader that wrote it, and nodes compare terms to find entries from an old leader. A reserved field lets a cluster add that value without a change to the entry format that single-node deployments also read.
CLP-02-012 MUST Every text that describes the case ledger MUST use "Accept" and "Reject" only as the names of the AS2 activities. The CASE_MANAGER's verdict on whether an assertion enters the ledger is admitted or refused. The rules that keep refusals off the ledger (CLP-02-005, CLP-04-007) govern that verdict, not the Reject activity.

The same word cannot name both the ledger verdict and an AS2 activity. If it does, a reader takes "a refusal is not ledgered" to mean "a Reject is not ledgered", and builds a handler that drops a participant's decline.
See also: CLP-02-005 — context for the reader
See also: CLP-04-007 — context for the reader
CLP-02-016 MUST When the CASE_MANAGER admits a participant's Reject or TentativeReject of a request, it MUST commit a CaseLedgerEntry for it under CLP-02-001. The request is an Offer or an Invite, and the matching Accept gets an entry the same way.

A participant's decline is a case event: it closes a request and reply pair, and the ledger must record that (CLP-11-001). If the decline has no entry, every replica keeps the request open.
Uses definition from: CLP-02-012
Refines: CLP-02-001
CLP-02-013 MUST Each activity the CASE_MANAGER admits at the case layer is a case event, which it MUST ledger (CLP-02-001), unless this list exempts it. Activities processed before a case exists are not case events, such as report submission and case proposal intake. RK is not one: it answers the reporter's Offer outside the case and never goes to the CASE_MANAGER (RMB-08-005). A replica's receipt of Add(CaseLedgerEntry) is not one, because it applies an entry and asserts none. Activities about the ledger itself are not case events: the CASE_MANAGER's refusal notice (CLP-05-001) and a replica's Reject(CaseLedgerEntry) that asks for redelivery. A replica's receipt of Announce(VulnerabilityCase) is not one, which CLP-10-034 leaves unledgered (ADR-0214). An activity only the CASE_MANAGER sends is not a case event where a participant receives it. Examples are the bootstrap Create(VulnerabilityCase), its Announce(EmbargoEvent) notice, and its Accept or Reject of a recommender's Offer(Actor). A participant never commits (CLP-01-003), so such an activity is ledgered, if it is a case event, where the CASE_MANAGER sends it. The bootstrap Create(VulnerabilityCase) is the case's genesis entry itself (CLP-07-011). A Create(ProcessingFault) NACK (ADR-0080) is not one, because it reports on message handling and changes nothing in the case. A late embargo Accept is not one when the case has no embargo for it to bind (EMB-17-015). It changes nothing at any receiver (ADR-0152). Nor is a message whose meaning the receiver does not recognize, or whose object it cannot resolve.

A closed list makes each activity with no entry a recorded decision, not the choice of one handler. A coverage test then has a fixed set of grounds for an exemption. A handler that runs only at a participant has no commit to reach. An activity that changes nothing at any receiver is an observation, not an act. An entry for it would record a fact that every holder of the ledger can already derive.
Refines: CLP-02-001
Uses definition from: CLP-05-001
Uses definition from: CLP-07-011
See also: CLP-01-003 — context for the reader
See also: CLP-10-034 — context for the reader
See also: EMB-17-015 — context for the reader
See also: RMB-08-005 — context for the reader
CLP-02-017 MUST An author MUST add a new kind of activity that carries no ledger entry to the CLP-02-013 list before any handler leaves it unledgered.

A closed list makes each activity with no entry a recorded decision, not the choice of one handler. A coverage test then has a fixed set of grounds for an exemption.
Extends: CLP-02-013
CLP-02-014 MUST CaseLedgerEntry MUST carry the entry's semantic type under the wire key semanticType.

The field holds a semantic type, the registry's label for the entry's payload (ADR-0140), and the glossary lists "event type" as a term to avoid for it.
CLP-02-018 MUST The entry hash of a CaseLedgerEntry MUST cover the entry's semantic type under the key semantic_type.

Every holder recomputes the entry hash to verify the chain. If the hash did not cover the semantic type, a holder could relabel an entry and still pass the check, and two holders could disagree on what an entry means.
Extends: CLP-02-014
Audit Scope and Continuity
ID Priority Requirement Related
CLP-03-001 MUST Only assertions that can be resolved to a specific case MUST be appended to the case audit ledger

Every entry belongs to the hash chain of one case. An assertion that no case can claim has no chain to join, and an entry for it would break the rule that a ledger holds only the history of its own case.
CLP-03-002 MUST Malformed, unauthenticated, or otherwise unrouteable inbound messages that cannot be attached to a report or case MUST be handled outside the case audit ledger

A message that the receiver cannot attach to a case tells the case nothing. It is a transport or sender problem, and the receiver's own log is the place to record it. If it went into a case ledger, any sender could add noise to a case it has no part in.
Canonical Ledger and Replication
ID Priority Requirement Related
CLP-04-001 MUST The authoritative history of a case MUST be the append-only canonical ledger; every entry in it records a protocol-significant admitted assertion. The ledger contains no refused or locally-scoped entries (see CLP-04-007).

Replicas agree only when they share one source of history. If any other record could also define the case history, two holders could each follow a different source and disagree with no way to decide which is correct.
See also: CLP-04-007 — context for the reader
CLP-04-002 MUST Case-state reconstruction MUST use only the canonical case ledger; refused assertions are never committed to the ledger and therefore require no filter during reconstruction.

A replica that rebuilds case state from any other source can get a different answer from every other replica. Because the ledger holds no refusals, a replay needs no filter, and so no filter rule can differ between implementations.
CLP-04-003 MUST Replicated hash chains, Merkle proofs, and replay state MUST be computed over the canonical case ledger; because the ledger contains only admitted canonical entries, no disposition filtering is required during chain computation.

Two holders must compute the same hash for the same history. If each holder first had to filter entries, a different filter rule would give a different hash for the same case. A ledger with only admitted entries removes that step.
CLP-04-004 MUST CASE_MANAGER fan-out replication MUST deliver the canonical CaseLedgerEntry content, wrapped in an ActivityStreams transport envelope such as Add

A replica must check the entry hash against the content that the CASE_MANAGER committed. If fan-out sends a rebuilt or summarized form, the replica cannot verify the chain. The envelope only carries the entry, so the entry stays the same for every recipient.
CLP-04-005 SHOULD When a participant includes log-position context with an assertion, it SHOULD use the last canonical hash or position the sender holds from the canonical case ledger

A participant and the CASE_MANAGER compare positions to find a replica that lags. A position from any other source, such as the participant's own pending records, names a point that the canonical chain does not have.
CLP-04-006 MUST Implementations MUST derive case participant membership and case state only from the canonical recorded log, never from any other source.

Membership and case state decide who receives case content and what each participant may do. If any other source could set them, two replicas at the same ledger position could disagree about who is in the case.
CLP-04-007 MUST The case ledger MUST contain only canonical admitted entries, never a refusal from any processing path.

Every replica applies every entry. A refusal in the ledger would make each replica tell a refusal from a change, and an implementation that fails to do this would apply a change that never happened. The hash chain would also depend on traffic that the CASE_MANAGER did not admit. A refusal is recorded in the process log. A refusal by a precondition guard is also answered with a refusal notice (CLP-02-005).
Refusal Handling

What the CASE_MANAGER does with an assertion it refuses to admit to the ledger. "Refused" is the CASE_MANAGER's ledger verdict, not the AS2 Reject activity: a participant's Reject answering a request is a case event and is admitted and ledgered like any other (CLP-02-012).

ID Priority Requirement Related
CLP-05-001 MUST The refusal notice that CLP-02-005 requires MUST be a Refuse whose object is the refused activity, inline. It names that activity's id in inReplyTo, is addressed to the asserting participant alone, and carries the refusing guard's reason in summary. It is sent as "type": ["Refuse", "Reject"] (VM-03-005).

A refused sender should learn that it was refused and why, and stop waiting for its assertion to be committed. One shape for every refused activity needs one emitter and one receiving use case (CS-22-001). A Reject of an Invite or an Offer already means a decline, so a refusal of one needs its own type for the receiver to tell the two apart; Refuse is a subtype of Reject, so a plain AS2 receiver still reads a Reject (ADR-0196).
Refines: CLP-02-005
Uses definition from: VM-03-005
CLP-05-004 MUST The CASE_MANAGER MUST derive the id of a refusal notice from its own id and the refused activity's id.

A derived id lets a redelivery of the refused activity find the notice already sent, so the participant gets one notice, not one per delivery (HP-01-014).
Extends: CLP-05-001
CLP-05-005 MUST The CASE_MANAGER MUST send one refusal notice for every refusal by a precondition guard (CLP-10-022).

A refused sender should learn that it was refused and why, and stop waiting for its assertion to be committed.
Refines: CLP-02-005
CLP-05-006 MUST NOT The CASE_MANAGER MUST NOT send a refusal notice for a refusal at a door guard (the post-close boundary, the addressee check, the path stage or the closed-sender door) or by the sender guard (HP-01-006). Nor does it send one for a repeat of an activity it already processed.

A sender that is not entitled to make the assertion is owed no answer (HP-01-006, ADR-0141). A repeat was already answered, so a second notice adds nothing and could contradict an effect already in place.
Refines: CLP-02-005
Uses definition from: HP-01-006
CLP-05-007 MUST A participant that receives a refusal notice MUST close the pending assertion it recorded for the refused activity.

The notice is the answer the participant waits for. If the pending record stays open, it blocks a correct new assertion until it times out.
Uses definition from: CLP-05-001
CLP-05-008 MUST NOT A participant that receives a refusal notice MUST NOT write case state, or send the assertion again, because of it (CLP-06-005).

A refusal changes nothing in the case, so a write would put state into the replica that no entry records. A re-send would repeat a refused assertion with no new decision behind it.
Uses definition from: CLP-05-001
See also: CLP-06-005 — context for the reader
CLP-05-009 MUST A participant MUST process the CASE_MANAGER's Reject of its own Invite or Offer as the decline of that request, which closes the pending entry.

A Reject is the CASE_MANAGER's own decision against the request, such as its answer to an embargo Invite once P/X/A is set (EMB-01-002), so it is a decline. The CASE_MANAGER's refusal of a request on a precondition is a Refuse instead, which the refusal-notice use case reads (CLP-05-001, ADR-0196).
CLP-05-003 MUST NOT Implementations MUST NOT record local-only tracking markers or duplicate-detection markers as CaseLedgerEntry objects of any kind; such markers belong in ephemeral per-actor state, not in the canonical ledger.

A duplicate marker or a local tracking marker is one actor's working state. If it is an entry, it replicates to every participant and becomes part of the hash chain. Then the chain depends on the timing of one actor's processing and not on the case history.
Pending Assertion Suppression
ID Priority Requirement Related
CLP-06-001 SHOULD Participant actors SHOULD maintain actor-local pending assertion state for recently emitted case-scoped assertions that are awaiting canonical CaseLedgerEntry confirmation

A participant waits for its own assertion to come back as an entry. If it does not record that it is waiting, its behavior can send the same assertion again before the entry arrives. A short local record stops these duplicate sends.
Canonical Entry Criteria and Ledger/Process-Log Separation
ID Priority Requirement Related
CLP-07-001 MUST A CaseLedgerEntry committed to the canonical case ledger MUST correspond to exactly one CASE_MANAGER-accepted protocol-significant assertion. A state change the CASE_MANAGER itself writes is such an assertion, with the CASE_MANAGER as asserter. An example is the RM transitions it records for a leaving participant (CM-23-022).

Each entry is one fact that every replica applies once. An entry that records no admitted assertion, or that records more than one, makes replicas apply something the CASE_MANAGER never decided, or lose part of what it decided. A change the CASE_MANAGER writes itself is also a fact, so it needs an entry like any other.
See also: CM-23-022 — context for the reader
CLP-07-011 MUST The payloadSnapshot of a CaseLedgerEntry MUST be the verbatim AS2 activity that was asserted, with no field of it dropped, re-serialized, inlined, patched or merged. For an activity the CASE_MANAGER received, it is the JSON body as received (VM-08-002). For one the CASE_MANAGER emits, it is the body it delivered (VM-08-003). An activity the CASE_MANAGER sends and ledgers is one activity. So the case's genesis entry is the Create(VulnerabilityCase) it sends for the case, not a second activity built for the ledger. The metadata the CASE_MANAGER adds lives on the entry, outside the snapshot: the index, the hashes, the commit and receipt times, and the case it names in its context.

The payload snapshot is the replication substrate, and the entry hash covers it, so what it holds is what every replica treats as the event. A snapshot rebuilt from the receiver's object graph records the receiver's reconstruction, not what the sender claimed, and every rewrite is one more thing a replica must reproduce exactly to verify a hash (ADR-0107).
Uses definition from: VM-08-002
Refines: VM-08-003
CLP-07-012 MUST NOT The payloadSnapshot of a CaseLedgerEntry MUST NOT be empty.

An empty payload snapshot breaks deterministic replay and makes it impossible for replica nodes to reconstruct the case state from the canonical log.
CLP-07-002 MUST The CASE_MANAGER MUST commit at most one CaseLedgerEntry for each logical state change. It never commits both an admitted participant assertion and an entry of its own for the same change. An act and the state transitions the CASE_MANAGER records as its consequence are different facts, not the same state change. For example, the close_case entry records a received Leave (CM-23-021). The status entries after it record the RM transitions the Leave caused (CM-23-022).

A replica applies each entry. Two entries for one change make it apply the change twice, and the ledger then shows two facts where there is one. An act and the transitions it causes are different facts, so each one gets its own entry.
See also: CM-23-021 — context for the reader
See also: CM-23-022 — context for the reader
CLP-07-013 MUST The CASE_MANAGER MUST commit every change it makes to the case file as its own CaseLedgerEntry, never making a change that has no committed entry. The act's entry comes first. When the act's own activity states a change, that entry is the change's entry, and applying it writes only what the activity states. Examples are Add(Note)[target=VulnerabilityCase] carrying the note, and an invitee's Accept of the stub Invite marking its own consent and joining. A decision the CASE_MANAGER takes from local policy or the clock may change the case file. Such a decision is committed as the change it makes, before the change is made. A decision that changes nothing is not committed, such as noticing that a deadline has passed or that a closure is complete (ADR-0152). Moving the case's ledger position (ledgerPosition) to an entry as it is committed (SYNC-16-005) is part of applying that entry. It is not a change to the case file of its own, and takes no entry.

Two replicas at the same ledger position must hold the same case file, and a replica infers nothing. If a change is not in the ledger, it did not happen (ADR-0124). One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times. Full records are ledger content that the hash chain must cover (CLP-07-006).
Extends: CLP-07-002
Uses definition from: SYNC-16-005
CLP-07-021 MUST Each change an act causes, beyond what the act's own activity states, MUST follow the act's entry as its own CASE_MANAGER-authored entry. The entries follow in the order the CASE_MANAGER writes them. Each one's payloadSnapshot carries the object in full (CLP-07-006). A record the change adds to one of the case's lists (its participants, reports, notes, statuses, vulnerability items or case references) is recorded as an Add of the record with the case as its target. Any other record the CASE_MANAGER brings into existence is recorded as a Create, and a changed record as an Update.

One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times, and replicas at one ledger position then differ. Full records are ledger content that the hash chain must cover (CLP-07-006). A record that belongs to a case list needs the case as the entry's target: a Create has none, so a replica would have to decide which list the record joins, which is lifecycle logic a replica must not run (CM-23-044). The one Add both brings the record and lists it.
Extends: CLP-07-013
See also: CLP-07-006 — context for the reader
CLP-07-014 MUST NOT The CASE_MANAGER MUST NOT commit case bookkeeping to the case ledger. Case bookkeeping is the records the CASE_MANAGER keeps alongside a case while it works it, such as who recommended whom, offer records and pending markers. It is not part of the case file.

The case file is what replicates, and "same ledger position, same case file" covers only the case file. If bookkeeping is stored on the case or read to compute a case-file value, replicas at the same position can disagree on a value that no entry carried.
CLP-07-022 MUST NOT The CASE_MANAGER and every replica MUST NOT read case bookkeeping (CLP-07-014) to compute any case-file value.

The case file is what replicates, and "same ledger position, same case file" covers only the case file. If a case-file value is computed from bookkeeping, replicas at the same position can disagree on a value that no entry carried.
Uses definition from: CLP-07-014
Refines: CLP-04-006
CLP-07-015 MUST The CASE_MANAGER MUST commit an act's entries atomically, together with the case-file changes they carry and every consequence the act commits. So when any of them fails, none of them is written. Such consequences include a re-issued stub Invite, a relayed Invite with its invitee's row, a closure step's status entry, and a notice it queues. For a received act, the act's own entry is one of those entries.

An act commits its own entry and one entry for each change it causes (CLP-07-013). If they commit one at a time, a failure part-way keeps the act and loses some of its consequences, a state no single act produces. Nothing commits the missing parts later: a repeated trigger starts a new act, and an idempotency guard stops a redelivered one. So an act succeeds or fails as a whole (ADR-0146). A received act's own entry is in the same transaction (ADR-0214), so a failed received act keeps nothing and a later delivery runs it again.
Extends: CLP-07-013
CLP-07-023 MUST The CASE_MANAGER MUST refuse an embargo act, before it writes anything, when any of the act's entries will not apply.

An entry that will not apply would fail part-way through the act's commits. Finding it before the first write keeps the act whole, so a failed embargo act leaves nothing behind (ADR-0146).
Extends: CLP-07-015
CLP-07-003 MUST The payloadSnapshot.actor of a CaseLedgerEntry MUST name the original asserting actor, never the CASE_MANAGER in a participant asserter's place. The CASE_MANAGER's identity appears on the transport envelope and in recording metadata. When the CASE_MANAGER also holds a participant role in the case, its identity in payloadSnapshot.actor is the correct asserter identity. A state change the CASE_MANAGER writes itself names the CASE_MANAGER, its true asserter. The RM status entries after a close_case entry (CM-23-022) are of this kind. The leaving participant's own act stays attributed to them in the close_case entry (CM-23-021).

Replicas apply each entry as the act of the actor that the snapshot names. If the CASE_MANAGER puts its own identity there, the act is attributed to the wrong participant, and its effects land on the wrong record. Authority is a role, not an identity (ADR-0088), so a CASE_MANAGER that also holds a participant role can assert as that participant.
See also: CM-23-021 — context for the reader
See also: CM-23-022 — context for the reader
CLP-07-017 MUST In an entry that records a received activity, payloadSnapshot.actor MUST name the same actor as the received activity's actor. The two are compared as normalized actor ids. A state change the CASE_MANAGER writes itself has no received activity, so this comparison does not apply to it.

Any other mismatch shows that one identity was put in place of another. Comparing normalized ids keeps a trailing slash from reading as a different actor.
Refines: CLP-07-003
CLP-07-004 MUST NOT The canonical case ledger MUST NOT contain runtime diagnostics, demo checkpoints, synthetic verification markers, troubleshooting events, or any per-actor observability content; such content belongs in each actor's own logs.

The ledger replicates to every participant and the hash chain covers it. Diagnostics and checkpoints depend on one actor's runtime. If they enter the ledger, replicas must filter them, and the chain changes when the timing of a run changes. An actor's own log can hold any detail with no effect on the protocol.
CLP-07-006 MUST The CASE_MANAGER MUST record each nested object of a payloadSnapshot exactly as the asserted activity carried it, never inlining, resolving or replacing a reference. An entry the CASE_MANAGER authors carries in full every object it records. A received entry is the received body (CLP-07-011). So an object is inline where its sender inlined it, as a sender does every object its recipient cannot be expected to hold. It is bare where its sender named an object the case's replicas already hold (AKM-02-002). A replica that does not hold an object named by reference dereferences it.

A protocol rule, not this prototype's inline-object shortcut (AKM-03-003): the entry hash covers the payloadSnapshot and nothing outside it, so an object carried in full is under the hash every participant verifies, and an object named by id is only identified by it. Filling a reference in at the CASE_MANAGER would put the receiver's reconstruction in place of what was sent, and a replica could not tell the sender's claim from the fill-in (ADR-0107).
See also: AKM-02-002 — context for the reader
See also: CLP-07-011 — context for the reader
CLP-07-018 MUST NOT The CASE_MANAGER MUST NOT refuse an entry for a bare reference anywhere but the snapshot's own object, whose type is half of the entry's signature.

A sender may name by id any object the case's replicas already hold (AKM-02-002), so a bare reference elsewhere is a valid entry. Only the snapshot's own object must be inline, because its type selects the entry's signature.
Derives from: CLP-07-006
CLP-07-007 MUST Once a case exists, the builder of a case-scoped activity MUST set its context to the case URI, never to a report URI. A ParticipantStatus activity is one such activity.

The obligation falls on whoever builds the activity. A received snapshot is the body as sent (CLP-07-011), so the CASE_MANAGER neither writes a context in nor rewrites one; the commit boundary refuses a context naming another case, and the entry names its case on the envelope (its context), so a snapshot that names no context, such as the Offer that opened the case, is still that case's entry.
Per-Case Genesis Hash Derivation and Origin Binding
ID Priority Requirement Related
CLP-08-001 MUST Each case ledger MUST use a per-case genesis hash, never a globally-shared constant, as the predecessor hash of its first entry.

A shared global constant provides no cryptographic origin-binding: a ledger with all entries stripped is indistinguishable from a legitimately new empty ledger, and the well-known constant enables sync DoS amplification by allowing full-replay requests without any case-specific knowledge
CLP-08-002 MUST The per-case genesis hash MUST be derived as SHA-256(case_id + "&#124;" + created_at + "&#124;" + owner_actor_id), where case_id is the canonical case URI, created_at is the case creation UTC timestamp (the case's published) in ISO 8601 format, and owner_actor_id is the actor id of the Case Owner, the case's attributedTo when the case is created. The same derivation applies on every creation path, including a case the CASE_MANAGER creates from the owner's CaseProposal.

Including all three values cryptographically anchors the chain's starting point to the specific case's origin identity and timestamp, allowing any party who knows the case metadata to independently verify the ledger's genesis. The owner is the anchor because the CaseActor that may create the case is the owner's delegated proxy, so a case created by its owner and one created for the owner from a CaseProposal (CP-09-001, CM-02-008) start from the same identity. The decision is recorded in ADR-0117.
CLP-08-003 MUST The case-specific genesis hash MUST be stored on VulnerabilityCase as a required field computed at case creation time, so that receivers can verify that a ledger starts correctly for this case

A receiver checks the first entry of a ledger against the genesis hash. If the case does not carry the hash, each receiver must compute it again from fields it may not hold in the same form, and two receivers can get different values. A field set at creation gives every receiver the same value.
CLP-08-004 MUST A case ledger that holds no recorded entries MUST report the case-specific genesis hash as its tail hash, never a globally-shared constant sentinel.

A shared constant is the same for every case. An empty ledger that reports it cannot show which case it belongs to, and the empty ledger of one case looks the same as the empty ledger of any other case. The per-case hash makes an empty ledger specific to its case.
CLP-08-005 MUST A replay or backfill request that supplies a from_hash MUST start from the case-specific genesis hash, or from the hash of a known recorded entry.

A starting hash tells the CASE_MANAGER where the requester's copy ends. Only the genesis hash and the hashes of real entries name a position in the chain.
CLP-08-008 MUST The CASE_MANAGER MUST treat a replay or backfill request whose from_hash names no recorded entry as a request to replay from the start.

A value that names no known position cannot be trusted, so a full replay from the start is the only safe answer. The genesis hash is no entry's own hash, so it also replays from the start.
Refines: CLP-08-005
CLP-08-006 MUST The case URI used for origin-binding MUST contain a cryptographically random UUID component in its path segment to satisfy the non-spoofability guarantee of the per-case genesis hash (e.g., https://example.org/cases/<uuid>).

A cryptographically random path segment makes the genesis hash unique and unguessable per case, so a ledger with all entries stripped is distinguishable from a legitimately new empty ledger.
CLP-08-007 MUST NOT Implementations MUST NOT use sequentially predictable or human-chosen path segments in the case URI when origin-binding integrity is required.

Predictable or human-chosen path segments allow an attacker to pre-compute a valid genesis hash and construct a forged chain. See notes/case-ledger-authority.md for future improvement paths (secret nonce, CASE_MANAGER keypairs).
CASE_MANAGER Inbox Routing for Canonical Ledger Entry Authorship

Requirements for the end-to-end routing path that delivers protocol-significant activities to the CASE_MANAGER's inbox so the CASE_MANAGER can author canonical ledger entries. Covers outbound addressing rules, the rule that the CASE_MANAGER commits its own emissions in the emitting tree rather than addressing a copy to itself (ADR-0109), and the rule that a received-side use case runs its tree only as the receiving actor.

ID Priority Requirement Related
CLP-10-001 MUST Every protocol-significant act a participant originates MUST send at least one activity to the case's CASE_MANAGER. The CASE_MANAGER can then author a canonical ledger entry for it. A participant reaches the CASE_MANAGER only by sending it the participant's own activity, never by acting as the CASE_MANAGER (CM-24-010, CM-24-011, ADR-0109). The CASE_MANAGER is a participant with extra duties, so its own acts reach the ledger too, as CLP-10-031 and CLP-10-032 state.

The CASE_MANAGER is the only writer of the ledger, and it writes only what it receives or sends. An act that sends nothing to the CASE_MANAGER has no entry, and no replica learns of it. When the CASE_MANAGER originates an act, it commits the entry in the tree that sends the activity. A copy to itself would come back through its inbox and could be committed a second time. Only the container that hosts the CASE_MANAGER may act as it (ADR-0109).
See also: CLP-10-032 — context for the reader
See also: CM-24-010 — context for the reader
See also: CM-24-011 — context for the reader
CLP-10-031 MUST When the CASE_MANAGER originates a protocol-significant activity, it MUST commit the canonical entry itself as it sends the activity. Inviting an actor to the case is one such activity.

The CASE_MANAGER is the only writer of the ledger, and it writes only what it receives or sends. When it originates an act, it commits the entry in the tree that sends the activity, so the act has its entry with no round trip.
Extends: CLP-10-001
CLP-10-032 MUST NOT The CASE_MANAGER MUST NOT address a copy of an activity it originates to itself in any addressing field.

A copy to itself would come back through its inbox and could be committed a second time. Only the container that hosts the CASE_MANAGER may act as it (ADR-0109).
Extends: CLP-10-031
CLP-10-004 MUST NOT An Add(CaseLedgerEntry) replication envelope MUST NOT itself be recorded as the payloadSnapshot of a canonical ledger entry; it is the envelope that carries canonical entries to participants, not a ledger event.

The Add(CaseLedgerEntry) envelope only delivers entries. An entry whose payload is the envelope would itself need an envelope to deliver it. Each delivery would then add one more entry with no end, and the hash chain would change with every delivery.
CLP-10-015 MUST When a receiver must identify a subject that an incoming message names (the invitee of an embargo invitation, the actor whose consent an accept or reject records, or the target of any participant-scoped action), it MUST take that identity from the received activity, never from its own identity as the receiving actor. The two coincide in the ordinary single-recipient case and diverge whenever a message is relayed on a participant's behalf.

The receiving actor and the subject of a message are the same in the usual single-recipient case. They differ when a message is relayed on a participant's behalf, sent from the command line, or replayed from the log. If the receiver uses its own identity as the subject, it records consent for the wrong participant, or sends an action to the wrong one. A conforming peer then sees a change on an actor that the message never named.
CLP-10-016 MUST Subject-identity resolution (CLP-10-015) MUST give a result that does not change when the to: list is reordered.

The order of the to: list carries no meaning. A pick by position resolves a message with several recipients to the same subject in every replica. Each recipient after the first would then apply the message to the record of another participant.
Extends: CLP-10-015
Protocol Request/Reply State Detection

Requirements for querying whether a protocol-level request/reply pair (e.g., Offer(CaseParticipant) → Accept/Reject) is still open or has been closed. These rules establish the canonical pattern for duplicate-emission suppression and CASE_MANAGER decision-gate checks.

ID Priority Requirement Related
CLP-11-001 MUST This codebase MUST determine whether a protocol request/reply pair has been authorized from the case ledger, never from the actor's outbox. An example pair is an Offer(CaseParticipant) that awaits an Accept or a Reject.

The outbox is a delivery queue: entries are removed when the activity is sent and MUST NOT be used to infer protocol state. The case ledger is the canonical append-only protocol history and survives actor restarts. Any code that reads the outbox to determine whether a request is still in-flight is architecturally incorrect and MUST be replaced.
CaseLedger Causal Ordering — CASE_MANAGER Timestamp Invariants

Normative requirements establishing that log_index order is the canonical causal order from the CASE_MANAGER's perspective, and the temporal invariants that conformance tests can verify against any ledger. See ADR-0079 for the decision record and rationale.

ID Priority Requirement Related
CLP-14-001 MUST A case ledger MUST record entries in the order the CASE_MANAGER observes them. So if it observes event A before event B, log_index(A) is less than log_index(B). The log_index sequence is the authoritative causal order; timestamp order is supporting evidence only.

The CASE_MANAGER is the single authoritative writer (CLP-01-003, ADR-0041). A single-writer regime produces a total order by construction, so no distributed consensus mechanism is needed. ADR-0079 formalises this design intent as a normative requirement; DEMOMA-22-005 depends on it.
Extends: SYNC-01-002
CLP-14-002 MUST The published timestamp on the CaseLedgerEntry envelope MUST be non-null. This is the CASE_MANAGER's commit stamp, as distinct from the claimed payloadSnapshot.published.

A null entry timestamp makes the ordering checks impossible, and it breaks any consumer that orders entries by time. An entry carries two timestamps. A rule for the envelope stamp that is applied to the claimed stamp, or the reverse, gives a check that never fires or that refuses valid entries, so the rule names its field.
CLP-14-011 MUST The CASE_MANAGER MUST stamp each entry's envelope published with its own authoritative clock at commit time.

One writer stamping from one clock gives stamps that support the causal order (CLP-14-001). A stamp copied from the claimed time would carry a participant's clock into the ordering checks.
Extends: CLP-14-002
CLP-14-003 MUST The envelope published timestamps (the CASE_MANAGER's commit stamps) on consecutive recorded entries MUST be monotonically non-decreasing in log_index order. So no entry carries an envelope published earlier than the entry with the immediately preceding log_index. This rule does not apply to the claimed payloadSnapshot.published, whose cross-entry order CLP-15-003 constrains only per participant.

A timestamp that goes backward contradicts the causal order. If entry N has a later log index than entry N-1 but an earlier stamp, observers cannot use the stamps to support the order that the CASE_MANAGER recorded. The rule covers only the envelope stamp, because one writer stamps every entry from one clock. On the claimed stamps it would compare the clocks of two participants, which ADR-0079 rejects as option C, and it would refuse a valid assertion when two clocks disagree.
Extends: CLP-14-001
See also: CLP-15-003 — context for the reader
CLP-14-004 MUST All entries in a single case ledger MUST name the same case in their context.

A ledger mixing entries from multiple cases makes causal comparisons meaningless and breaks hash-chain verification (which is scoped per case).
CLP-14-012 MUST A holder of a case ledger MUST refuse as malformed an entry whose case, named in its context, does not match the ledger's case.

A ledger mixing entries from several cases makes causal comparisons meaningless and breaks hash-chain verification, which is scoped per case. Refusing the entry keeps it out of the chain.
Implements: CLP-14-004
CLP-14-005 MUST log_index values MUST be unique within a single case ledger. No two entries for the same case may share a log_index value.

Duplicate indices would make it impossible to identify which entry is causal-order position N, breaking any test or consumer that relies on log_index to determine ordering.
Derives from: SYNC-01-002
CLP-14-006 MUST Every CaseLedgerEntry's envelope published timestamp MUST be on or after the parent VulnerabilityCase's own published timestamp, never before the case's creation.

The CASE_MANAGER is the single writer and creates the case before committing any entries. An entry predating the case indicates a clock error or commit-path bug; treating it as a protocol violation catches the defect at the boundary. The envelope stamp holds by construction and is verified by the conformance harness.
CLP-14-013 MUST The CASE_MANAGER MUST refuse a recorded assertion whose claimed payloadSnapshot.published precedes the parent case's published timestamp by more than the configured clock-skew tolerance (CLP-14-009).

A claimed time well before the case's creation shows a clock error or a malformed assertion. The check needs a tolerance because the participant's clock is not the CASE_MANAGER's. A zero-tolerance comparison across two clocks would refuse well-formed assertions from any participant whose clock lags, the wall-clock coupling ADR-0079 rejected as option C.
Extends: CLP-14-006
Uses definition from: CLP-14-009
CLP-14-007 SHOULD The CASE_MANAGER SHOULD refuse a payload assertion whose payloadSnapshot.published is more than a configurable tolerance ahead of the CASE_MANAGER's clock at receipt.

A payload timestamped in the future relative to the CASE_MANAGER's clock indicates a participant clock error or a malformed assertion. Accepting it silently would produce ledger entries where the payload claims to have been published after the ledger envelope was stamped — a contradiction of the observation model in ADR-0079. A small tolerance accommodates legitimate clock drift without rejecting well-formed messages from participants whose clocks are slightly ahead.
CLP-14-014 SHOULD The default future tolerance (CLP-14-007) SHOULD be no more than five minutes, to match common clock-skew conventions.

A small tolerance accommodates legitimate clock drift without refusing well-formed messages from participants whose clocks are slightly ahead.
Extends: CLP-14-007
CLP-14-008 SHOULD The CASE_MANAGER SHOULD refuse a payload assertion whose payloadSnapshot.published timestamp is more than a configurable staleness window in the past relative to the CASE_MANAGER's clock at receipt.

A payload with a timestamp far in the past suggests the participant is replaying old activities, potentially to reconstruct or manipulate ledger history. Rejecting stale payloads limits the window in which a replayed or delayed assertion can be inserted into the canonical ledger.
CLP-14-015 SHOULD The default staleness window (CLP-14-008) SHOULD be seven days.

Seven days bounds the window in which a replayed or delayed assertion can enter the ledger, while still admitting an assertion that a slow participant sends late.
Extends: CLP-14-008
CLP-14-010 MUST The CASE_MANAGER MUST assign log_index values as a gapless sequence: 0 for the genesis entry, and its predecessor's index plus one for every later entry.

Receivers find a missing entry by index arithmetic. An entry whose log index is greater than tail_index + 1 shows a forward gap (SYNC-14-001), and a replica that lags is valid only while its local prefix has no gaps. Both tests work only if the CASE_MANAGER never leaves a gap. CLP-14-001 requires only that indices increase, and CLP-14-005 requires only that they are unique. Neither excludes a sparse ledger.
Refines: SYNC-01-002
Participant Assertion Timestamp Obligations

Normative requirements on what well-behaved participants MUST do when emitting assertions to the CASE_MANAGER, so that the CASE_MANAGER's observation-order model (ADR-0079, CLP-14) yields a ledger that faithfully reflects real-world causal order within a single participant's event stream.

ID Priority Requirement Related
CLP-15-001 MUST A participant MUST emit the protocol activities for a case to the CASE_MANAGER in causal order. So if activity A causally precedes activity B in its own event stream, it emits A before B.

The CASE_MANAGER uses arrival order as the authoritative sequence. If a participant emits B before A despite A causing B, the CASE_MANAGER's ledger will record the wrong causal order. The participant is responsible for correct ordering; the CASE_MANAGER cannot reconstruct causality it did not observe.
CLP-15-002 MUST NOT A participant MUST NOT batch causally ordered activities and submit them to the CASE_MANAGER in an order that reverses their causal dependencies. For example, it never submits A → B → C as C, A, B.

Batched out-of-order submission produces a malformed ledger from the CASE_MANAGER's perspective. This is a protocol violation on the participant's part, not a CASE_MANAGER failure.
Refines: CLP-15-001
CLP-15-003 MUST Within one participant's event stream, the participant MUST give each activity a published timestamp no earlier than that of every activity that causally precedes it.

A participant that assigns earlier timestamps to later events produces a payloadSnapshot whose timestamp order contradicts the submission order. Even if the CASE_MANAGER's own entry timestamps are correct, the snapshot timestamps become evidence against the order recorded in the ledger.
Extends: CLP-15-001
CLP-15-004 SHOULD A participant SHOULD assign published timestamps that reflect the actual time the event occurred, not the time the batch was submitted or a retry was attempted.

Backdated or forward-dated timestamps degrade the forensic value of the ledger even when causal order is preserved. Timestamps that reflect actual occurrence time allow CaseActors and auditors to detect anomalies like stale replays (CLP-14-008).
Extends: CLP-15-006
CLP-15-006 MUST A participant MUST include a published timestamp on every protocol activity it emits.

ActivityStreams makes published optional. Each check that reads the claimed time needs the sender's value (CLP-14-007, CLP-14-008), so a sender that omits it makes those checks impossible.
CLP-15-008 MUST A receiver MUST refuse at message validation, as malformed, an inbound activity that carries no published, never substituting its own clock for the missing value.

A receiver that fills in the field cannot later tell a time the sender claimed from one it made. Each check that reads the claimed time then compares the receiver's clock with itself and never fires (CLP-14-007, CLP-14-008). A receiver that creates its own outbound activity stamps its own clock, which is correct.
Extends: CLP-15-006
CLP-15-005 MUST The CASE_MANAGER MUST record the sequence it observed in the order it received it. It never reorders that sequence to reconstruct a participant's internal causal order, which it cannot verify. Its ledger is authoritative for what it observed, not a guarantee of real-world causal fidelity when external participants self-report events.

Even a compliant participant's clock may drift, and a non-compliant participant may submit events in arbitrary order. The CASE_MANAGER's role is to record faithfully what arrived, in the order it arrived, while applying the timestamp sanity checks in CLP-14-007 and CLP-14-008. Attempting to reorder entries based on payload timestamps would require trusting externally-supplied data to override the CASE_MANAGER's own observation — a violation of the single-writer authority model.
Refines: CLP-14-001
CLP-15-007 MUST A receiver MUST carry the published and updated timestamps of every object nested in an inbound activity as received. An omitted timestamp that CLP-15-011 does not require stays absent. The receiver never substitutes its own clock for it, at parsing, extraction, storage or rendering.

AS2 makes object timestamps optional. A value that the receiver makes is later indistinguishable from the sender's claim. For example, each receiver would derive its own genesis hash for one case, and order received statuses by arrival.
CLP-15-009 MUST When a decision requires a nested timestamp that is absent, the receiver MUST refuse the message at message validation.

An absent time harms only a decision that needs it, so that decision refuses the message early and clearly. A whole object's published is required everywhere (CLP-15-011), so this rule covers the other times a sender may omit, such as an embargo's endTime.
Extends: CLP-15-007
CLP-15-010 MUST A receiver MUST reject at message validation an inbound activity carrying a CaseStatus with no published, wherever the status sits in it outside a preview (MV-12-006).

Every status carries its author's time (SM-05-003), and its published follows its place in the case history (CM-29-005). A receiver that filled in a missing time would claim one no sender made (CLP-15-007), so the status is refused at message validation (CLP-15-009), as CLP-15-008 refuses an activity with no time. A participant status is not named here, since nothing reads its time; it is refused as a whole object with no published (CLP-15-011).
Refines: CLP-15-009
Refines: CLP-15-011
CLP-15-011 MUST A receiver MUST refuse at message validation an inbound activity that carries, at any depth, a whole object with no published, naming the object's position. An actor profile, a collection and an EmbargoConsent row are exempt. A typed reference (MV-10-011), a URI and a Link are not whole objects, and a preview a typed reference carries is a projection of the object it names (ADR-0205), so the rule reaches none of them, nor any object inside such a preview (MV-12-006).

A conformant sender states the time of every object it authors, so the rule refuses only malformed input. Refusing at the edge spares every reader of a received object's time a check of whether its type is one a decision needs, and lets core declare the time required (ADR-0032). An actor profile or a collection is not an act made at a moment, and many servers serve profiles without one. A case preview, a projection of the case it names, and a consent row are kept without a time by CM-17-010 and CM-23-044.
Extends: CLP-15-007
See also: MV-10-011 — defines the typed reference the rule excludes; a scope boundary, not a dependency

Case Event Log Synchronization

Requirements for the append-only canonical recorded case ledger, replication transport, conflict handling, per-peer state tracking, and retry semantics for distributed case state synchronization across Participant Actors.

Append-Only Log
ID Priority Requirement Related
SYNC-01-001 MUST The canonical recorded case ledger MUST be append-only.

The ledger is the record of what happened in the case. If an entry can go away or move to a new place, the hash chain breaks, replicas disagree, and nobody can audit the case history. An append-only ledger lets every replica apply the same history and reach the same case state. Each entry's own immutability is SYNC-08-001.
SYNC-01-002 MUST Each log entry MUST carry a monotonically increasing, gapless index scoped to its case

The index gives every entry one position in the case's causal order (ADR-0079). Because the index has no gaps, a receiver knows that an entry is missing when the next index it gets is too high (SYNC-14-001). A duplicate or skipped index would hide a lost entry or let two entries claim one position.
SYNC-01-003 MUST Each log entry MUST include a cryptographic hash of its own content.

The content hash lets a receiver check that an entry's content matches the hash the entry states. A receiver can then detect an entry whose content does not match its hash (SYNC-03-006).
SYNC-01-007 MUST Each log entry MUST reference the hash of its immediate predecessor, so the entries form a forward-linked hash chain (Merkle chain style).

The link to the predecessor's hash fixes the entry's place in the chain. A receiver can then detect an entry in the wrong place (SYNC-03-001).
Extends: SYNC-01-003
SYNC-01-008 MUST Not yet in the reference implementation (tracked by #3659)

A CaseLedgerEntry's hash MUST be computed over the RFC 8785 (JCS) serialization of the content it covers, payload snapshot included.

Every receiver recomputes an entry's hash and refuses a mismatch (SYNC-03-006, SYNC-03-012). A peer built in another language reproduces the hash only if the bytes it hashes are fixed by a published rule, not by one serializer's behavior. JCS is that rule: it fixes key order, number form and string escaping, and the signing cryptosuite already uses it (SIG-01-002).
Extends: SYNC-01-003
SYNC-01-004 MUST Canonical recorded log entries MUST be written only by the CASE_MANAGER.

One writer gives one canonical order of entries. If two actors could write canonical entries, their ledgers could fork, and no rule could say which fork is the case history.
SYNC-01-005 MUST The hash-chain log entry format MUST be designed to be forward-compatible with a future Merkle Tree implementation

A Merkle tree would let a peer prove that one entry is in the ledger without sending the whole chain. If the entry format blocks that change, a migration would have to rewrite every stored ledger, which an append-only ledger forbids.
Replication Transport
ID Priority Requirement Related
SYNC-02-001 MUST Log replication between the CASE_MANAGER and Participant Actors MUST use ActivityStreams Add activities, each adding one committed CaseLedgerEntry to the case's ledger, as the transport envelope for canonical recorded log content.

Vultron actors talk through ActivityStreams messages, so ledger replication uses the same inbox, outbox and parsing path as other case messages. Add says the actor added the object to the target collection, which is what committing an entry to the ledger does; Add only calls attention to an object (ADR-0204).
SYNC-02-002 MUST Each replication message MUST identify the sender, target recipient, the log entry hash, and the predecessor hash

The receiver needs the sender to check that the message comes from the CASE_MANAGER. It needs the two hashes to find the entry's place in its chain before it applies anything (SYNC-03-001). Naming the recipient makes each message belong to one peer, so the CASE_MANAGER can track each peer's replication state (SYNC-04-001).
SYNC-02-003 MUST Replication MUST originate from the replication leader (the actor holding the CASE_MANAGER role) and be sent individually to every active participant (CM-10-004).

Only the CASE_MANAGER holds the canonical ledger, so only it can send entries that a replica can trust. A separate message to each active participant lets the CASE_MANAGER track and repair each peer on its own (SYNC-04-001). Case content goes only to active participants, so an inert participant receives no ledger entries (CM-10-004, ADR-0114).
Uses definition from: CM-10-004
SYNC-02-004 MUST The object of each Add(CaseLedgerEntry) activity MUST be the CaseLedgerEntry itself, carried inline or by reference, with every field the recipient needs to validate the hash chain (including the entry hash and its predecessor's hash).

The recipient checks the hash chain before it applies the entry (SYNC-03-001, SYNC-03-006). It can do that check only when it has every field the hashes cover. The inline form and the by-reference form give the recipient the same entry, so the protocol allows either.
SYNC-02-006 MUST Each Add(CaseLedgerEntry) MUST name the case's ledger, <case>/ledger, as its target and the entry's case as its context.

The ledger is an OrderedCollection whose items are the case's entries in logIndex order, so a replica reads the case and the collection from the message rather than from inside the entry. The ledger's id is an identity only: no route serves it (IE-02-003), and fetching it is separate work.
Refines: SYNC-02-001
SYNC-02-008 MUST A receiver MUST refuse an Add(CaseLedgerEntry) whose target or context names another ledger or case than the entry's own.

An Add that names another case's ledger contradicts the entry it carries, so it is refused at the parse edge rather than applied to either case.
Refines: SYNC-02-006
SYNC-02-007 MUST Each Add(CaseLedgerEntry) MUST name the act its entry commits in inReplyTo.

The Add is the positive acknowledgement of the act it commits (MSM-05-009): the act's sender learns that its act committed from the message that commits it, with no separate acknowledgement.
Refines: SYNC-02-001
SYNC-02-009 MUST NOT An Add(CaseLedgerEntry) MUST NOT carry a result.

Listing in result what the act caused would need the ids of follow-on acts before they exist, or an Add that waits for them. An act a commit causes names its cause in its own inReplyTo instead, so causation is read from effect to cause.
Refines: SYNC-02-007
SYNC-02-010 MUST A receiver MUST refuse an Add(CaseLedgerEntry) whose inReplyTo names another act than the one its entry commits.

An Add that names another act acknowledges an act the entry does not commit, so it is refused at the parse edge rather than read as either act's acknowledgement.
Refines: SYNC-02-007
Conflict Handling
ID Priority Requirement Related
SYNC-03-001 MUST A receiver MUST reject a replication message whose predecessor hash does not match the receiver's current log tail hash

An entry that does not extend the receiver's tail is in the wrong place for this replica. If the receiver applies it, the replica holds a chain that the CASE_MANAGER never wrote. The rejection tells the CASE_MANAGER where the replica's chain ends, so it can send the missing entries.
SYNC-03-002 MUST On receiving a rejection, the sender MUST retry replication starting from the entry following the last accepted hash reported by the receiver

The rejection names the last entry that the replica holds. Sending from the entry after it fills the gap with the fewest messages. Sending from any other point either skips entries the replica needs or sends entries it already has.
SYNC-03-003 MUST NOT A receiver MUST NOT add a duplicate entry to its log when the same log entry is delivered again, so that replication is idempotent.

The outbox retries and replays send entries again, so a receiver often gets one entry more than once. A duplicate in the log would break the gapless index and the hash chain, and its effects would apply twice (ID-02-001).
SYNC-03-005 MUST The CASE_MANAGER MUST refuse a Reject(CaseLedgerEntry) whose sender is not an active participant in the case (CM-10-004).

A rejection that states no ledger position, or the position of an empty chain, makes the CASE_MANAGER replay the whole ledger and send the case. Without this check, any sender could get embargoed case content just by asking. The replay cooldown limits how often a replay occurs, not who gets it.
Refines: HP-01-006
Supersedes: SYNC-03-002
Uses definition from: CM-10-004
SYNC-03-011 MUST NOT When the CASE_MANAGER refuses a Reject(CaseLedgerEntry) under SYNC-03-005, it MUST NOT record replication state for the sender or replay any entry or case to it.

A refusal that still replayed the ledger or the case would hand the sender the content the sender check withholds. Recording its position would let a later answer send that content too.
Extends: SYNC-03-005
SYNC-03-006 MUST Before a receiver buffers, applies or stores a received CaseLedgerEntry, it MUST recompute the entry's hash from its content. It compares that hash with the entry's stated entryHash.

The predecessor check (SYNC-03-001) proves only that an entry claims the right place in the chain. It does not prove that the content matches the entry's hash. Checking before the entry is buffered, applied or stored keeps broken content out of every place the replica reads from.
Uses definition from: SYNC-01-003
SYNC-03-012 MUST A receiver MUST refuse, and never buffer, apply or store, a CaseLedgerEntry that states no hash or whose content does not reproduce it.

An entry whose content does not match its hash is not the entry the CASE_MANAGER committed. A refused entry gets no Reject(CaseLedgerEntry), because a replay would send the same entry again. The receiver's tail does not move, so the next entry does not extend it and causes a Reject in the usual way. The receiver reports the refusal with a processing fault instead (SYNC-03-007).
Extends: SYNC-03-006
SYNC-03-007 MUST A participant that refuses a CaseLedgerEntry under SYNC-03-012 MUST send Create(ProcessingFault) with failure class LedgerEntryRefused/HashMismatch to the case's CASE_MANAGER, naming the refused Add(CaseLedgerEntry) by reference.

The entry was received but could not be processed, which ASK-07-001 and MSM-05-001 answer with a processing fault. Without it only the replica's log shows the refusal, while the CASE_MANAGER's replay resends the same entry. A hash mismatch is not a divergence: a fresh case copy cannot repair it, because the replica still cannot store the entry, so it takes this fault and not SYNC-16-001's. Like that fault, it is replication signalling and is never ledgered (SYNC-16-002).
Extends: SYNC-03-012
Refines: ASK-07-001
SYNC-03-013 MUST A participant MUST derive the id of the SYNC-03-007 fault from the refused Add(CaseLedgerEntry) and the failure class.

The CASE_MANAGER's replay delivers the same refused entry again. A derived id makes each repeat name the same fault, so the outbox and the CASE_MANAGER see one fault, not one per delivery (ID-04-004).
Extends: SYNC-03-007
SYNC-03-008 MUST NOT The CASE_MANAGER MUST NOT send anything, re-seed the peer or record replication state because of a SYNC-03-007 fault from an active participant (CM-10-004).

A hash mismatch comes from deterministic content: a fault in rendering or parsing the wire form, or a broken stored entry the send-side check (SYNC-03-009) did not see because fan-out checked its in-memory copy. Neither a replay nor a re-seed can repair it; only a code fix or an operator can. The reject-and-replay loop it leaves is already bounded by the replay cooldown (SYNC-15-003, SYNC-15-013).
Uses definition from: SYNC-03-007
Uses definition from: CM-10-004
SYNC-03-014 MUST The CASE_MANAGER MUST refuse the SYNC-03-007 fault from a sender that is not an active participant of the case (CM-10-004).

Only a participant the CASE_MANAGER replicates to can have been sent the refused entry. A fault from any other sender reports nothing the CASE_MANAGER sent, and refusing it gives such a sender no effect on the case.
Uses definition from: CM-10-004
Uses definition from: SYNC-03-007
SYNC-03-009 MUST Before the CASE_MANAGER sends a CaseLedgerEntry in Add(CaseLedgerEntry), it MUST recompute the entry's hash from its content, as SYNC-03-006 does. This holds for fan-out, replay and backfill alike.

A broken entry in the CASE_MANAGER's own store is found where it starts, not after a replica refuses it (SYNC-03-012) and reports it (SYNC-03-007). The receiver's check stays, because a fault in rendering or parsing the wire form still shows up first at the receiver.
Uses definition from: SYNC-03-006
SYNC-03-017 MUST NOT The CASE_MANAGER MUST NOT send an entry that states no hash, or whose content does not reproduce it, under SYNC-03-009. This takes precedence over SYNC-03-002, SYNC-17-004 and CM-10-006, which otherwise oblige it to send every entry in a range.

Broken content never leaves the CASE_MANAGER. Holding the entry back stalls the replica at it, as sending it would. The replica's Reject loop stays bounded without the replay cooldown: a replay that starts at the broken entry, as the replica's stalled Reject makes it, sends nothing, so it records no position (SYNC-15-011). The replica then sends one Reject per later fan-out, with nothing replayed to amplify it.
Extends: SYNC-03-009
Supersedes: SYNC-03-002
Supersedes: SYNC-17-004
Supersedes: CM-10-006
SYNC-03-018 MUST The CASE_MANAGER MUST log at ERROR each entry it holds back under SYNC-03-017, with the case, the entry, its log_index and the recipients.

A held-back entry stalls every replica the send was for. The ERROR record names what to repair and who is waiting for it.
Extends: SYNC-03-017
SYNC-03-019 MUST NOT When the CASE_MANAGER holds back an entry under SYNC-03-017, it MUST NOT send any later entry of the same send. This takes precedence over SYNC-03-002, SYNC-17-004 and CM-10-006, which otherwise oblige it to send every entry in a range.

The replica could only hold a later entry as a forward gap (SYNC-14-001), because its chain stops at the held-back entry.
Extends: SYNC-03-017
Supersedes: SYNC-03-002
Supersedes: SYNC-17-004
Supersedes: CM-10-006
Per-Peer Replication State
ID Priority Requirement Related
SYNC-04-001 MUST The replication leader MUST track per-peer state including at minimum the last acknowledged log entry hash for each peer

The leader must know how far each peer has got. Without that record, it cannot tell a peer that is behind from one that is current. It also cannot decide where a replay starts or whether the replay cooldown applies (SYNC-15-008).
Retry and Backoff
ID Priority Requirement Related
SYNC-05-001 SHOULD The replication sender SHOULD implement retry with exponential backoff on delivery failure

A peer can be offline or overloaded for some time. Retries at a fixed interval add load to that peer when it can least take it. Exponential backoff keeps retries frequent for a short fault and rare for a long one.
Leadership and Ownership
ID Priority Requirement Related
SYNC-06-001 SHOULD Replication leadership SHOULD be treated as distinct from case ownership

The Case Owner decides about the case, and the replication leader writes and sends the ledger. The Case Owner can hold the CASE_MANAGER role or give it to another actor, and a multi-node CASE_MANAGER can change its leader with no change of owner. If the two concepts are one, a change of either one forces a change of the other.
SYNC-06-003 MUST In a single-node deployment, the actor holding the CASE_MANAGER role MUST be treated as the permanent replication leader with exclusive write authority for its cases; no leader-election procedure is required.

A single-node deployment is a degenerate Raft cluster of one: there is always a quorum (1/1) and no election can occur, so the CASE_MANAGER is permanently the leader without consensus overhead. This is the expected topology for the prototype phase.
Commit Discipline
ID Priority Requirement Related
SYNC-09-001 MUST An implementation MUST treat a log entry as committed only once it is durably written to the authoritative log with its content hash recorded.

A durable entry with its hash recorded survives a crash and can be checked on replay. An entry treated as committed before that could vanish while other actors already rely on it.
SYNC-09-005 MUST NOT An implementation MUST NOT apply a log entry to the case state machine before the entry is committed under SYNC-09-001.

If an actor applies an entry that is not yet durable, a crash can leave state changes with no entry that records them. The replica then holds state that its ledger cannot explain, and a replay cannot rebuild it.
Uses definition from: SYNC-09-001
SYNC-09-002 MUST A node MUST commit the CaseLedgerEntry that records a Vultron message it sends only after it writes the message to its own outbox, never before. The one message sent after its commit is Add(CaseLedgerEntry): it delivers a committed entry, and is not an act the ledger records.

A ledger entry records a complete act, and a send is complete when the message is in the sender's outbox, which owns delivery and retries. An entry committed before the send records an intention that may never become true, and its fan-out can reach a replica before the message it records. A retry after a failed commit rebuilds the activity under its first id. The outbox does not queue it again while it is pending (OX-06-002), and the receiver drops a copy it already has (ID-02-001).
System Invariants
ID Priority Requirement Related
SYNC-08-001 MUST Append-only integrity: a log entry MUST be immutable once committed.

An entry that changes after commit no longer matches its hash, so every later entry in the chain breaks. A replica could also apply the changed entry and still pass the chain check.
Refines: SYNC-00-005 — Restates the immutability of SYNC-00-005 as a system invariant
SYNC-08-006 MUST Content-hash identity: each log entry MUST be uniquely identified by its content hash.

Replays and the drain find an entry by its hash. If two different entries could have the same hash, a replica could apply the wrong entry and still pass the chain check.
SYNC-08-002 MUST Deterministic projection: given an identical canonical recorded log prefix, all compliant implementations MUST derive identical state

Each replica gets its case state from the ledger. The ledger keeps replicas in step only if the same entries always give the same state, on every implementation. Any other input, such as the local clock or the arrival order, would let two replicas with the same ledger disagree.
SYNC-08-003 MUST NOT Idempotent replay: reprocessing any canonical recorded log prefix (including duplicates) MUST NOT change the resulting state

Replays, retries and restarts make an actor process some entries more than once. If a second pass changed the state, recovery itself would corrupt the case.
SYNC-08-004 MUST NOT Monotonic visibility: participants MUST NOT regress their acknowledged log position

The CASE_MANAGER uses each peer's acknowledged position to decide what to send and when to replay. A position that moves back would make it send again entries the peer already holds, and could reset the replay cooldown. An acknowledged entry stays in the peer's append-only ledger, so a lower position is never true.
SYNC-08-005 MUST Reject-on-divergence: a receiver MUST reject an entry that does not extend its current hash chain.

"Rejected" means "not applied and not persisted as the current tail"; it does not require discarding the entry. A forward-gap entry (a valid entry whose predecessor has not yet arrived) may be held in the non-ledger holding area of SYNC-14 until its predecessor arrives. See ADR-0037 (docs/adr/0037-buffer-out-of-order-ledger-entries.md).
SYNC-08-007 MUST A receiver MUST trigger resynchronization for each entry it rejects under SYNC-08-005, a held forward-gap entry included.

Holding an entry covers one that arrives out of order, not one that was lost. The Reject that triggers resynchronization stays the backstop for entries that never arrive (SYNC-14-002).
Extends: SYNC-08-005
Catch-Up Gate Before New Actions
ID Priority Requirement Related
SYNC-10-001 MUST After actor process restart or recovery, an actor with case state in scope MUST re-establish case-ledger freshness with the CASE_MANAGER before taking new protocol-significant case actions

After a restart, an actor can have missed entries while it was down. If it acts on that old view, it can propose or answer from a case state that the missed entries have changed. Catching up first makes its next action rest on the current case history (ADR-0018).
SYNC-10-002 MUST While catch-up freshness is not established, the actor MUST block or defer new protocol-significant case actions and surface an explicit stale-or-catching-up condition

An action taken from a stale view can conflict with entries the actor has not seen, and blocking the action prevents this. A visible stale condition tells an operator or a test why the action did not run, so a stuck catch-up does not look like a silent failure.
SYNC-10-003 SHOULD Catch-up freshness checks SHOULD use the actor's last acknowledged canonical hash and replay mechanisms so that action gating is based on canonical log position, not local wall-clock assumptions

Clocks on different actors do not agree, and the time since the last message does not show whether an entry is missing. The hash of the last canonical entry is the same on every replica that holds the same prefix, so it is a reliable test of freshness.
SYNC-10-004 MUST The catch-up gate MUST block protocol-significant case actions while the actor's canonical log prefix, from genesis through its currently acknowledged tip, has any gap.

A gap means that a committed effect is missing from the replica's case state. An action based on that state can contradict the missing entry. The hash chain shows a gap directly, so the gate can test for it without a request to the CASE_MANAGER.
SYNC-10-005 MUST NOT The catch-up gate MUST NOT require the actor's acknowledged tip to equal the CASE_MANAGER's current ledger tip; lagging behind the leader tip is allowed if the actor's own acknowledged prefix is contiguous from genesis

Fan-out is asynchronous, so a participant is often a few entries behind the CASE_MANAGER. If the gate required the latest tip, an active case would block almost every action. A contiguous prefix is enough to make the actor's own view consistent, and the later entries reach it in time.
Effects-Before-Persist Invariant
ID Priority Requirement Related
SYNC-12-001 MUST A participant MUST apply all domain effects derived from a CaseLedgerEntry before it persists the entry to its local ledger. The effects include embargo teardown, participant-status update, note attachment and invite-accept.

A stored entry is the replica's proof that the entry's effects were applied (SYNC-12-002). If the replica stored the entry first and an effect then failed, the already-stored check (SYNC-12-003) would skip that effect on every later delivery. The replica would keep a case state that its ledger does not explain.
SYNC-12-004 MUST NOT A participant MUST NOT persist a CaseLedgerEntry when any domain effect derived from it fails.

A stored entry tells every later delivery that its effects are done (SYNC-12-003). An entry stored after a failed effect would keep that effect from ever running.
Extends: SYNC-12-001
SYNC-12-002 MUST The presence of a CaseLedgerEntry in a participant's local ledger MUST imply that all domain effects for that entry were successfully applied; a persisted entry with unapplied effects is a protocol violation

The already-stored check (SYNC-12-003) and the drain both rely on this meaning. If a stored entry could have missing effects, nothing would ever apply them, and the replica would differ from the CASE_MANAGER permanently.
SYNC-12-003 MUST When a participant receives a CaseLedgerEntry that is already present in its local ledger, the participant MUST skip both effects and persist (treat as already-done); re-applying effects to a stored entry is not permitted because the entry's effects were applied exactly once before the initial persist

Duplicate delivery is normal under retries and replays. The effects of a stored entry were applied once, before the entry was stored (SYNC-12-001). Applying them again would repeat state changes such as a status update or an embargo teardown.
Ledger Write Ownership and Layer Boundary

SYNC-12's already-stored gate (SYNC-12-003) uses the presence of a CaseLedgerEntry in an actor's DataLayer as the sole evidence that the entry's effects were already applied. That inference is only sound if the ONLY thing that ever writes a CaseLedgerEntry to the DataLayer is the core write path that also applies the effects. If any other layer (e.g. a wire/adapter parse or rehydration helper) creates a CaseLedgerEntry record, the gate fires SUCCESS on first delivery and the effects are silently skipped. These requirements make the write-ownership boundary that SYNC-12 depends on explicit.

ID Priority Requirement Related
SYNC-13-005 MUST CaseLedgerEntry records for a case's authoritative ledger MUST be authored only by the case's CASE_MANAGER; no other actor may write authoritative case ledger entries.

The CASE_MANAGER's single authoritative write path is the enforcement mechanism for the ledger's append-only integrity and the write-ownership guarantee required by SYNC-12.
Refines: SYNC-01-004 — Restates the single-writer rule of SYNC-01-004 for CaseLedgerEntry records
SYNC-13-006 MUST Participants MUST obtain replica CaseLedgerEntry records solely from received Add(CaseLedgerEntry) activities.

Channelling all replica writes through the receive behavior tree ensures that effects are applied in the correct order and that the already-stored gate (SYNC-12-003) is the sole idempotency mechanism.
SYNC-13-004 MUST A receiver MUST treat an inbound Add(CaseLedgerEntry) as the announcement of a ledger entry on first delivery, without needing any stored record of the entry.

On first delivery the receiver has no stored record of the entry, so routing cannot depend on one.
SYNC-13-009 MUST A receiver MUST use only the already-stored check (SYNC-12-003) to tell the first delivery of a ledger entry from a repeat delivery.

One test for repeat delivery keeps all implementations in agreement about when effects run. A second test could disagree with it and skip or repeat effects.
Extends: SYNC-13-004
Uses definition from: SYNC-12-003
Out-of-Order Entry Buffering and Drain

Add(CaseLedgerEntry) is delivered over a transport with no ordering guarantee, and Vultron may not be the only implementation on the wire, so a replica can receive an entry before its hash-chain predecessor. Dropping such an entry and relying on a reject/replay round-trip does not converge under adversarial reordering, because replay re-announces entries individually over the same unordered transport (they can reorder and be dropped again). These requirements make replica convergence independent of delivery order by holding the received Add of a forward-gap entry in a non-ledger holding area and replaying it, in hash-chain order, once the entry that closes the gap is committed. What is held and replayed is the Add that was received, never one the replica builds. Rationale: ADR-0037 (docs/adr/0037-buffer-out-of-order-ledger-entries.md), ADR-0214.

ID Priority Requirement Related
SYNC-14-001 MUST A forward gap is a valid Add(CaseLedgerEntry) whose prev_log_hash does not match the participant's chain tail and whose log_index is greater than tail_index + 1. A participant MUST keep the Add that carried a forward-gap entry, as the body that arrived (VM-08-002), in a holding area until its predecessor arrives.

The hash chain makes it safe to hold an entry for any length of time. The replica applies a held entry only after it commits an entry whose entry_hash equals the held entry's prev_log_hash, so a fork or a rewrite cannot act as the predecessor. Discarding the entry for good would leave the replica to wait for a replay that the next delivery may lose again.
Uses definition from: VM-08-002
SYNC-14-010 MUST NOT A participant MUST NOT hold a forward-gap entry apart from the Add(CaseLedgerEntry) that carried it.

The replica holds the Add and not the entry alone, so the drain applies what the replica received. An entry held alone can only reach the inbox again inside an Add that the replica makes up, which names a sender that never sent it.
Extends: SYNC-14-001
SYNC-14-002 MUST A participant that holds a forward-gap entry's Add MUST still send Reject(CaseLedgerEntry) carrying its last accepted hash (SYNC-08-007). The Reject makes the CASE_MANAGER replay entries that were lost, never delivered, rather than merely reordered.

Holding an entry covers an entry that arrives out of order. It does not cover an entry that was lost. The Reject tells the CASE_MANAGER where the replica's chain ends, so the lost entry is sent again. Without it, a replica with a lost entry would hold its later entries permanently.
Refines: SYNC-08-007
SYNC-14-003 MUST After a participant commits a CaseLedgerEntry, it MUST drain the holding area. For each newly committed tail, it finds the held Add, if any, whose entry's prev_log_hash equals the tail's entry_hash. It applies that entry, and repeats until no held Add extends the current tail.

A held entry can apply only after its predecessor. Each commit can make one held entry appliable, and that entry can make the next one appliable. If the drain stopped after one step, entries that arrived early would stay held until some other delivery came.
SYNC-14-004 MUST Draining a held entry MUST apply the entry's domain effects before persisting it (SYNC-12-001).

A drained entry becomes a stored entry like any other. The already-stored check relies on every stored entry having its effects applied, so the drain must keep the same order (SYNC-12-001).
Refines: SYNC-12-001 — The drain MUST preserve the effects-before-persist invariant per applied entry
SYNC-14-007 MUST NOT The drain path MUST NOT re-apply effects for an entry already present in the local ledger (SYNC-12-003).

Re-applying effects for a previously committed entry would cause duplicate state transitions and violate the idempotency guarantee established by SYNC-12-003. A replayed Add reaches the same already-stored check as any delivery (SYNC-14-008), so an entry committed between its hold and its replay is skipped, not applied again.
Refines: SYNC-12-003
SYNC-14-008 MUST Applying a drained entry MUST follow the same apply-then-persist rules as in-order delivery, starting from the held Add as in-order delivery starts from the received one.

A separate drain path can drift away from the in-order path. A drained entry could then apply its effects after it is stored, or skip a check that in-order delivery makes. One shared path keeps the effects-before-persist rule true for every entry (SYNC-12).
Genesis-Unavailable Buffer-and-Reject

A participant replica receives Add(CaseLedgerEntry) activities from the CASE_MANAGER over an unordered transport. If the CASE_MANAGER delivers a ledger entry before the Create/Announce(VulnerabilityCase) activity has been processed by the participant (a delivery race under HTTP BackgroundTasks), the replica cannot reconstruct the per-case genesis hash (CLP-08-005) and must not silently drop the entry. Silently dropping causes the entry to be permanently lost because the CASE_MANAGER never learns that delivery failed and never replays. A pre-genesis entry is therefore held in the same non-ledger holding area used for forward gaps (SYNC-14) and drained once the case seed anchors the genesis hash, making convergence independent of whether the case or its ledger entries arrive first (issue #2186, #2180). A Reject is still sent as the loss backstop, triggering the same replay path as the hash-mismatch case (SYNC-08-005, SYNC-14-002) for an entry that is genuinely lost rather than merely early. The backstop is asked once per wait, not once per held entry, and the CASE_MANAGER answers once per need; both limits are rate limits, never stops (SYNC-15-016 to SYNC-15-025, ADR-0168). The forward-gap hold of SYNC-14 alone does not cover this window: it only holds entries for a case whose genesis anchor is already known, so a distinct pre-genesis hold and a drain triggered by the case seed are required. Rationale for the buffer-and-drain path (SYNC-15-004, SYNC-15-005): ADR-0059 (docs/adr/0059-buffer-pre-genesis-ledger-entries.md).

ID Priority Requirement Related
SYNC-15-001 MUST A participant that receives an Add(CaseLedgerEntry) before it holds the VulnerabilityCase cannot reconstruct the per-case genesis hash (CLP-08-002). Such a participant MUST tell the CASE_MANAGER by sending it a Reject(CaseLedgerEntry) with last_accepted_hash="". The CASE_MANAGER then replays all entries from the beginning once the case is delivered. The one exception is a Reject that an earlier such Reject for the same case lets the participant withhold (SYNC-15-016).

An empty last_accepted_hash means "I hold no entries; replay from genesis." The CASE_MANAGER's replay path (SYNC-03-002) replays every entry after the hash it receives. An empty string matches no entry, so it replays the full ledger. Without the Reject, the CASE_MANAGER never learns that the delivery failed, and the replica stays without the entry permanently. One Reject asks for the whole ledger, so a second one asks for nothing new (ADR-0168).
Uses definition from: CLP-08-002 — The missing-case failure originates from the genesis-hash derivation in CLP-08-002
Refines: SYNC-08-005 — Reject-on-divergence applies equally to the genesis-unavailable case
SYNC-15-002 MUST NOT A participant MUST NOT persist a CaseLedgerEntry when the per-case genesis hash is unavailable.

Without the genesis hash, the replica cannot check that the entry belongs to this case's chain. A stored entry also means that its effects were applied (SYNC-13-001). Storing an unchecked entry would put an entry in the ledger that may not be canonical, and its effects would never apply.
SYNC-15-006 MUST NOT A CaseLedgerEntry received when the per-case genesis hash is unavailable MUST NOT be treated as committed.

Treating a pre-genesis entry as committed would populate the already-stored gate (SYNC-12-003) prematurely, causing effects to be skipped when the entry is later drained after the genesis is seeded.
SYNC-15-007 MUST NOT The domain effects of a CaseLedgerEntry received when the per-case genesis hash is unavailable MUST NOT be applied (SYNC-12-001).

Applying effects before the genesis hash is known means the effects cannot be attributed to a verified chain position; if the genesis hash later reveals the entry is a fork, already-applied effects cannot be rolled back.
See also: SYNC-12-001 — context for the reader
SYNC-15-003 SHOULD The CASE_MANAGER SHOULD bound the rate at which it replays entries to a peer whose acknowledged replication position has not advanced.

A peer that cannot anchor its hash chain rejects every entry replayed to it. Each Reject causes a replay, and each replayed entry causes another Reject. Without a bound, this loop grows without limit and can starve the CASE_MANAGER's other work. The bound is a rate limit and not a stop, because a later Reject must still get a replay when a replayed entry is lost.
Constrains: SYNC-03-002 — The replay-from-hash path whose rate this rule limits
Constrains: SYNC-15-001 — The genesis Reject that SYNC-15-001 mandates is the highest-volume source of no-progress replays
SYNC-15-004 MUST This rule covers a participant that receives a valid Add(CaseLedgerEntry) before it holds the VulnerabilityCase, so it cannot reconstruct the per-case genesis hash (CLP-08-002). Such a participant MUST keep the Add, as received, in the forward-gap holding area (SYNC-14-001), keyed by the entry's prev_log_hash, until the case seed arrives. Unlike a forward gap, this hold needs no tail_index comparison, because no chain tail exists before genesis. Every entry for the missing case is held, the genesis entry (log_index 0) included.

The reject and replay recovery (SYNC-15-001) does not converge when deliveries arrive out of order, for the same reason that forward gaps are held (SYNC-14). The replay sends entries one by one over the same unordered transport, so each early entry is rejected again. This adds load, and each round can lose an entry. Holding the entry lets it drain in order once the case is seeded, so the participant does not rely on the round-trip alone.
Uses definition from: SYNC-14-001 — Reuses the same non-ledger holding area and prev_log_hash keying as the forward-gap hold
Extends: SYNC-15-001 — The Reject is retained as the loss backstop; holding is the primary convergence path
Uses definition from: CLP-08-002
SYNC-15-005 MUST After a participant seeds the VulnerabilityCase, through Create or Announce(VulnerabilityCase), it MUST drain the holding area for that case. Seeding anchors the deterministic per-case genesis hash (CLP-08). The participant finds the held Add, if any, whose entry's prev_log_hash equals that genesis hash, and replays it (SYNC-14-009). The replay applies the entry and then persists it, as in-order delivery does (SYNC-14-004). The drain cascades in hash-chain order (SYNC-14-003) until no held Add extends the current tail.

A participant can compute the genesis hash from the case object alone: it comes from the case id, the creation time and the Case Owner's actor id (CLP-08-002). Seeding the case therefore anchors the chain, and the participant need not wait for a second delivery of the genesis entry. Draining on seed turns the pre-genesis hold (SYNC-15-004) into convergence.
Uses definition from: SYNC-14-003 — Reuses the cascading drain defined for forward gaps
Uses definition from: SYNC-14-004
Uses definition from: SYNC-15-004 — Drains exactly the entries that SYNC-15-004 held during the pre-genesis window
Uses definition from: SYNC-14-009
SYNC-15-015 MUST When the CASE_MANAGER answers a Reject(CaseLedgerEntry) with last_accepted_hash="" with a replay, it MUST first send Announce(VulnerabilityCase) to the rejecting peer.

A peer that rejects from genesis does not hold the case, so it cannot compute the per-case genesis hash (CLP-08-005). Without the case, the peer fails the chain check on each replayed entry and rejects it again. The case lets the peer anchor its chain and drain the entries it holds (SYNC-15-005), so the replay that follows can apply.
SYNC-15-016 SHOULD NOT A participant that has sent the CASE_MANAGER a Reject(CaseLedgerEntry) with last_accepted_hash="" for a case it still does not hold SHOULD NOT send another for that case until a bounded interval has passed since the last one.

One genesis Reject asks for the case and the whole ledger. The participant holds every early entry and drains them when the case arrives (SYNC-15-004, SYNC-15-005), so a Reject for each further early entry asks for nothing the first did not. On a loaded host the CASE_MANAGER answered each of them with a full replay, and the duplicates delayed unrelated messages by about 20 seconds (#5552).
Supersedes: SYNC-15-001
SYNC-15-017 MUST A participant that withholds genesis Rejects under SYNC-15-016 MUST send one for the first entry of the still-missing case it receives after the interval has passed, as a new activity rather than a redelivery of an earlier Reject.

The genesis Reject is the only recovery for a participant whose replay was lost, so withholding it may delay recovery but never end it. A redelivery of an earlier Reject carries that Reject's id, and the CASE_MANAGER drops a known id as a duplicate (ID-02-001), so a request after the interval must be its own activity.
Extends: SYNC-15-016
SYNC-15-018 MUST Once a bounded interval has passed since an actor's rate limit last let through a replay, or a replay request, about the same case and position, that limit MUST let the next one through.

Every limit in this group trades recovery time for quiet. A limit that never lets a later request or replay through would turn a lost replay into a replica that never converges.
Constrains: SYNC-15-003
SYNC-15-019 MAY The CASE_MANAGER MAY decline to answer a Reject(CaseLedgerEntry) with last_accepted_hash="" whose rejected entry was included in a replay from genesis it sent the same peer within a bounded interval; declining sends neither the case nor any entry.

A Reject the CASE_MANAGER handles after it already replayed that entry from genesis to the same peer asks for a replay that is already on its way. The CASE_MANAGER cannot rely on every participant to limit its own requests (SYNC-15-016), because other implementations share the wire, so it may limit them itself.
Implements: SYNC-15-003
Divergence Recovery

Under the copy model (ADR-0124) a replica applies each entry through one apply function that refuses an entry whose starting state does not match the replica's case file. When the refused entry already extends the replica's stored chain, no replay can fill the gap: the replica's case file has diverged from the CASE_MANAGER's, and the reject and replay path resends the same refused entry forever. A divergence is a defect, not a steady state, so the replica reports it and the CASE_MANAGER repairs it with a fresh case copy that names the ledger position it reflects. The fault is replication signalling, like the gap Reject, and is never ledgered. Rationale: ADR-0142.

ID Priority Requirement Related
SYNC-16-001 MUST This rule covers a participant that refuses a CaseLedgerEntry whose prev_log_hash matches its chain tail. It refuses the entry because the entry's starting state does not match its case file. The rule applies only when the participant's case file is not already past the entry. Such a participant MUST send Create(ProcessingFault) with failure class LedgerEntryRefused/CaseDiverged to the case's CASE_MANAGER, naming the refused Add(CaseLedgerEntry) by reference.

The entry was received but could not be processed, which MSM-05-001 assigns to a processing fault. Without it the CASE_MANAGER sees only gap Rejects, and its replay resends the entry the replica refuses. An entry whose content is invalid in itself, such as the impossible participant status of RSH-09-006, is not a divergence: a fresh copy cannot repair it, so it takes that requirement's fault instead of this one.
Refines: ASK-07-001
SYNC-16-009 MUST A participant that sends the SYNC-16-001 fault MUST keep holding the refused entry, as SYNC-14-001 holds a forward gap.

The re-seed that answers the fault (SYNC-16-003) lets the replica apply the held entry once its case file is replaced. A dropped entry would need another replay after the re-seed.
Extends: SYNC-16-001
Uses definition from: SYNC-14-001
SYNC-16-002 MUST NOT A processing fault that reports a failure to apply a CaseLedgerEntry MUST NOT be committed to the case ledger, by the participant or by the CASE_MANAGER. The CASE_MANAGER's response to it is per-peer replication state (SYNC-04), except for the hash-mismatch fault, which changes nothing (SYNC-03-008).

It reports on replication, as Reject(CaseLedgerEntry) does. Ledgering it loops: the diverged replica cannot apply the entry that records its own fault, and a failure to apply that entry would be another fault to ledger.
Refines: CLP-04-007
Refines: ASK-07-008
See also: SYNC-03-008 — scope boundary: SYNC-03-008 states no ledger-commit rule
SYNC-16-003 MUST When the CASE_MANAGER receives the SYNC-16-001 fault from an active participant of the case (CM-10-004), it MUST send that participant Announce(VulnerabilityCase) of its current case.

The CASE_MANAGER's case is authoritative (PCR-03-001), and a copy carrying its ledger position (SYNC-16-005) lets the replica replace its case file and backfill (SYNC-16-022, SYNC-16-007).
Uses definition from: CM-10-004
Uses definition from: SYNC-16-001
SYNC-16-010 MUST The CASE_MANAGER MUST refuse the SYNC-16-001 fault from a sender that is not an active participant of the case (CM-10-004).

The sender gate is the active-participant standing (CM-10-004, CM-23-020), not the gap Reject's (SYNC-03-005): that one admits a closed participant, but a copy of the current case would cross the closure cutoff such a participant is held to (CM-23-004), so its diverged replica is not repaired this way.
Uses definition from: CM-10-004
Uses definition from: SYNC-16-001
SYNC-16-011 MUST NOT When the CASE_MANAGER refuses the SYNC-16-001 fault under SYNC-16-010, it MUST NOT send anything or record replication state for the sender.

A refusal that still sent the case, or recorded the sender's position, would give the sender the case content the gate withholds.
Extends: SYNC-16-010
Uses definition from: SYNC-16-001
SYNC-16-004 MUST The CASE_MANAGER MUST bound the rate at which it re-seeds a peer under SYNC-16-003. A fault received within the cooldown triggers no new re-seed, and a fault after it does.

A diverged replica faults once per replayed entry it refuses. A rate limit stops a re-seed storm without stranding a peer whose re-seed was lost, which a permanent suppression would (SYNC-15-003 makes the same choice for replay).
Supersedes: SYNC-16-003
SYNC-16-012 MUST The CASE_MANAGER MUST record, per peer, the time and the ledger tail of its last re-seed under SYNC-16-003.

The rate bound of SYNC-16-004 needs the time of the last re-seed to measure the cooldown. The tail it sent lets a later fault be judged against the copy the peer was given (SYNC-16-008).
Implements: SYNC-16-004
Uses definition from: SYNC-16-003
SYNC-16-005 MUST Each VulnerabilityCase MUST store its ledger position (ledgerPosition), the position its case file is a projection of. The position is the log_index and entry_hash of the last entry applied to the case or, before any, index -1 and the per-case genesis hash.

A case copy is the case as applying the ledger up to some entry leaves it (ADR-0124); the position names that entry, so a receiver can tell a current copy from a stale one. Stored on the case, it is right on a replica too, whose case can be ahead of its own chain after it replaces its case with a copy.
SYNC-16-015 MUST An actor that commits an entry, or stores one as a replica, MUST move the case's ledger position to that entry atomically with storing it. The exception is an entry the position is already past or already names (SYNC-16-016).

Moving the position with the entry it names keeps the two from disagreeing. A crash between the two writes would leave a case that names an entry its ledger lacks, or a ledger past the case it explains.
Extends: SYNC-16-005
SYNC-16-016 MUST An actor MUST leave the case's ledger position unchanged when it stores an entry that the position is already past or already names.

Never moving the position back keeps a case that a copy put ahead of its chain at the copy's position while the chain catches up (SYNC-16-007). A different entry at the position's index is a conflict, not one the position already reflects.
Supersedes: SYNC-16-015
SYNC-16-017 MUST A ledger entry whose payloadSnapshot carries the case MUST carry the case at the position before that entry.

A snapshot taken before the entry keeps any entry's hash from depending on itself.
Uses definition from: SYNC-16-005
SYNC-16-018 MUST The ledger position MUST travel with the case on its wire form, so a copy names the position it reflects.

A receiver can judge a copy only against the position the copy states (SYNC-16-006). A copy that left its position behind could not be told from a stale one.
Extends: SYNC-16-005
SYNC-16-019 MUST A receiver MUST refuse a received case that carries no ledger position.

A case with no position cannot be compared with the receiver's own, so taking it could move the receiver's case back to a stale copy.
Extends: SYNC-16-018
SYNC-16-006 MUST This rule covers a participant that receives Announce(VulnerabilityCase) from the case's CASE_MANAGER for a case it already holds, a repeat of an earlier Add included. Such a participant MUST compare the copy's ledger position (SYNC-16-005) with its own. Its own position is the later of its chain's tail and its case's stored position.

The transport is unordered and the outbox retries, so an old copy can arrive late. The case's stored position counts as well as the chain, because after a replacement the case can be ahead of the chain, and a copy older than the replacing one must not move it back.
Uses definition from: SYNC-16-005
SYNC-16-020 MUST When a participant's own position (SYNC-16-006) is already past the copy's, it MUST leave its case file unchanged, as for a repeat delivery.

Replacing the case file with an older copy would drop the effects of the entries the replica already holds past the copy.
Extends: SYNC-16-006
SYNC-16-021 MUST A participant MUST refuse the copy, leaving its case file unchanged, when it holds, or its case names, another entry at the copy's index.

A different entry at the same index means the chains themselves disagree, which no copy repairs.
Extends: SYNC-16-006
SYNC-16-022 MUST When neither SYNC-16-020 nor SYNC-16-021 applies, the participant MUST replace its case file with the copy, taking the copy's position.

A copy at or past the participant's own position, with no conflicting entry, is the CASE_MANAGER's current case. Replacing the case file with it repairs a diverged replica (SYNC-16-003).
Extends: SYNC-16-006
See also: SYNC-16-020 — context for the reader
See also: SYNC-16-021 — context for the reader
SYNC-16-007 MUST A participant MUST send Reject(CaseLedgerEntry) carrying its own tail after it replaces its case file under SYNC-16-006 with a copy ahead of its chain.

The copy is ahead of the chain, so the replica lacks the entries between them. The Reject asks the CASE_MANAGER to replay them, so the replica ends where seed-plus-replay leaves it (ADR-0114).
Uses definition from: SYNC-16-006
SYNC-16-023 MUST This rule covers a participant whose case's position is ahead of its chain. Such a participant MUST store each entry it receives at or before that position as an idempotent no-op, never refusing it. This covers a case put ahead by a replacement or by a first seed from a copy (PCR-02-003). It covers an entry replayed or drained from the holding area (SYNC-14-003) alike.

Those entries are already reflected in the copy. The refused entry the replica held under SYNC-16-001 drains first, before any replay arrives, so a rule that covered only replayed entries would refuse it again. Storing them advances the chain to the copy's position, after which the entries that follow apply normally. A first seed is the same case: the copy already reflects the entries the joining replica's backfill brings.
Uses definition from: PCR-02-003
Uses definition from: SYNC-14-003
SYNC-16-024 MUST NOT A participant MUST NOT move the case's position back for an entry it stores under SYNC-16-023 (SYNC-16-005).

The case already reflects the copy's position. Moving it back for an older entry would make the case name a position its case file is past.
Refines: SYNC-16-016
Uses definition from: SYNC-16-005
Uses definition from: SYNC-16-023
SYNC-16-025 MUST A participant that SYNC-16-023 covers MUST refuse, not store, an entry at the position's index whose hash differs from the one the position names.

The entries before the position carry no hash the case names, so a chain that diverged among them shows only at the position's index. Refusing the entry there keeps the chain from naming one entry and the case another.
Supersedes: SYNC-16-023
SYNC-16-026 MUST A participant MUST log at ERROR each conflicting entry it refuses under SYNC-16-025.

A conflict at the position's index means the replica's chain and its case disagree, which no replay repairs. The ERROR record makes it visible to an operator.
Extends: SYNC-16-025
SYNC-16-027 MUST When the participant's chain stores no entry, it MUST ask under SYNC-16-007 with a position statement, Read(<case>/ledger) (SYNC-17-001), stating the empty chain's ledgerPosition: index -1 and the case's genesis hash (SYNC-18-001). It names the Announce(VulnerabilityCase) that carried the copy in inReplyTo.

A replica with no entry has none for a Reject to name. Waiting for the next fan-out would stall it on a quiet case, so it states that it holds nothing, which asks for everything. The one position-statement form serves it, so no message needs an objectless Reject (ADR-0204).
Refines: SYNC-16-007
Uses definition from: SYNC-18-001
Uses definition from: SYNC-17-001
SYNC-16-028 MUST A receiver MUST refuse a Reject that names no object, whatever ledgerPosition or target it states.

A Reject declines what its object names. The empty-chain request is a position statement (SYNC-16-027), so no Reject is left that may name nothing, and a Reject with no object gives no point to replay from (ADR-0204).
Extends: SYNC-16-027
SYNC-16-029 MUST The CASE_MANAGER MUST answer the empty-chain statement of SYNC-16-027 by replaying every entry of its ledger, as it answers any stated position (SYNC-17-004).

The replica holds no entry, so every entry after index -1 is every entry. It holds the case, so no case copy goes ahead of them.
Extends: SYNC-16-027
Uses definition from: SYNC-17-004
Participant Position Statements

A participant's replica can fall behind with nothing to show it: when the last Add(CaseLedgerEntry) before a quiet period is lost, no later entry arrives with a gap, so no Reject(CaseLedgerEntry) is sent and the reject-and-replay loop never starts. The CASE_MANAGER cannot see the lag either, because nothing tells it how far a participant has got. The participant therefore states its position, when it chooses, in a Read(<case>/ledger), a Read of the case's ledger, and the CASE_MANAGER replays every entry after that position. A position behind its tail, or the empty ledger's at index -1, so asks for a replay. The position stated on every case activity (SYNC-18) composes the same answer. This is how the LedgerReconciliation phase detects a gap and retries until convergence (SYNC-00-003, SYNC-00-007, SYNC-00-008). Rationale: ADR-0155, ADR-0204.

ID Priority Requirement Related
SYNC-17-001 MAY A participant MAY send the case's CASE_MANAGER Read(<case>/ledger), whose object is the case's ledger <case>/ledger, an OrderedCollection named by its id and type, whose context is the case and whose ledgerPosition is the participant's tail in that ledger. A participant that holds no entry for the case states the empty ledger's position, index -1 with the case's genesis hash.

ActivityStreams defines Read as the actor having read the object, so the activity states how far the sender has read the ledger. The CASE_MANAGER replays what follows, so a position behind its tail, or at -1, asks for a replay; one at its tail asks for nothing. A Reject(CaseLedgerEntry) would claim a refusal that did not happen, and naming the ledger rather than an entry gives every position, -1 included, one form with no bare object id (SE-01-006, ADR-0204).
SYNC-17-002 MUST The CASE_MANAGER MUST refuse a Read(<case>/ledger) position statement (SYNC-17-001) from a sender that is not an active participant in the case (CM-10-004). It reports REFUSED.

An inert or closed participant's replica stops on purpose, so its stated position always lags, and answering it would send withheld case content (SYNC-03-005). CM-10-006's backfill catches up a participant that becomes active again. The Invite resend is no answer to the position and runs apart from this check (SYNC-20-001, ADR-0163): an unconsented participant on the roster is resent the Invites it was already sent, which carry no withheld content, and its statement is otherwise refused.
Uses definition from: CM-10-004
Refines: HP-01-006
Uses definition from: SYNC-17-001
SYNC-17-009 MUST NOT When the CASE_MANAGER refuses a stated position under SYNC-17-002, it MUST NOT record replication state for the sender or send anything in answer.

A recorded position would let a later answer send the withheld content, and any answer now would send it at once.
Extends: SYNC-17-002
SYNC-17-003 MUST When the CASE_MANAGER acts on a stated position (SYNC-17-002) that its ledger holds, it MUST record the position's hash as the sender's acknowledged position in its per-peer replication state (SYNC-04-001).

The CASE_MANAGER has no other record of how far a quiet participant has got (SYNC-04-001). The stated entry is a fact the participant reports about itself, so recording it gives the replay a correct start and the cooldown a correct position.
Extends: SYNC-04-001
See also: SYNC-17-002 — context for the reader
SYNC-17-004 MUST When the stated position the CASE_MANAGER acts on (SYNC-17-002) is behind its tail, it MUST send the sender each later canonical entry, in log order. It sends them as Add(CaseLedgerEntry), under the replay rate bound (SYNC-15-003, SYNC-15-013) and outbox de-duplication (SYNC-15-012) of a Reject-triggered replay.

This is the retry that SYNC-00-008 requires. It runs whenever the participant reads, so a lost last entry is recovered without waiting for a new commit. A Read can predate entries already on their way to the sender, so a stated lag can be transient; the replay rate bound, not the outbox de-duplication, is what limits the replays such a race causes.
Implements: SYNC-00-008
Uses definition from: SYNC-15-003
Uses definition from: SYNC-15-012
Uses definition from: SYNC-15-013
See also: SYNC-17-002 — context for the reader
SYNC-17-010 MUST When the stated position the CASE_MANAGER acts on (SYNC-17-002) is its ledger tail, it MUST send nothing in answer.

A participant at the tail is missing nothing, so any entry sent would be a duplicate.
See also: SYNC-17-002 — context for the reader
SYNC-17-005 MUST When a stated position names an entry the CASE_MANAGER's ledger does not hold, an index at which its entry has a different hash, or index -1 with a hash other than the case's genesis hash, the CASE_MANAGER MUST log it at WARNING with the sender and the position, record no replication state and send nothing.

Such a position is not a lag, and replaying from a guessed point would send a suffix the replica cannot anchor. A replica whose case file has diverged reports it by SYNC-16-001.
SYNC-17-006 MUST NOT The CASE_MANAGER MUST NOT commit a ledger entry for a Read(<case>/ledger) or for its answer to one.

Stating a position changes nothing in the case file, so it is an observation and not a case event (ADR-0152). Ledgering it would add an entry every time a participant checks, which itself would leave every other participant behind.
SYNC-17-008 SHOULD Once an Announce(VulnerabilityCase) has seeded a participant's replica of a case it did not hold (PCR-02-003), the participant SHOULD send the case's CASE_MANAGER one Read(<case>/ledger) (SYNC-17-001) stating the ledger position the seeded case is at (SYNC-16-005).

A joiner that dropped an Invite before its case copy arrived (CBT-03-003) may have nothing else to send, so the CASE_MANAGER never learns that its replica is ready. The statement tells it, and the CASE_MANAGER can then resend each Invite the participant has not answered (ADR-0163). The seeded case reflects every entry up to the copy's position, and the replica stores none of them yet (SYNC-16-007), so that position is the replica's tail. A copy that updates a held replica tells the CASE_MANAGER nothing new, and SYNC-16-007 already asks for what it lacks.
Uses definition from: PCR-02-003
Uses definition from: SYNC-16-005
Refines: SYNC-17-001
Sender Ledger Position on Case Activities

Every case activity states the ledger position its sender held when it built the activity, so the case ledger records what each actor knew when it acted. The position is a record, not a gate: an actor that lags the CASE_MANAGER's latest entry may still act (SYNC-10-005), and a stale answer to a replaced object is already refused by the object it names (CM-18-003). A lagging position is answered as a Read(<case>/ledger) is (SYNC-17), and a position the CASE_MANAGER's ledger does not hold is a split chain, which it repairs. Rationale: ADR-0156.

ID Priority Requirement Related
SYNC-18-001 MUST Every activity about a case whose ledger its sender holds MUST carry the sender's ledger tail for that case as its ledgerPosition. Its logIndex and entryHash name the last entry the sender had committed, or stored as a replica, when it built the activity. For an empty ledger they are index -1 and the per-case genesis hash. A Read(<case>/ledger) carries it as the position it states (SYNC-17-001).

One rule for every sender and message type gives every ledgered act its provenance, and a new message type needs no decision about whether it counts. Join, Ignore, Leave and Offer of a case name the case and act on it, so they carry the sender's position. The property is the ledgerPosition term that a case copy already carries (SYNC-16-005), so one fact keeps one wire form.
Uses definition from: SYNC-17-001
SYNC-18-017 MUST NOT A sender MUST NOT put a ledgerPosition on three kinds of activity. They are one sent before it holds the case's ledger, one whose object already states a ledger position, and a Create(ProcessingFault). The objects that state their own position are in Add(CaseLedgerEntry), Announce(VulnerabilityCase), Create(VulnerabilityCase) and Update(VulnerabilityCase).

A stub-Invite reply or a report Offer comes from an actor with no ledger to state. An entry and a case copy state their own positions, and Create(VulnerabilityCase) and Update(VulnerabilityCase) are copies too. A Create(ProcessingFault) is about one activity's processing, not a case: any receiver sends one, even for an activity it could not parse (ASK-07-001), and it names no case (ASK-07-004).
Supersedes: SYNC-18-001
SYNC-18-002 MUST ledgerPosition MUST be the sender's ledger tail for the case at the moment the activity is built.

The position describes the moment of the act, so a receiver learns how far the sender had got when it acted.
Refines: SYNC-18-001
SYNC-18-008 MUST This codebase MUST produce ledgerPosition only in vultron.wire.as2.factories.

One producer stamps every activity the same way, so no other code path can send a position that is not the sender's tail.
Extends: SYNC-18-002
SYNC-18-009 MUST A resent activity MUST carry the ledgerPosition it was first sent with.

A later resend that restamped the position would misstate what the sender knew. The outbox already relays the sealed body (OX-07-001), which keeps the first position.
Extends: SYNC-18-002
SYNC-18-003 MUST A receiver MUST parse ledgerPosition as the core LedgerPosition at the parse edge.

Core code then receives a non-optional position (ADR-0032), and every ledgered act carries one.
Uses definition from: SYNC-18-001
SYNC-18-015 MUST A receiver MUST refuse an activity whose required ledgerPosition (SYNC-18-001) is missing or does not parse, naming the activity and writing nothing.

An act in scope with no position, or one that cannot be read, could not be ledgered with the provenance SYNC-18-001 gives every act.
Extends: SYNC-18-003
Uses definition from: SYNC-18-001
SYNC-18-016 MUST NOT A receiver MUST NOT refuse, for its missing position, a Reject(CaseLedgerEntry) that names an entry and carries no ledgerPosition.

Such a Reject comes from a peer that does not hold the case yet, which the CASE_MANAGER seeds and replays from genesis (SYNC-15-015). A receiver cannot tell from the Reject alone whether its sender holds the case, and the peer that does not is the one the replay from genesis exists to repair.
Supersedes: SYNC-18-015
SYNC-18-004 MUST NOT The CASE_MANAGER MUST NOT refuse, hold or defer an activity because its ledgerPosition is behind the CASE_MANAGER's own ledger tail. A reply to the full-case Invite is the one exception, judged against its Invite's floor (CM-11-012, CM-11-035).

Under asynchronous fan-out an active participant is routinely a few entries behind, and SYNC-10-005 lets it act while it lags. A stale answer to a replaced embargo is already refused, because its consent row accepts no trigger (CM-18-003), so refusing on the position alone would refuse ordinary acts and catch nothing new.
See also: CM-11-035 — context for the reader
SYNC-18-010 MUST The CASE_MANAGER MUST log at DEBUG, with the activity and the actor, each activity whose ledgerPosition is behind its own ledger tail.

A lag is routine, so it is not a warning, but the record shows how far behind a participant acted when an outcome needs explaining.
Extends: SYNC-18-004
SYNC-18-005 MUST A split position is a ledgerPosition naming an index the CASE_MANAGER's ledger holds with a different entry hash, or an index past its tail. The CASE_MANAGER MUST judge an activity with a split position as it would without the position.

The CASE_MANAGER is the single writer, so no participant can hold an entry it did not commit; such a position means the sender's chain has split. Whether the act itself should be refused is open (notes/sync-ledger-replication.md).
SYNC-18-011 MUST The CASE_MANAGER MUST log at ERROR each activity with a split position (SYNC-18-005).

A split chain is a fault that a re-seed may not explain. The ERROR record makes it visible to an operator.
Extends: SYNC-18-005
SYNC-18-012 MUST The CASE_MANAGER MUST send Announce(VulnerabilityCase) of its current case to an active participant (CM-10-004) whose activity has a split position (SYNC-18-005). It sends the copy under the rate bound of SYNC-16-004.

The fresh copy repairs the split with the path SYNC-16-003 already uses for a reported divergence. A Read(<case>/ledger) stating such a position is answered with nothing instead (SYNC-17-005); that difference is open (notes/sync-ledger-replication.md).
Extends: SYNC-18-005
Uses definition from: CM-10-004
Uses definition from: SYNC-16-004
SYNC-18-013 MUST NOT The CASE_MANAGER MUST NOT re-seed a sender that is not an active participant because its activity has a split position (SYNC-18-005).

A copy of the current case is withheld content for a sender that is not active (CM-10-004), so a split position must not become a way to get it.
Uses definition from: SYNC-18-005
SYNC-18-006 MUST The ledgerPosition of an admitted activity MUST stay in its ledger entry as part of the received body (CLP-07-011), never removed.

The entry is the received envelope with a postmark (ADR-0107), so the position is ledgered with the act it describes and replicas receive it unchanged.
Refines: CLP-07-011
SYNC-18-007 MUST This rule covers an activity whose ledgerPosition names an entry in the CASE_MANAGER's ledger, from an active participant of the case (CM-10-004). The CASE_MANAGER MUST answer that position as it answers one stated in Read(<case>/ledger). It records the entry's hash as the sender's acknowledged position (SYNC-17-003). When the position is behind its tail, it sends the later entries as SYNC-17-004 does. Neither the record nor the replay changes the activity's own outcome.

A stamp states the same fact as a Read(<case>/ledger), so one answer serves both (ADR-0155): a participant that sends anything also tells the CASE_MANAGER how far it has got, and one that lost the last entry is repaired by its next act.
Extends: SYNC-17-003
Extends: SYNC-17-004
Uses definition from: CM-10-004
SYNC-18-014 MUST NOT For an activity from a sender that is not an active participant (CM-10-004), the CASE_MANAGER MUST NOT record replication state or answer the ledgerPosition.

A removed, unconsented or closed participant lags on purpose, so answering it would send withheld case content (SYNC-17-002).
Uses definition from: CM-10-004
Arrival-Order Independence and Eventual Consistency

The transport promises no delivery order (ADR-0037), and other implementations may share the wire, so every message a case actor receives can arrive before, between or after the messages it relates to. The protocol's guarantee is eventual consistency: the case ledger's log_index is the causal order (CLP-14-001), and hash-chain apply plus gap repair bring every replica to the CASE_MANAGER's case file. No decision may lean on an arrival order the ledger does not define. Rationale: ADR-0161.

ID Priority Requirement Related
SYNC-19-001 MUST NOT A coordination decision MUST NOT depend on an arrival order that the case ledger does not define. The CASE_MANAGER's observation order is the case's causal order (CLP-14-001). When it takes concurrent assertions from different senders in observed order, its ledger records that order and every replica learns the same outcome. Every other decision is the same whatever order its messages arrive in. That covers what a participant applies, stores or answers, given a message the CASE_MANAGER sent outside the ledger and the ledger entries it relates to. It also covers what the CASE_MANAGER records, given two assertions one sender sent before the first was committed.

Arrival order differs between recipients, between implementations and between runs. A decision that reads it gives different coordination outcomes for the same messages, and the ledger cannot explain the difference. The CASE_MANAGER cannot observe the order one sender sent two messages in, so that order is lost unless the decision does not need it.
Uses definition from: CLP-14-001
SYNC-19-002 MUST Every active participant's replica that receives the CASE_MANAGER's committed ledger entries, in any order, MUST reach the CASE_MANAGER's case file. It gets there through hash-chain apply (SYNC-03-001, SYNC-14) and gap repair (SYNC-00-007, SYNC-00-008, SYNC-16, SYNC-17). This eventual consistency is the ordering guarantee the protocol makes.

Replicas see the case at different times, so a stronger guarantee would need a delivery order the transport does not give.
Derives from: SYNC-08-002
See also: SYNC-00-007 — context for the reader
See also: SYNC-00-008 — context for the reader
See also: SYNC-03-001 — context for the reader
SYNC-19-004 MUST NOT A message the CASE_MANAGER sends outside Add(CaseLedgerEntry) MUST NOT leave a replica in a final state that its related ledger entries do not determine.

A direct message that wrote state the ledger later cannot correct would let two replicas holding the same ledger disagree for good.
Extends: SYNC-19-002
SYNC-19-003 MUST NOT Per-recipient delivery order MUST NOT be a protocol guarantee.

Another implementation may share the wire with no ordered outbox, and even an ordered outbox loses that order when an Add is lost and replayed later, so a rule that holds only under ordered delivery fails in exactly the cases recovery exists for.
SYNC-19-007 MAY An implementation MAY deliver its messages in order per recipient as an optimization (OX-01-005).

Ordered delivery makes reordering rare, so fewer entries are held or replayed. It stays an optimization, because SYNC-19-003 gives no one a right to rely on it.
SYNC-19-005 MUST NOT A receiver MUST NOT rely on a sender delivering its messages in the order it sent them.

Delivery order is no guarantee (SYNC-19-003), so a receiver that relied on it would apply the wrong outcome whenever messages arrive in another order.
Derives from: SYNC-19-003
SYNC-19-006 MUST NOT A sender MUST NOT rely on its own ordered delivery for a receiver's correctness.

Even an ordered outbox loses its order when an Add is lost and replayed later, so a sender whose messages are correct only in its own order fails during recovery.
Derives from: SYNC-19-003
Resending Unanswered Invites

An Invite can be lost before its addressee can answer it. A joiner's relayed Invite(EmbargoEvent) or full-case Invite that arrives before its case copy waits in the pre-bootstrap queue, and is dropped when the queue's window ends (CBT-03-003); any Invite can be lost in delivery. A participant that states its ledger position tells the CASE_MANAGER its replica holds the case, which is the moment a resent Invite can be answered. So the CASE_MANAGER resends each Invite the participant still owes an answer to, as first sent and rate-bounded per Invite and participant. Rationale: ADR-0163.

ID Priority Requirement Related
SYNC-20-001 MUST When a participant on the case's roster that is not removed (CM-31-001) and whose closure is not recorded states a ledger position that names an entry in the CASE_MANAGER's ledger, in Read(<case>/ledger) (SYNC-17-001) or as an activity's ledgerPosition (SYNC-18-001), the CASE_MANAGER MUST resend each Invite that participant owes an answer to (SYNC-20-002), whether or not the participant is active (CM-10-004).

A position statement is the first sign that the replica holds the case, so a resent Invite can now be answered (ADR-0163). The resend is not an answer to the position, so it runs apart from SYNC-17-002 and SYNC-18-007: a joiner that lost its Invite to the embargo in force has not consented, so it is inert, and is the one to ask again. A resent Invite was already sent and is not case content (CM-10-007), so nothing withheld leaks.
Uses definition from: CM-10-004
Uses definition from: CM-31-001
Uses definition from: SYNC-17-001
Uses definition from: SYNC-18-001
Uses definition from: SYNC-20-002
SYNC-20-002 MUST An Invite the CASE_MANAGER sent a participant MUST be treated as owed an answer while that answer can still count, and at no other time: an Invite(EmbargoEvent) whose embargo is still a proposal or is the embargo in force, whose consent row for the participant is INVITED (CM-18-001), and whose RSVP deadline has not passed (CM-28-001); and the full-case Invite (CM-11-010) until the CASE_MANAGER's ledger records the participant's reply to it. Of several Invites for one embargo, only the last one sent is owed, and the Invite that the activity stating the position answers is not owed.

Only an answer that can still change something is worth asking for again; an answered Invite, a decided or withdrawn proposal and a passed deadline cannot. An Invite for the embargo in force is still owed: a reinstated participant (CM-31-040), or a joiner whose proposal was activated first, is asked to sign it. The stating activity may be the answer itself, committed after its position is read, so its Invite is excluded by name.
Uses definition from: CM-11-010
Uses definition from: CM-18-001
Uses definition from: CM-28-001
SYNC-20-003 MUST A resent Invite MUST be the activity as first sent: the same id, ledgerPosition and RSVP deadline (SYNC-18-002), delivered from the body sealed when it was first sent (OX-07-001), never a new Invite built for the resend. So an Invite whose sealed body the CASE_MANAGER does not hold is not resent.

A receiver that already handled the Invite treats a redelivery as a no-op (IE-10-001), and one that dropped it handles it as new. Resending never extends a deadline, so silence before the deadline is still a pocket veto, and the full-case Invite's ledger floor (CM-11-012) is unchanged.
Uses definition from: OX-07-001
Refines: SYNC-18-009
See also: SYNC-18-002 — context for the reader
SYNC-20-004 MUST NOT The CASE_MANAGER MUST NOT resend an Invite to a participant while an earlier send of that Invite is still pending in its outbox; such a skipped resend does not count toward its cooldown (SYNC-20-005).

An Invite still waiting in the outbox has not been lost, so a second copy would only queue behind it. Not counting the skip keeps a later, real resend from waiting out a cooldown no delivery started. This is the replay's rule for a pending Add (SYNC-15-012).
Refines: OX-06-002
Uses definition from: SYNC-20-005
SYNC-20-005 MUST Each consecutive resend of one Invite to one participant MUST double the cooldown before the next resend of that Invite to that participant, from a base value up to a fixed ceiling; a position stated inside the cooldown resends nothing.

A participant that leaves an Invite unanswered on purpose states its position again and again. A doubling cooldown soon makes the resends rare, and the ceiling still resends at a fixed interval until the deadline passes, as the replay bound does (SYNC-15-013).
SYNC-20-007 MUST NOT A resent Invite MUST NOT be committed as a ledger entry, nor change the outcome of the activity that stated the position.

The Invite's emission was ledgered when it was first sent, so a resend changes nothing in the case file and is not a case event (ADR-0152). The activity that stated the position is judged on its own merits, as SYNC-18-007 requires of the rest of the answer to its position.
Refines: SYNC-17-006
SYNC-20-008 MUST NOT The CASE_MANAGER MUST NOT resend an Invite to a sender that is not on the case's roster, that was removed (CM-31-001), or whose closure the case records.

A removed participant was taken out by the Case Owner's decision, and inviting it again would undo that decision (CM-31-013). A closed participant may act on nothing further (CM-23-018), and an actor off the roster was never sent an Invite to answer.
Refines: CM-31-013
Uses definition from: CM-31-001
Sender Sequence on Participant Case Activities

Two activities one participant sends to the CASE_MANAGER can arrive in either order, and their ledgerPosition cannot tell them apart when the first is not yet committed. So each participant numbers its case activities per case, and the CASE_MANAGER judges each sender's activities in that order. An activity past a gap waits in a bounded hold; when the hold ends, the gap is skipped. A number that arrives after its gap was skipped is never applied, and it and a missing number are refused with a notice. This is how the CASE_MANAGER meets SYNC-19-001 for one sender's assertions. Rationale: ADR-0178.

ID Priority Requirement Related
SYNC-21-001 MUST A participant MUST put a senderSequence on each activity it sends the CASE_MANAGER that carries a ledgerPosition (SYNC-18-001), except Read(<case>/ledger) and Reject(CaseLedgerEntry). The CASE_MANAGER puts no senderSequence on the activities it sends.

The CASE_MANAGER cannot see the order in which one sender sent its activities, because the transport keeps no order (SYNC-19-003) and two activities sent before the first is committed state the same position. The number states that order. The two ledger requests are excluded because they ask about the ledger and are not case events (CLP-02-013), and a request for a missed entry must not wait behind the gap it reports. The CASE_MANAGER's own case events are ordered by its ledger (CLP-14-001).
Uses definition from: SYNC-18-001
SYNC-21-002 MUST A participant's senderSequence for a case MUST be one more than the last one it used for that case, and 1 for its first.

A number that goes up by one lets the CASE_MANAGER see a missing activity as a gap and hold what comes after it. Counting per case keeps one case's gaps from delaying another's activities.
Refines: SYNC-21-001
SYNC-21-003 MUST A resent activity MUST carry the senderSequence it was first sent with.

A resend is the same activity, which the CASE_MANAGER finds as a repeat by its id (ID-02-001). A new number on it would move the activity in its sender's order and would use up a number no other activity fills.
SYNC-21-005 MUST The senderSequence of an admitted activity MUST stay in its ledger entry as part of the received body (CLP-07-011), never removed.

A sender that lost its counter finds its own numbers in the ledger it holds (SYNC-21-006). The entry keeps the activity as received, so the number is part of what the hash chain and the sender's signature cover.
Refines: CLP-07-011
SYNC-21-006 SHOULD A participant that lost its count for a case SHOULD resume from the highest senderSequence of its own in that case's ledger.

A sender that lost its state through data loss or a rebuild would otherwise start again at 1, and the CASE_MANAGER would refuse its next activities as late. The ledger it holds keeps its admitted numbers (SYNC-21-005). A refusal notice still recovers a sender that cannot do this (SYNC-21-007).
Uses definition from: SYNC-21-005
SYNC-21-007 MUST A participant that receives a sequence refusal notice (SYNC-21-015) MUST number its next activity for that case no lower than the notice's expectedSenderSequence.

The notice is how a sender whose counter fell behind learns where the CASE_MANAGER is. A sender that kept its old count would have each next activity refused as late. The count is the sender's own sequence state, not case state, so raising it is not a write that CLP-05-008 forbids.
Uses definition from: SYNC-21-015
SYNC-21-008 MUST The CASE_MANAGER MUST judge each sender's numbered activities for a case in senderSequence order.

A participant's later act decides after its earlier one only if the CASE_MANAGER judges them in the order they were sent. Otherwise an Accept and a later Reject of one Invite decide by arrival (#5202), and a note overtaken by its sender's Leave is refused (#5203). Its ledger then records the sender's order, and every replica learns the same outcome.
Refines: SYNC-19-001
Uses definition from: SYNC-21-001
SYNC-21-009 MUST The CASE_MANAGER's next expected number per sender and case MUST be one more than the highest senderSequence it judged or skipped for them. Before it judges any, the number is one more than the highest its case ledger records for them, or 1.

Judging an activity, whether it is admitted or refused on its merits, puts it in the order, and so does skipping its number when a hold ends. The next expected number is what decides whether an arriving activity is judged, held or late. A CASE_MANAGER that took the role from another actor holds the ledger but none of the old one's expected numbers; starting from the ledger keeps a sender already past 1 from being held or refused because the role moved.
SYNC-21-010 MUST The CASE_MANAGER MUST hold an activity whose senderSequence is above its sender's next expected number until the numbers before it arrive or the hold ends.

An activity past a gap was sent after one that has not arrived, so judging it now would put it before an earlier act. It waits as the body that arrived, so its ledger entry is still that body (CLP-07-011).
Uses definition from: SYNC-21-009
SYNC-21-011 MUST The CASE_MANAGER MUST end a hold once its wait has passed, whether or not any further activity arrives.

A lost activity would otherwise stop every later activity of its sender for good. Ending the hold on time bounds that delay, and a sender that sends nothing more still has its held activities judged.
SYNC-21-012 MUST The CASE_MANAGER MUST end a hold when the sender's held activities for the case reach the cap.

The cap bounds the storage one sender can take, including one that sends a forged high number before signing is built. A sender seldom has that many activities in flight to one case.
SYNC-21-013 MUST When a hold ends with numbers still missing, the CASE_MANAGER MUST skip them and judge the held activities in senderSequence order.

Skipping the gap is what keeps a lost activity from deadlocking its sender. The held activities keep their order among themselves, and the next expected number moves past them (SYNC-21-009).
Uses definition from: SYNC-21-009
SYNC-21-014 MUST The CASE_MANAGER MUST refuse, writing nothing, an activity whose senderSequence is below its sender's next expected number or equals that of an activity it holds.

A number below the next expected one arrived after its gap was skipped, or comes from a sender that lost its count. Judging it now would put it after acts its sender made later (SYNC-21-024). One number cannot mean two activities, so the first to arrive keeps its place.
Uses definition from: SYNC-21-009
SYNC-21-015 MUST For each refusal under SYNC-21-014 or SYNC-21-017, the CASE_MANAGER MUST send the sender a refusal notice (CLP-05-001) carrying its next expected number as expectedSenderSequence.

Without a notice the activity would be lost silently, as the note in #5203 was. The expected number tells a sender that lost its count, or never numbered, where to resume (SYNC-21-007). The notice only reports: it changes no case state.
Uses definition from: CLP-05-001
Uses definition from: SYNC-21-014
Uses definition from: SYNC-21-017
SYNC-21-016 MUST NOT The CASE_MANAGER MUST NOT refuse an activity for its senderSequence except under SYNC-21-014 or SYNC-21-017.

The number orders a sender's activities; it is not a reason to doubt them. A gap delays an activity for at most the wait and never refuses it, so a lost activity costs its sender only that one activity.
Uses definition from: SYNC-21-014
Uses definition from: SYNC-21-017
SYNC-21-017 MUST The CASE_MANAGER MUST refuse, writing nothing, an activity SYNC-21-001 requires to be numbered whose senderSequence is missing or not a positive integer.

An unnumbered activity could not be put in its sender's order, so judging it on arrival would leave it open to the arrival-order failures this group removes. A missing ledgerPosition is refused the same way (SYNC-18-015). The project supports only clients built from current main and makes no backwards-compatibility commitment at this time, so no supported sender is refused by this rule (ADR-0178).
Uses definition from: SYNC-21-001
SYNC-21-018 MUST The CASE_MANAGER MUST find a repeat of an activity it has received, held ones included, by its id (ID-02-001) before it compares the senderSequence.

A redelivery of a judged activity would otherwise be refused as late and draw a notice, which a repeat never gets (CLP-05-006). A redelivery of a held activity would otherwise be refused for reusing a held number.
Refines: ID-02-003
Uses definition from: ID-02-001
SYNC-21-019 MAY A participant MAY assert a refused activity's content again (SYNC-21-014) as its own deliberate new act, with a new id and a higher senderSequence.

The refused activity was sent in good time, so its content may still stand. It is a new act of the sender, never an automatic resend on the notice (CLP-05-008): sending a skipped Accept again after a later Reject was judged would reverse the participant's final answer.
Uses definition from: SYNC-21-014
SYNC-21-023 MUST The CASE_MANAGER MUST hold an activity (SYNC-21-010) or refuse it for its number (SYNC-21-014, SYNC-21-017) only after the door and sender guards admit it. One they refuse is refused there with no refusal notice (CLP-02-005), and is neither held nor counted.

A door or sender-guard refusal gets no notice (CLP-05-006), and a sequence check run first would send one to a closed sender, a stranger or a misaddressed copy. Checking the guards first also keeps a stranger from filling a hold, so the hold's storage is bounded by the case's participants. The guards run again when a held activity is judged, so a sender's earlier Leave still closes the door on its later activities.
Uses definition from: CLP-02-005
Refines: SYNC-21-010
Refines: SYNC-21-017
Refines: SYNC-21-014
SYNC-21-024 MUST NOT An activity refused under SYNC-21-014 MUST NOT change case state or enter the case ledger's history, whether it arrives late, replayed or redelivered.

Its sender's later activity, already judged, has countermanded it. If an Accept numbered 2 is lost and the Reject numbered 3 is applied after the skip, the Accept that then arrives decides nothing. The ledger is append-only and is never reordered or rewritten to pick up a missed transient state. The refusal notice (SYNC-21-015) only reports; a deliberate re-assertion is a new activity with a higher number (SYNC-21-019).
Refines: SYNC-21-014
SYNC-21-025 MUST Before its role passes to another actor (CM-02-016), the CASE_MANAGER MUST judge every activity it holds for the case, skipping gaps as an ended hold does (SYNC-21-013).

The new CASE_MANAGER holds none of the old one's held activities, so any left held would be neither judged nor refused, and their senders never told. Draining first loses nothing and needs no notice: the handover only ends the waits early, and the drain keeps each sender's order. The new CASE_MANAGER then starts each sender from its ledger (SYNC-21-009).
Constrains: CM-02-016
Uses definition from: SYNC-21-013

Participant Case Replica

Requirements for how each Vultron Actor maintains and manages its local copy (replica) of a VulnerabilityCase. Covers replica identity, bootstrap, update authority, case-context message routing, reporter case discovery, and unknown-context handling.

Replica Identity (No Stub CASE_MANAGER)
ID Priority Requirement Related
PCR-01-001 MUST Each Vultron Actor MUST maintain its local case replica as an internal concern — there is exactly one externally-addressable Actor identity per participant, regardless of how many cases that Actor is involved in.

Other actors address an Actor, and decide whether to trust it, by its one id. A separate identity for each case would need its own discovery and its own trust anchor for every case, and a message sent to the Actor's main id would not reach the case. Keeping each replica inside the Actor gives every case the same inbox and the same identity.
Derives from: CM-01-001
PCR-01-002 MUST There is exactly one CASE_MANAGER per case, acting on the Case Owner's behalf.

The CASE_MANAGER is the single writer of the case ledger. Two CASE_MANAGERs could each commit a different entry at the same index, and the replicas would then disagree with no rule to pick one. A participant also needs exactly one sender whose case updates it accepts (PCR-03-001).
Refines: CM-02-001
PCR-01-003 MUST The protocol MUST work the same whether every Actor runs on one host or on many. Actor co-location is an implementation choice.

Co-location is a deployment choice. Code that reads another Actor's store, or waits for a side channel, works only while two Actors share a host. Per-actor stores (ADR-0073) prevent direct reads and writes, but not code that expects the case to be visible early.
PCR-01-004 MUST Actors MUST exchange information only through protocol messages.

A protocol message is the one channel every deployment shares. Information that passes any other way works only while two Actors share a host, so the protocol would then depend on where the Actors run (PCR-01-003).
Implements: PCR-01-003
PCR-01-005 MUST NOT An Actor MUST NOT read, write, or otherwise reach into another Actor's store.

Each Actor has its own store (ADR-0073). A read or write of another Actor's store works only on a shared host, and it changes that Actor's state without a message that Actor can check.
Derives from: PCR-01-003
PCR-01-006 MUST NOT An Actor MUST NOT rely on out-of-band communication with a co-located Actor.

A side channel between two Actors on one host is not there when they run apart. Code that waits for one then fails, or works only by chance, in a distributed deployment.
Derives from: PCR-01-003
PCR-01-007 MUST An Actor that asked a CASE_MANAGER to create a case MUST treat the case as absent until the CASE_MANAGER's Create(VulnerabilityCase) reaches it. It never assumes that co-location makes the case visible sooner.

The report receiver does not create the case (ADR-0041), so it holds the case only after the CASE_MANAGER's Create(VulnerabilityCase) arrives. A tree that acts on the case sooner has nothing to act on, even when the CASE_MANAGER shares its host.
Refines: PCR-01-003
Replica Bootstrap
ID Priority Requirement Related
PCR-02-001 MUST After a case is created, the CASE_MANAGER MUST deliver each full case copy to a participant in an Announce(VulnerabilityCase).

A participant that gets every later full case copy in one activity type applies each copy through one path, with one sender check (PCR-03-001) and one ledger-position check (SYNC-16-006). The creation copy is the one exception: it travels in the bootstrap Create(VulnerabilityCase) (PCR-02-005, CBT-01-002).
PCR-02-002 MUST When a participant becomes active (CM-10-004) by accepting the stub Invite (CM-11-008), the CASE_MANAGER MUST send it Announce(VulnerabilityCase) with its first case copy.

A participant cannot act on a case it does not hold, and only the CASE_MANAGER holds the canonical copy. Sending the copy when the participant becomes active gives it the case at the moment it is entitled to it. A participant seated at case creation already has the copy from the bootstrap Create(VulnerabilityCase) (PCR-02-005).
Uses definition from: CM-10-004
Part of: CM-11-008
PCR-02-006 MUST NOT The CASE_MANAGER MUST NOT send Announce(VulnerabilityCase) to an inert participant (CM-10-004).

An inert participant is not entitled to case content (CM-10-004), and a full case copy is case content. Sending it one would leak the case to an actor that has not joined or has not agreed to the embargo in force.
Refines: CM-10-004
PCR-02-003 MUST When a participant actor receives Announce(VulnerabilityCase) and has no existing local copy for that case ID, it MUST create a local replica from the received case object.

The first case copy a participant receives is its only source for the case. If the participant did not store it, every later ledger entry for the case would name a case the participant does not hold.
PCR-02-004 MUST When a participant actor receives Announce(VulnerabilityCase) and already has a local replica for that case ID, it MUST apply the received case state as an authoritative update, subject to PCR-03-001 and to the ledger-tail comparison of SYNC-16-006.

An update is safe only when the copy names the ledger position it reflects, because an old copy can arrive late over an unordered transport (ADR-0142).
Uses definition from: SYNC-16-006
PCR-02-005 MUST A participant that receives the bootstrap Create(VulnerabilityCase) from a trusted sender MUST seed its case replica from the creation copy that the Create carries (CBT-01-002).

The case's first copy travels inline in the bootstrap Create(VulnerabilityCase) (CBT-01-002, ADR-0157), so no separate Announce(VulnerabilityCase) follows it. A receiver that did not seed its replica from the Create would hold no case until some later copy arrived.
Uses definition from: CBT-01-002
Uses definition from: CBT-01-001
Replica Update Authority
ID Priority Requirement Related
PCR-03-001 MUST A participant actor's local case replica MUST only accept case-state updates that originate from the CASE_MANAGER for that case.

The CASE_MANAGER is the single writer of the case. A replica that accepted a case-state update from any other sender would let that sender change the participant's view of the case without the CASE_MANAGER's checks and without a ledger entry, and the replicas would then disagree.
Refines: CM-06-002
Constrains: PCR-02-004
PCR-03-002 MUST NOT The Case Owner actor MUST NOT write directly to its own local case copy.

When the Case Owner is not the CASE_MANAGER, its copy of the case is a replica like every other, and it changes only after the CASE_MANAGER has checked the change and recorded it in the ledger. A direct write skips both steps, so the other replicas never learn of the change and the owner's copy then disagrees with the canonical case.
Refines: PCR-03-005
PCR-03-003 MUST A participant actor MUST authenticate Announce(VulnerabilityCase) activities before accepting them as authoritative updates to its local replica.

The sender check of PCR-03-001 compares the activity's actor id, and a sender writes that id itself. Without authentication, any sender can write the CASE_MANAGER's id there and have its copy applied. Actor signatures are not yet available, so this rule applies to production only.
PCR-03-004 MUST NOT A participant actor MUST NOT create a local case replica from an Announce(VulnerabilityCase) unless it already trusts a CASE_MANAGER for that case. It gains that trust by one of two paths. In path (a), it has processed a Create(VulnerabilityCase) from the report receiver that introduced the CASE_MANAGER. In path (b), it has completed an InviteActorToCase exchange, the Invite and its Accept, that recorded a pending expectation for the case.

The sender writes the roster of an Announce(VulnerabilityCase), so a fake case naming its sender as CASE_MANAGER passes a roster-only check. A first-contact Announce with no local record would let an attacker seed a fake replica and block the real CASE_MANAGER (PCR-03-001). No real sequence sends one without a prior Create(VulnerabilityCase) or InviteActorToCase. Without signatures (#2841), the receiver cannot check that the named CASE_MANAGER is genuine.
Refines: PCR-03-001
Supersedes: PCR-02-003
PCR-03-005 MUST The Case Owner MUST follow the same replica rules as all other participants.

Exempting the Case Owner from replica rules would create an inconsistent update path that bypasses the CASE_MANAGER consistency checks.
PCR-03-006 MUST The Case Owner MUST route all case-state changes through the CASE_MANAGER.

Routing through the CASE_MANAGER ensures all case-state mutations go through the single-writer authority and are recorded in the case ledger.
Extends: PCR-03-002
PCR-03-007 MUST For path (b) of PCR-03-004, a participant MUST create the pending-expectation record only when the Invite's object is that participant.

An Invite addressed to another actor says nothing about this participant. If it anchored trust here, a misaddressed Invite could make this participant trust a CASE_MANAGER on another actor's behalf.
Extends: PCR-03-004
PCR-03-008 MUST The pending-expectation record of PCR-03-004 path (b) MUST bind to the Invite's actor id, the named CASE_MANAGER, not to the sender that delivered the Invite.

The transport-level sender can be a relay, so its id need not name the CASE_MANAGER. The Invite's actor is the CASE_MANAGER that the participant later accepts case copies from (PCR-03-001).
Extends: PCR-03-004
PCR-03-009 MUST A later Invite for the same case that names a different CASE_MANAGER MUST replace a participant's path (b) anchor (PCR-03-004). This applies while the participant has not accepted the Invite that set the anchor.

Until the receiver accepts, a later Invite replaces the anchor, so a forged stub Invite cannot lock out the real CASE_MANAGER's Invite until the bootstrap.
Extends: PCR-03-004
PCR-03-010 MUST A participant MUST refuse a later Invite for the same case that names a different CASE_MANAGER, and keep its anchor unchanged. This applies once it has accepted the Invite that set its path (b) anchor (PCR-03-004).

An accepted anchor is the trust the participant chose. A second Invite that could replace it would let any sender take the case over after the join. A forged Invite the receiver accepts first still wins, a residual risk accepted until signatures (#2841).
Extends: PCR-03-004
Case Context Routing
ID Priority Requirement Related
PCR-04-001 MUST The context field of an ActivityStreams activity is the canonical mechanism by which a participant actor identifies the local case replica a case-scoped message belongs to.

An Actor holds replicas of many cases behind one inbox (PCR-01-001), so each case-scoped activity must say which case it is about. One standard field for that lets every receiver find the replica the same way.
PCR-04-002 MUST All case-scoped protocol activities sent by the CASE_MANAGER to participants MUST carry context set to the case ID.

A participant finds the replica an activity belongs to from its context (PCR-04-001). An activity from the CASE_MANAGER with no case context also skips the hold for unknown cases (PCR-06-002), so the participant can process it before it holds the case.
PCR-04-003 MUST A participant actor MUST be the only externally-addressable entity that receives case-scoped messages for the cases it takes part in. It has no separate per-case inbox.

Other actors reach a participant at its one Actor identity (PCR-01-001). A separate inbox for each case would be a second address that senders must discover and trust for every case, and a message sent to the wrong address would not reach the replica.
Reporter Case Discovery
ID Priority Requirement Related
PCR-05-001 MUST Each actor MUST keep, for each report it has submitted, a link from the report's id to the id of the case created for it.

A reporter learns about the case for its report only from the activities it receives later. The link from the report to the case lets it find the case for the report it submitted, and it lets the reporter check that a case it receives is the case for that report (CBT-01-005).
PCR-05-002 MUST When a participant actor receives Announce(VulnerabilityCase) and the case references a report whose report-to-case link is not yet bound to a case, the actor MUST bind that link to the local case replica.

The report-to-case link is how a reporter finds the case for its report (PCR-05-001). If a received case copy did not update the link, the reporter would hold the case but could not find it from the report. A bound link also records the CASE_MANAGER trusted for its case (CBT-01-006), so a link already bound to a case is left on it. Moving it to a second case holding the same report would take that trust from the first case and give the second case a CASE_MANAGER it never had, which CBT-02-003 forbids.
Unknown Case Context Handling
ID Priority Requirement Related
PCR-06-001 MUST NOT When a participant actor receives an activity whose context field does not match any known local case replica, the actor MUST NOT silently discard the activity.

Activities can arrive before the case they name, because the transport does not keep order (ADR-0161). The receiver has already taken delivery, so the sender has no reason to send the activity again, and a discarded activity is lost. Keeping it, or reporting the drop, keeps the participant from losing a case change without a record.
PCR-06-002 SHOULD When an activity with an unknown case context arrives, the actor SHOULD queue the activity briefly.

An activity for an unknown case usually arrives before the case copy that would let the participant apply it. Holding it for a short time gives that copy time to arrive. The participant does not ask for the copy: the CASE_MANAGER sends it when the participant joins (CM-11-008), and resends an Invite the participant dropped once the participant states its ledger position (SYNC-17-008, ADR-0163).
PCR-06-003 MUST NOT Activities with unknown case context MUST NOT update any local state until a valid case replica has been established.

Until a replica exists, the participant has nothing to check an activity against: not the case, not its CASE_MANAGER, not its roster. A write made then could seed case state from an untrusted sender, which PCR-03-004 forbids for the case itself.
PCR-06-005 MUST A participant MUST process a stub Invite (CM-11-013) on arrival, not queue it under PCR-06-002. This holds though it has no replica of the case the Invite names. Every other activity that names a case the participant does not hold is still queued.

An invitee decides whether to join a case before the case is delivered to it (MV-10-005), and the case arrives only after it accepts. An Invite held until the case arrives would wait for the Announce that only its own Accept can bring, so the invitee could never answer it, except from a copy stored under the sender's id, which DL-06-006 forbids.
Supersedes: PCR-06-002
Supersedes: PCR-06-003
Uses definition from: CM-11-013
PCR-06-006 MUST A participant that processes a stub Invite for a case it does not hold MUST write only two records. They are the Invite's intake archive (CLP-10-036) and its PCR-03-004 path (b) trust anchor.

The Invite precedes its case by design (PCR-06-005). Writing only its intake archive and its trust anchor means it sets no case state before the replica exists (PCR-06-003).
Extends: PCR-06-005
Uses definition from: CLP-10-036
Uses definition from: PCR-03-004
Outbound Participant Message Routing
ID Priority Requirement Related
PCR-08-001 MUST After a case is created and its CASE_MANAGER introduced, a participant MUST address each case-scoped message to that CASE_MANAGER alone, never directly to another participant. Case-scoped messages include notes, status updates, embargo proposals, RM transitions and any other protocol message about the case. The one exception is RK, Read(Offer(VulnerabilityReport)). RK answers the reporter's original Offer outside the case. So an addressee of that Offer sends RK to the reporter, never to the CASE_MANAGER (RMB-08-003, RMB-08-005).

A participant sends each case-scoped message to the CASE_MANAGER, so that the CASE_MANAGER can check the sender, record the change in the case ledger and send it on to the other participants (PCR-08-003). A message sent straight to a peer gets none of these steps, so the peer's replica and the canonical case disagree. RK is not a case message: it answers the reporter's Offer, which the reporter sent to that receiver before the case existed, so the answer goes back to the reporter (RMB-08-003).
See also: RMB-08-005 — context for the reader
PCR-08-002 MUST NOT A participant actor MUST NOT assume that other participants will receive its case-scoped messages through any channel other than the CASE_MANAGER's Add(CaseLedgerEntry) broadcast. Sending to the whole roster or any multi-recipient list that includes non-CASE_MANAGER actors is a violation of this rule.

Only the CASE_MANAGER's Add(CaseLedgerEntry) tells a participant what the case ledger holds. A participant that sends its message to other participants as well gives them a change that the CASE_MANAGER has not yet checked or recorded, and they may act on a change that the CASE_MANAGER later refuses.
PCR-08-003 MUST The CASE_MANAGER MUST, for every participant message it receives and accepts, commit a CaseLedgerEntry recording the outcome and broadcast Add(CaseLedgerEntry) to the case's active participants (CM-10-004) as the standard cascade. This cascade is the only mechanism by which participants learn of accepted case-state changes.

Participants learn of case changes only from the ledger. If the CASE_MANAGER applied a change without an entry, or recorded an entry without sending it, the other replicas would never learn of the change and would disagree with the canonical case.
Uses definition from: CM-10-004
PCR-08-013 MUST The CaseLedgerEntry commit and Add(CaseLedgerEntry) broadcast (PCR-08-003) MUST follow automatically from the CASE_MANAGER processing any accepted participant message, without any further request or operator action.

If the commit and the broadcast needed a separate request, a CASE_MANAGER that did not get the request would apply a change that no replica learns about. Making them part of processing the message means every processed change reaches the ledger and the participants.
Extends: PCR-08-003
PCR-08-005 MUST A participant MUST take the sole to: recipient of a case-scoped message from its case replica. That recipient is the participant holding the CASE_MANAGER role, never the case's full participant list.

The case's full participant list includes actors that are not entitled to every message (CM-10-004), and it reaches peers that the CASE_MANAGER has not yet checked the message for. Taking the CASE_MANAGER from the participant's own replica gives one recipient that the participant already trusts.
PCR-08-007 MUST The CASE_MANAGER MUST send each InviteActorToCase with actor set to its own ID, never the Case Owner's. This holds even when the Case Owner triggered the Invite.

A receiver records the Invite's actor as its trust anchor (PCR-03-008), and it later accepts the case copy only from that actor. If the Case Owner were the actor, the invitee would anchor its trust on the wrong actor and answer the wrong actor.
PCR-08-019 MAY An InviteActorToCase MAY carry the Case Owner's ID in attributedTo to record who asked for the Invite.

The CASE_MANAGER is the Invite's actor (PCR-08-007), so the actor field no longer shows that the Case Owner asked for it. attributedTo keeps that record without changing whom the invitee trusts.
PCR-08-008 MUST The invitee's Accept of that Invite (PCR-08-007) MUST be addressed to the CASE_MANAGER (not the Case Owner). The CASE_MANAGER is the authoritative recipient and processor of all case-management handshake messages after case creation.

Only the CASE_MANAGER records the invitee's join in the case and in the ledger. When the Case Owner is not the CASE_MANAGER, an Accept addressed to the Case Owner reaches an actor that cannot record the join, so the join is never recorded.
Refines: PCR-08-001
Uses definition from: PCR-08-007
PCR-08-009 MUST The CASE_MANAGER MUST process an invitee's replies and record their effect on its own copy of the case: a reply to the stub Invite as CM-11-001 and CM-11-007 require, and a reply to the full-case Invite as CM-11-011 requires.

The invitee's replies are the only source of its join and its judgment of the case. If the CASE_MANAGER did not record them, the case would show the invitee as not joined, and the invitee would get no case content.
Uses definition from: CM-11-001
Uses definition from: CM-11-007
Uses definition from: CM-11-011
PCR-08-014 MUST NOT The Case Owner MUST NOT author or emit any RM state-change activity on behalf of the invitee.

RM state belongs to each participant, and it is the participant's own judgment (ADR-0121). Outside the bootstrap record of CBT-01-008, only that participant declares it. An RM change that the Case Owner emits for the invitee records a decision the invitee never made, and the case then shows the invitee engaged when it is not.
Refines: PCR-08-010
PCR-08-010 MUST Every activity that an actor constructs or emits while processing a received activity MUST name that actor's own ID as its actor.

Receivers trust the actor field to name the actor that made the decision, and the sender checks depend on that. An activity that names another actor forges that actor's decision, and every receiver applies it as if that actor had sent it.
PCR-08-012 MUST NOT The CASE_MANAGER MUST NOT record any RM transition from an invitee's Accept(Invite(VulnerabilityCase preview)[target=Actor]) (CM-11-001). That Accept is a join and embargo-consent decision, not an RM engagement decision.

PCR-08-014 prohibits the Case Owner from emitting RM state-change activities on behalf of the invitee. The invitee's own messages are the authoritative signals, and each carries only the decision it names: accepting the stub joins the case, the full-case Invite reply judges it (CM-11-011), and Join engages.
Refines: CM-11-001
PCR-08-020 MUST The CASE_MANAGER MUST record an invitee as RM.ACCEPTED only when it receives Join(VulnerabilityCase) from that invitee (CM-11-004).

Join is the invitee's own engagement decision. Recording RM.ACCEPTED on any other message would record a decision the invitee did not make (PCR-08-012).
Refines: CM-11-004

Case Bootstrap Trust

Requirements for establishing trust in a VulnerabilityCase and its CASE_MANAGER at non-owner sites. Governs the bootstrap process by which a non-owner participant verifies that an incoming case and its managing actor are legitimate before accepting case state updates.

Original Report-Submission Bootstrap
ID Priority Requirement Related
CBT-01-001 MUST When a case is created in response to an inbound Offer(VulnerabilityReport), the actor that received the report (the report receiver) MUST establish trust at the original report submitter by sending it, as itself, a one-time Create(VulnerabilityCase) activity. When the CASE_MANAGER is a different actor from the report receiver, that activity introduces the CASE_MANAGER the receiver delegated case maintenance to (ADR-0132).

The reporter must learn that its report became a case, and which actor coordinates the case. The submitter chose the report receiver and wrote a record of that choice before the case existed. A case that arrives first from an actor the submitter never addressed gives it nothing to check the sender against, and a roster the sender wrote is not an anchor. The receiver already knows the CASE_MANAGER, so it vouches for it.
CBT-01-002 MUST The bootstrap Create(VulnerabilityCase) activity MUST carry the complete VulnerabilityCase inline, rather than a reference, a minimal stub or a partial trust-only payload.

The receiver seeds its Participant Case Replica from this activity. A stub or a partial case leaves it nothing complete to seed from. A reference leaves it nothing to read: it has no trusted source to fetch the case from, because it trusts the CASE_MANAGER only after it accepts this activity (ADR-0170).
Refines: AKM-03-001
CBT-01-003 MUST The bootstrap case snapshot MUST distinguish the actor that asked for the case from the actor that created it (CBT-01-013, CBT-01-014).

The CASE_MANAGER creates the case (ADR-0041) and the report receiver asks for it, so the two roles can belong to two actors. CASE_OWNER is the standing of the party whose disclosure decisions the case serves, and it is never delegated. CASE_MANAGER is the right to write the canonical case ledger, held by the actor whose store holds the canonical case (ADR-0073). If the snapshot merged the roles, the ledger writer could also make the Case Owner's decisions.
CBT-01-013 MUST The bootstrap case snapshot MUST record the actor whose CaseProposal caused the case to exist as a participant with the CASE_OWNER role. That actor is the report receiver, whatever other roles it also holds.

CASE_OWNER is the standing of the party whose disclosure decisions the case serves. The report receiver asked for the case, so the snapshot names it as the Case Owner for every replica seeded from it.
Part of: CBT-01-003
CBT-01-014 MUST The bootstrap case snapshot MUST record the actor that created the case as a participant with the CASE_MANAGER role.

CASE_MANAGER is the right to write the canonical case ledger, held by the actor whose store holds the canonical case (ADR-0073). Every participant finds the CASE_MANAGER in the snapshot's participant records.
Part of: CBT-01-003
CBT-01-015 SHOULD In the bootstrap case snapshot, the participant that holds CASE_MANAGER SHOULD also carry the COORDINATOR role.

The actor that manages the case also coordinates it. Carrying the role lets checks that look for a coordinator find the CASE_MANAGER.
Extends: CBT-01-014
CBT-01-016 MUST NOT The CASE_OWNER role MUST NOT pass to the CASE_MANAGER by delegation.

CASE_OWNER is never delegated. If the snapshot merged the two roles by delegation, the ledger writer could also make the Case Owner's decisions.
Extends: CBT-01-003
CBT-01-004 MUST When the original report submitter is intended to receive ongoing case updates immediately, the bootstrap case snapshot MUST include that actor as a participant from the start.

The CASE_MANAGER shares case content only with active participants (CM-10-004). A submitter that is not on the starting roster gets no updates until it is invited, although it is the party that brought the report. On the roster from the start, it can follow the case from its first entry.
CBT-01-005 MUST NOT A report submitter MUST NOT trust a newly introduced CASE_MANAGER unless its bootstrap Create(VulnerabilityCase) comes from the report's receiver and references the submitted report.

The report receiver is an actor the submitter chose when it sent the report. The record the submitter wrote when it sent the report ties the report to that actor, so the sender cannot forge it (PCR-05-001). The sender writes the roster in the snapshot, so any actor can name itself CASE_MANAGER there. The report reference also stops an actor from attaching an unrelated case to the submitter.
CBT-01-017 MUST The report submitter MUST check the bootstrap of CBT-01-005 against a record it wrote itself before the case arrived, never against the snapshot's roster.

The sender writes the roster in the snapshot, so any actor can name itself CASE_MANAGER there. The record the submitter wrote when it sent the report ties the report to the actor it chose, so the sender cannot forge it (PCR-05-001).
Implements: CBT-01-005
CBT-01-006 MUST After validating the bootstrap Create(VulnerabilityCase), the receiving actor MUST persist the report-to-case link, the report receiver's identity (the actor that introduced the case), and the trusted CASE_MANAGER identity for that relationship.

The receiver checks later CASE_MANAGER traffic, such as Announce(VulnerabilityCase), against this record (CBT-02-001, CBT-02-003). Without it, the receiver could judge each later message only by what the message claims about itself. The report-to-case link also lets the submitter find the case for its report.
Refines: PCR-05-001
CBT-01-007 MUST The bootstrap Create(VulnerabilityCase) payload MUST carry each CaseParticipant record the case lists inline.

The receiver seeds its replica from this payload, and later guards read the participant records it seeds, such as the participant checks on a sender. A record the payload leaves out is one the replica lacks when a guard needs it. A record named only by reference is left out too: the receiver does not fetch it (AKM-05-007), because before it accepts this activity it has no trusted source to fetch it from (ADR-0170).
Refines: CBT-01-002
CBT-01-008 MUST The bootstrap case snapshot MUST include the original report submitter's participant record with an RM state of RM.ACCEPTED.

A report submitter can only be in RM.ACCEPTED at the time of submission: reporting is the act of accepting that the vulnerability warrants coordinated disclosure. A submitter who considered the item invalid would not have filed a report, and one who had deferred or closed their involvement would not be reporting at all. Because the CASE_MANAGER cannot observe the reporter's internal state progression, inserting intermediate RM records on the reporter's behalf would place unobserved events into the canonical case ledger. The CASE_MANAGER MUST instead reflect the only state the reporter could actually be in: RM.ACCEPTED.
Refines: CBT-01-004
CBT-01-018 MUST The CASE_MANAGER MUST set the reporter's RM.ACCEPTED directly, never inserting intermediate transitions (RM.START, RM.RECEIVED, RM.VALID) it never observed for the reporter.

The CASE_MANAGER cannot observe the reporter's internal state progression. Intermediate RM records written on the reporter's behalf would place unobserved events into the canonical case ledger.
Extends: CBT-01-008
CBT-01-009 MUST The CASE_MANAGER MUST generate its Create(VulnerabilityCase) only after the VulnerabilityCase is fully initialized, so the activity records a completed initialization, not an intent. Fully initialized means every participant is at its correct initial RM state and every role is assigned.

ActivityStreams 2.0 activities represent completed events, not intentions. A Create(VulnerabilityCase) sent before the case is fully initialized would misrepresent the state that existed at creation time. Receivers replay the bootstrap snapshot as authoritative ledger content; if that snapshot is incomplete, every replica is permanently wrong. Sequencing the activity after initialization is the structural guarantee that the bootstrap snapshot is always accurate.
CBT-01-019 MUST The report receiver's introduction to the submitter (CBT-01-001) MUST relay the completed snapshot of CBT-01-009.

The submitter seeds its replica from the introduction. A relay that carried a different or earlier snapshot would seed the submitter's replica with a state the CASE_MANAGER never recorded.
Uses definition from: CBT-01-009
Extends: CBT-01-001
CBT-01-010 MUST When the actor enacting CASE_MANAGER is not the report receiver, the CASE_MANAGER MUST NOT address its Create(VulnerabilityCase) to the original report submitter. That activity goes to the report receiver (the Case Owner), which relays the introduction (CBT-01-001). The CASE_MANAGER's first message to the submitter is an Announce. A submitter that receives it before the introduction holds it under CBT-03-001 and CBT-03-002.

The submitter never addressed the CASE_MANAGER, so a Create from it cannot be checked against anything the submitter wrote (CBT-01-005). Introducing the CASE_MANAGER through the actor the submitter chose keeps one trust anchor for the submitter and removes the route that trusted a sender because its own snapshot named it (ADR-0132).
Uses definition from: CBT-01-001
Derives from: CBT-01-005
See also: CBT-03-001 — context for the reader
See also: CBT-03-002 — context for the reader
CBT-01-011 MUST A participant MUST refuse a bootstrap Create(VulnerabilityCase) from a sender no trust anchor it wrote names as the expected sender, and store nothing from it. A snapshot naming that sender as CASE_MANAGER does not change this (CBT-01-017).

The sender wrote the snapshot, so a roster in it proves nothing about the sender's authority (ADR-0132; notes/participant-case-replica.md).
Refines: CBT-01-005
See also: CBT-01-017 — context for the reader
Post-Bootstrap Update Authority
ID Priority Requirement Related
CBT-02-001 MUST For the original report-submission path, Create(VulnerabilityCase) is a one-time bootstrap message only; subsequent full-case synchronization MUST use Announce(VulnerabilityCase) from the trusted CASE_MANAGER.

Two activity types let a receiver tell a first introduction from a later sync. It checks the Create against the record it wrote when it sent the report (CBT-01-005). It checks each Announce against the CASE_MANAGER that the accepted Create named (CBT-01-006).
Refines: PCR-02-001
CBT-02-002 MUST NOT Transport authentication or encrypted direct messaging alone MUST NOT be treated as establishing authority to trust a previously unknown CASE_MANAGER; the explicit bootstrap trust handoff is required.

Transport authentication shows which actor sent a message. It does not show that the actor may manage the case. Only a Trust Anchor the receiver wrote, from a relationship it had before the case arrived, ties the case to a CASE_MANAGER (CBT-01-005, CBT-04-001).
CBT-02-003 MUST A participant that trusts a CASE_MANAGER for a case MUST replace that identity only through an explicit transfer workflow, never through ordinary case-update traffic.

If ordinary case traffic could replace the trusted CASE_MANAGER, a case snapshot that names a different manager would move trust with no decision by the Case Owner. The receiver would then accept updates from an actor it never checked. An explicit workflow makes the change one step that participants can see.
Out-of-Order Handling
ID Priority Requirement Related
CBT-03-001 SHOULD If a CASE_MANAGER-originated case message arrives before the required bootstrap trust handoff, the receiving actor SHOULD queue it only for a short bounded interval rather than accepting or permanently trusting it immediately.

The transport does not promise delivery order (SYNC-19-003), so a message from the real CASE_MANAGER can arrive before the bootstrap that makes it trusted. If the receiver drops the message at once, the message is lost. If the receiver applies it at once, it trusts a sender it has not checked. A short hold keeps the message until the bootstrap arrives, and the limit stops untrusted messages from staying in storage with no end.
Refines: PCR-06-002
CBT-03-002 MUST NOT A pre-bootstrap CASE_MANAGER message MUST NOT update local case state before the corresponding trust-establishing bootstrap message has been validated.

Before the bootstrap is validated, the receiver cannot know that the sender is the CASE_MANAGER. A state change from that message can come from any actor, and the receiver would then hold case state that no trusted source sent.
Refines: PCR-06-003
CBT-03-003 MUST When the bounded pre-bootstrap queue interval (CBT-03-001) expires, the receiver MUST drop the queued message.

A message the receiver cannot yet trust must not wait without limit for a case copy that may never arrive. Dropping it when the interval ends limits what the receiver stores. ADR-0163 gives the recovery of a dropped Invite to the CASE_MANAGER, which knows which Invites each participant has not answered.
Extends: CBT-03-001
Late-Joiner Bootstrap
ID Priority Requirement Related
CBT-04-001 MUST For a participant added after case creation, the trust-establishing message MUST be InviteActorToCase from the CASE_MANAGER rather than Create(VulnerabilityCase).

A late joiner submitted no report, so it holds no record that ties a case to an actor it chose. The stub Invite gives it one: the joiner chooses to accept it, and the accepted Invite is its Trust Anchor for the case (PCR-03-004). A Create(VulnerabilityCase) from an actor the joiner never dealt with gives it nothing to check the sender against.
CBT-04-002 MUST The trust-establishing invite for a late joiner MUST identify both the case and the CASE_MANAGER that will send subsequent Announce(VulnerabilityCase) updates.

The joiner checks each later Announce(VulnerabilityCase) against the Trust Anchor the Invite left. If the Invite does not name both the case and the CASE_MANAGER, the joiner cannot tell which sender to trust for which case.
CBT-04-003 MUST NOT The CASE_MANAGER MUST NOT send a late joiner a Create(VulnerabilityCase). After the joiner accepts the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])), the CASE_MANAGER seeds the joiner's replica with Announce(VulnerabilityCase).

A late joiner is told what the case already is, which is an Announce. It did not witness the case's initialization, which is what a Create reports. The accepted stub Invite already gives the joiner its Trust Anchor (CBT-04-001), so a Create would also add a second trust step with nothing new to check.
Verification
ID Priority Requirement Related
CBT-05-008 MUST This rule covers a receiver that finds required participant data absent from a bootstrap Create(VulnerabilityCase) (CBT-01-007). It MUST reject the bootstrap as a protocol error, never skipping the participant, inferring its state, or synthesizing a record from data the payload lacks.

Silent reconstruction of missing protocol data masks protocol bugs: a fallback that fills in missing data "from domain knowledge" makes the protocol look as if it works when it does not, so the failure must be visible to be diagnosed and fixed. Replicas are built only from ledger content; data not in the ledger did not happen. A participant the payload names only by reference is absent too: CBT-01-007 requires it inline, and the receiver does not fetch it (AKM-05-007).
Derives from: CBT-01-007
One Report Offered to Several Recipients
ID Priority Requirement Related
CBT-06-001 MUST Each Offer(VulnerabilityReport) a reporter sends MUST address exactly one recipient.

A reporter that gets no answer from its first recipient routinely offers the same report to a Coordinator, and either recipient may then accept and create its own case. The protocol permits this on purpose. The two attempts, and the cases that follow from them, are only distinguishable if each Offer names one recipient and has its own id.
CBT-06-003 MUST Each Offer(VulnerabilityReport) a reporter sends MUST carry an activity id distinct from every other Offer of the same report.

With one recipient per Offer (CBT-06-001) and an id of its own, each submission attempt is identified by at least the pair (report, recipient). The cases that follow from two attempts can then be told apart.
Extends: CBT-06-001
CBT-06-002 MUST This rule covers a reporter that has offered one report to several recipients. It MUST accept a valid bootstrap Create(VulnerabilityCase) from each, checking each against its sender (CBT-01-005) and recording its case and CASE_MANAGER for that recipient alone.

A reporter often offers an unanswered report again to a Coordinator, and either recipient may then start a case. A reporter that trusts only one sender per report refuses the bootstrap from the second recipient and cannot join that case. How the reporter stores trust for each recipient is an implementation choice. This requirement controls only which bootstraps it accepts.
Refines: CBT-01-006
Uses definition from: CBT-01-005
CBT-06-004 MUST NOT Not yet in the reference implementation (tracked by #3698)

This rule covers a reporter that has offered one report to several recipients. It MUST NOT let a further offer, or its acceptance of one bootstrap, change how it treats another recipient's bootstrap. That covers whether it accepts the bootstrap and which case it records for that recipient.

Each recipient's case stands on its own trust anchor. If one recipient's bootstrap could displace another's, the order in which the bootstraps arrive would decide which case the reporter can join.
Extends: CBT-06-002

14.6 Message Processing

The requirements on how a receiver processes a message: handler behavior, which sender is entitled to change which status, the format of a response, and the order in which processing steps run.

Handler Protocol

Handler use-case classes process VultronEvent domain objects and implement protocol business logic. All handlers follow a common contract defined by the UseCase Protocol.

Protocol Semantics
ID Priority Requirement Related
HP-00-001 MUST A receiver MUST interpret received activities as assertions about the sender's state, not as commands to perform work

Each actor owns its own state and decisions. If a receiver obeyed a message as a command, any sender could make it act. The receiver would also do the work again on each redelivery. When the receiver reads a message as an assertion, the message only updates what the receiver knows about the sender. The receiver keeps its own decisions.
HP-00-002 MUST A receiver MUST update its local RM/EM/CS state to reflect the state transition asserted by the received activity

A receiver uses its view of the other parties to decide what to do next. For example, it checks whether an embargo is still active or whether a fix exists. The message is the only way that the receiver learns that the state of the sender changed. If the receiver did not record it, the receiver would act on a state that the sender has left.
Handler Signature
ID Priority Requirement Related
HP-01-006 MUST A receiver MUST establish that the sender of a received activity is entitled to make its assertion before any write, outbound activity or ledger commit. Entitlement is the sender's standing, not the receiver's. The governing group's sender clause names it per message (CM-11-017, CM-16-019, CM-21-011, CM-30-001, CM-30-002, CM-33-002, CM-33-004, CM-33-005, CP-06-005, HP-01-010, RMB-08-004, SYNC-03-005). A receiver role check, such as the CASE_MANAGER gate (BT-17-001), never satisfies it.

A received activity is an assertion about the state of the sender (HP-00-001). Thus the first question is whether the sender has the right to assert it. A CASE_MANAGER gate checks only the receiver. If only that gate protected a handler, any actor could claim ownership, admit itself, or get the full ledger (ADR-0115).
Derives from: HP-00-001
See also: BT-17-001 — context for the reader
HP-01-018 MUST A receiver MUST refuse a received activity whose sender it cannot establish as entitled (HP-01-006), with a reason that names the missing entitlement.

A refusal with a reason tells the sender what standing it lacks. Without the refusal, the activity could still change the case. Without the reason, the sender and an operator cannot tell a missing entitlement from any other fault.
Extends: HP-01-006
HP-01-010 MUST A receiver MUST accept a new report from any actor, whether or not that actor takes part in any case. A new report is sent as Offer(VulnerabilityReport) (RS) or Create(VulnerabilityReport). Only the addressing rules apply to it (HP-01-005, HP-09-001).

A report comes before any case. Thus the sender has no participant record or role. Any person who finds a vulnerability must be able to report it.
Refines: HP-01-006
HP-01-030 MUST NOT A receiver MUST NOT refuse a new report (HP-01-010) on the sender's standing.

A report comes before any case, so its sender has no participant record or role to check. A refusal on standing would stop a finder outside every case from reporting a vulnerability.
Extends: HP-01-010
Offer Recipient Addressing
ID Priority Requirement Related
HP-09-001 MUST A receiver processing an inbound Offer activity MUST determine case-creation eligibility from the to field only

to names the actors that a message asks to act. Only an addressee can make the decision to create a case. If eligibility came from a different field, a courtesy copy could create a case at an actor that the message did not ask. That duplicates cases.
Constrains: HP-01-010
HP-09-002 MUST NOT The target field MUST NOT be used to determine case-creation eligibility for Offer activities

target names where an object must go, not who must act, and a sender can set it to any actor. If target decided case creation, a sender could create a case at an actor that the message does not address.
Unsupported Addressing Fields
ID Priority Requirement Related
HP-10-001 MUST When a receiving actor finds itself only in the cc field of an inbound Offer(VulnerabilityReport) activity, it MUST discard the activity without creating a case

cc addressing has no defined handler semantics in the current protocol version. Implementing an "informational receive" use case for cc recipients would require defining what "informational only" means, which is deferred. Deliberate simplification.
Refines: HP-09-001

Received-Side Status Authorization

Requirements for the authorization model governing how a CASE_MANAGER adopts an inbound participant's reported CaseStatus as canonical (StatusAdoptionGate) and runs the embargo teardown an adopted value calls for, which the adoption also authorizes (ADR-0166). Derived from ADR-0046 and IDEA-1836 planning session.

StatusAdoptionGate

Controls whether a participant's reported CaseStatus is adopted as canonical by the CASE_MANAGER.

ID Priority Requirement Related
RSH-01-003 MUST When the CASE_MANAGER adopts the CaseStatus that a sender's ParticipantStatus embeds, it MUST record the post-adoption CaseStatus in the canonical case ledger. It records nothing when the adoption changes neither EM nor PXA (RSH-04-009).

Adoption is the only path that moves the P, X or A state of a participant into the case status (RSH-04-005). Replicas learn the adopted status only from the ledger, so an adoption with no record leaves them stale. A record that copies the PXA of the case again adopts nothing.
See also: RSH-04-009 — context for the reader
RSH-01-005 MUST The post-adoption CaseStatus of RSH-01-003 MUST set each of P, X and A that either the case's current PXA state or the adopted CaseStatus sets. It clears none that the case already sets.

A record that clears a latch that the case set already undoes the report of another participant. P, X and A latch on only, so the union of the two is the only result that loses no report.
Extends: RSH-01-003
ThreatTerminationBranchNode

Node that triggers embargo teardown on any of the three threat-signal CaseStatus flags.

ID Priority Requirement Related
RSH-03-001 MUST The CASE_MANAGER MUST trigger embargo teardown when the canonical CaseStatus carries CS.P (public awareness), CS.X (exploit public), or CS.A (attacks observed).

All three flags signal a breach of the conditions that justify an active embargo. Covering only CS.P (as the prior PublicDisclosureBranchNode did) leaves exploit and attack signals without a teardown trigger.
RSH-03-004 MUST NOT An actor that does not hold the CASE_MANAGER role MUST NOT ask the CASE_MANAGER for an embargo teardown when the P/X/A status that calls for the teardown (RSH-03-001) was declared by the CASE_MANAGER; it waits for the CASE_MANAGER's committed teardown entry (EP-09-007).

The CASE_MANAGER does the teardown when it detects P, X or A itself. It commits the teardown and records the new status, each as a ledger entry that it announces to every participant. If a replica asks it to terminate an embargo that it terminated already, the only result is a refusal and more messages. An open proposal raises no ask in either case (EMB-16-002). The CSB-18 diagnostic note raises no such false alarm, because PxaEmInvariantDiagnosticNode runs only at the CASE_MANAGER.
Uses definition from: RSH-03-001
See also: EP-09-007 — context for the reader
CaseStatus Emission Authority and Outbound Emit Invariant

Specifies which actors may emit Add(CaseStatus) directly and mandates that every CASE_MANAGER-side EM or PXA state mutation is followed by a canonical CaseStatus ledger write. CaseStatus is the only protocol channel for communicating EM and PXA state changes across actors; omitting the emit leaves all participant replicas stale until the next round-trip.

ID Priority Requirement Related
RSH-04-001 MUST NOT An actor that is not the CASE_MANAGER MUST NOT emit Add(CaseStatus).

CaseStatus encodes shared EM and PXA state for the entire case. The CASE_MANAGER is the authoritative writer of canonical case state (ADR-0210, CLP-09). Allowing participants to emit Add(CaseStatus) directly would bypass the adoption authorization model.
RSH-04-007 MUST A participant that is not the CASE_MANAGER MUST report the CaseStatus it suggests by embedding it in its own Add(ParticipantStatus).

A participant cannot send Add(CaseStatus) (RSH-04-001), but its view of P, X or A still needs to reach the case. Embedding it in the participant's own status puts it through the adoption gate (RSH-01-003).
Extends: RSH-04-001
RSH-04-002 MUST Every change the CASE_MANAGER makes to EM state (Propose, Accept, Reject, Terminate, and all cascade variants) MUST be followed immediately by a record of the updated CaseStatus in the canonical case ledger. A received activity whose committed entry records the very activity that caused the transition, and whose entry a replica applies by replaying the same transition (RSH-08-004, ADR-0113), has made that record: the committed entry carries the change to every replica, and a second CaseStatus entry for it would be a duplicate.

Remote actors see EM state changes only through CaseStatus entries in Add(CaseLedgerEntry) messages. If a change has no ledger write after it, the replicas of the participants keep a stale EM state. If the committed entry records the activity that caused the change, and replicas replay the same transition, that entry carries the change. A second CaseStatus entry then only duplicates it.
See also: RSH-08-004 — context for the reader
RSH-04-003 MUST Every change the CASE_MANAGER makes to PXA state (public awareness, exploit public, attacks observed) MUST be followed immediately by a record of the updated CaseStatus in the canonical case ledger.

PXA state is participant-agnostic and shared across the case. The rationale mirrors RSH-04-002: omitting the ledger write leaves replicas stale and breaks the Avoid Surprise principle.
RSH-04-004 MUST The CASE_MANAGER MUST make the CaseStatus record of RSH-04-002 and RSH-04-003 by committing a canonical CaseLedgerEntry that carries the new CaseStatus. It then announces the entry with Add(CaseLedgerEntry) for participant replica sync.

Replicas learn of the CASE_MANAGER's own EM or PXA change only from the announced entry, so the record is a committed entry that the CASE_MANAGER announces.
Implements: RSH-04-002
Implements: RSH-04-003
RSH-04-008 MUST NOT The CASE_MANAGER MUST NOT adjudicate its own CaseStatus as a received message. It is the authority for its own outbound state changes.

The CASE_MANAGER's own EM or PXA transition is an authoritative state change, not a received message. A received Add(CaseStatus) is admitted only from the CASE_MANAGER at a participant replica (RSH-04-005, RSH-08-003), so judging its own change as one would apply a rule meant for others.
Extends: RSH-04-004
RSH-04-009 MUST NOT The CASE_MANAGER MUST NOT commit or record a CaseStatus snapshot whose EM and PXA equal those of the case's last committed CaseStatus (CLP-07-013, ADR-0152). It measures the change against the ledger, not against the case's current status, which already carries the register's EM (ADR-0122).

Replicas learn of a change only from the announced entry. An entry that repeats the last committed CaseStatus would hand every replica a duplicate that records no change.
Extends: RSH-04-004
Refines: CLP-07-013
RSH-04-005 MUST A receiver MUST refuse a received Add(CaseStatus) unless the case's CASE_MANAGER sent it to a participant.

RSH-04-001 reserves Add(CaseStatus) for the CASE_MANAGER, which sends it to participants inside a case ledger entry. add_case_status_tree has no StatusAdoptionGate, so admitting it from another sender would adopt that participant's P, X or A report without the Case Owner approval RSH-07-001 requires. A participant embeds the P, X or A it reports in its own Add(ParticipantStatus) instead (RSH-04-007), which the CASE_MANAGER adopts through the gate (RSH-01-003).
Derives from: RSH-04-001
Refines: HP-01-006
RSH-04-012 MUST When a receiver refuses an Add(CaseStatus) under RSH-04-005, it MUST write nothing past intake and send nothing.

A refused status is one the receiver must not act on. A write past intake would change case state on the refused claim, and a reply would answer a sender that had no right to send it.
Extends: RSH-04-005
RM Anomaly Notification Policy (non-adjacent jumps and backward regressions)

When the receiver detects an RM transition anomaly — either a non-adjacent forward jump (sender skipped intermediate states) or a backward regression (sender reports a state earlier on the RM progress scale than the receiver has already observed) — it must act correctly and non-silently. Because CVD is inherently asynchronous, anomalies are detected at receipt time (t₁ > t₀ when the event occurred), and silence at that point breaks observability for both parties. Derived from ISSUE-2258 and ADR-0067.

ID Priority Requirement Related
RSH-06-001 MUST A CASE_MANAGER receiving an Add(ParticipantStatus, target=<participant>/statuses) that carries a non-adjacent forward RM jump (a move forward on the RM progress scale to a state that is not adjacent to the recorded one) MUST accept the reported rm state.

The sender is the authority for its own RM progress. If the receiver refuses a forward jump that is not adjacent, its replica stays incorrect, because the sender does not send again the intermediate transitions that it did not report. The receiver accepts every move that a forward path explains. This is the liberal-accept rule (ADR-0067).
RSH-06-002 MUST A CASE_MANAGER receiving an Add(ParticipantStatus, target=<participant>/statuses) that carries a backward RM regression (i.e. the reported rm state is earlier on the RM progress scale than the receiver's current value) MUST refuse the whole update (RSH-09-001, RSH-09-003).

RM is monotonic: a sender cannot un-validate, un-accept, or un-close a report. A backward assertion indicates either a protocol error or a divergent replica state; neither should update the receiver's record.
Refines: RSH-09-003
See also: RSH-09-001 — context for the reader
RSH-06-004 SHOULD Where a case context is available, the CASE_MANAGER SHOULD record a note on the case when it detects an RM anomaly. The note asks the sender to clarify the path it took between the two observed states. This holds whether the declaration that carries the anomaly is accepted or refused. The note is the CASE_MANAGER's own act (CLP-10-031). It commits the Add(Note)[target=VulnerabilityCase] carrying the note inline as an add_note_to_case entry, and attaches the note to the case.

An RM anomaly needs an answer in the protocol, not only in local logs, because only the sender knows the path that it took between the two states seen. Add(Note)[target=VulnerabilityCase] is the message for a condition that needs a written explanation (MSM-05-001). It replaces the report-management error message that MessageSemantics does not define (ADR-0049).
Refines: CLP-10-031
RSH-06-007 MUST NOT The CASE_MANAGER MUST NOT send the RSH-06-004 note to the sender as a direct Add(Note), which a participant refuses (HP-01-005). The sender learns of the note from the entry's Add(CaseLedgerEntry) fan-out (SYNC-02-001, SYNC-02-003).

The note is a case act of the CASE_MANAGER, so it goes to the sender through the ledger. A participant refuses a direct Add(Note) (HP-01-005), so a direct send would never reach it.
Extends: RSH-06-004
See also: HP-01-005 — context for the reader
See also: SYNC-02-001 — context for the reader
See also: SYNC-02-003 — context for the reader
RSH-06-005 MUST The note recorded under RSH-06-004 MUST include: the sending actor's identifier, the rm state before the anomaly, the rm state after the anomaly, and a human-readable description identifying whether the anomaly was a non-adjacent forward jump or a backward regression.

Without these fields the note cannot be acted on by a human or an automated remediation process. The request for clarification is only meaningful if the recipient can identify what they are being asked to clarify.
Extends: RSH-06-004
RSH-06-006 MUST The CASE_MANAGER MUST apply the RM acceptance rule of RSH-06-001, RSH-06-002, RSH-06-004 and RSH-06-005 to every received write of a participant's RM state. The rule accepts a forward move, a non-adjacent one included. It refuses a backward move and keeps the recorded state. It posts the clarification note where a case context exists. The rule holds whichever wire activity carries the declaration. Adjacency-only validation, which accepts only a move to an adjacent RM state, is never the receive-side rule for any of them. These writes include the report activities Accept(Offer(VulnerabilityReport)) and TentativeReject(Offer(VulnerabilityReport)). They include the full-case Invite replies Accept, TentativeReject and Reject(Invite(whole VulnerabilityCase)[target=Actor]) (CM-11-011). They include the case activities Join(VulnerabilityCase) and Ignore(VulnerabilityCase), not only Add(ParticipantStatus, target=<participant>/statuses). A declaration from a sender whose closure the case's ledger records is not adjudicated. It is refused before the rule applies, with no note (CM-23-018). A Reject(Offer(VulnerabilityReport)) for a report that belongs to the case is not adjudicated either. It is refused whatever it declares (CM-23-019).

The acceptance rule belongs to the state machine, not to the message. A transition accepted as a status snapshot but refused as the activity that caused it lets the sender pick its adjudication by picking its message shape, and lets the receiver second-guess a legal self-declaration because it never saw the intermediate step (ADR-0108). Adjacency remains the emit-side rule (ADR-0086): conservative in what you send, liberal in what you accept.
Uses definition from: CM-11-011
Uses definition from: RSH-06-001
Uses definition from: RSH-06-002
Uses definition from: RSH-06-004
Uses definition from: RSH-06-005
See also: CM-23-018 — context for the reader
See also: CM-23-019 — context for the reader
Conservative Default Authorization Policy for Status Gates

Adopting a non-owner's reported P, X or A value waits by default for the Case Owner's authorization, which also authorizes the embargo teardown the adopted value calls for (ADR-0210). A permissive policy is a deployment's explicit choice. Derived from CONCERN-2092 and ADR-0076; the mechanism is amended by ADR-0080 (CONCERN-2812, CONCERN-2809) — see RSH-07-004.

ID Priority Requirement Related
RSH-07-001 MUST Before it adopts a P, X or A value that a non-owner participant reports, the CASE_MANAGER MUST by default obtain the Case Owner's authorization. Adoption makes the value canonical case state.

A permissive default lets any admitted participant, a hostile or defective sentinel included, force PXA adoption and start the embargo teardown with no Case Owner confirmation. So the default is conservative, and permissive behavior needs an explicit opt-in (ADR-0076). The authorization also covers the teardown the adopted value calls for (ADR-0210). The rule says what a receiver does with a reported status, so every CASE_MANAGER obeys it. The Case Owner's own report is RSH-07-006.
RSH-07-006 MUST NOT Before it adopts a P, X or A value that the Case Owner reports, the CASE_MANAGER MUST NOT ask the Case Owner to approve it.

The Case Owner is the authority that RSH-07-001 asks. Asking it to approve its own report would be circular and would hold the case's canonical state on a question with only one possible answer. The report is still judged by the acceptance rules of RSH-09.
One Move, One Mover — Received-Side Write Subject and Pipeline

A protocol state transition may reach a receiver in more than one wire shape: the activity that performed the move (TentativeReject(Offer(VulnerabilityReport))) and a declaration of the resulting state (Add(ParticipantStatus) carrying rmState). These are two layers of one move, not competing encodings. Authority is a property of the pipeline, not of the message: the mover announces, the CASE_MANAGER adjudicates and commits, replicas apply the ledger. Derived from CONCERN-3473 and ADR-0108.

ID Priority Requirement Related
RSH-08-001 MUST A participant's RM status declaration is its assertion about itself, not about another actor. A receiver MUST take a received RM status declaration as a statement of the sending actor's own RM state. One participant record is not declared by its participant: a new invitee's. The CASE_MANAGER creates it when it emits the stub Invite in answer to a received activity (CM-11-006, CM-17-018, CM-16-006). It sets the RM.RECEIVED that it infers from its own send (BT-10-005).

A received activity is a statement about the state of the sender (HP-00-001), and each participant declares its own status (ADR-0121). The mistake this rule prevents has recurred (ADR-0089, CONCERN-3473): a tree that takes its store (BT-17-006) as the subject moves the receiver's RM on a declaration about the sender. RSH-08-005 states how this codebase records the declaration.
See also: BT-10-005 — context for the reader
See also: CM-11-006 — context for the reader
See also: CM-16-006 — context for the reader
See also: CM-17-018 — context for the reader
RSH-08-008 MUST A receiver's own RM state MUST move on receipt of an RM status declaration only when the receiver is itself the mover. It is the mover when it is also the sender. The CASE_MANAGER is also the mover when CM-23-002 directs it to advance its own participant on the Case Owner's departure.

A declaration is about its sender (RSH-08-001), so it moves the receiver's own RM only when the receiver is the one that moved. Other occasions, such as a report's receipt, declare their own subject (SM-10-001, ADR-0162).
Extends: RSH-08-001
See also: CM-23-002 — context for the reader
RSH-08-002 MUST When an act and a status declaration for the same move both arrive, the receiver MUST treat the second as a same-state confirmation. It never refuses it, faults it or records it as an anomaly. An example is TentativeReject(Offer(VulnerabilityReport)) followed by Add(ParticipantStatus) with rmState: INVALID.

One move producing both messages is expected (ADR-0108), so the second message confirms a state the receiver already recorded.
RSH-08-009 MUST The receiver MUST adjudicate a declaration whose RM value disagrees with the act it saw under the RM acceptance rule (RSH-06), like any other declaration. The disagreement is not itself grounds for refusal.

The declaration is the participant's own statement about itself and the participant is the authority on that; a mismatch with the act is a gap to flag under RSH-06-003, not a reason to prefer one message over the other.
RSH-08-006 MUST NOT A participant that declares its own RM, VF or D state MUST NOT append the status to a participant record in its own case replica. Nor may a Case Owner that asserts one on another participant's behalf. Each sends the declaration to the CASE_MANAGER. Its replica copies the status the CASE_MANAGER commits for it, as every other replica does.

A status that the sender writes for itself has its own id and times, or a value that the CASE_MANAGER then filters. The replica of the sender then holds a status that no entry records, and it is different from every replica at the same ledger position. PCR-03-002 and PCR-03-005 stop the Case Owner from writing its own copy. This rule applies the same limit to every sender of a status declaration (CLP-07-013, CM-23-016).
Extends: PCR-03-002
RSH-08-012 MAY A sender of a declaration under RSH-08-006 MAY check the move before it sends the declaration.

A sender that checks its move first does not send a declaration the CASE_MANAGER would refuse. The check writes nothing, so the replica still holds only committed state.
Uses definition from: RSH-08-006
RSH-08-013 MAY A sender of a declaration under RSH-08-006 MAY store the status object that the activity carries.

The status object is what the sender sends, so storing it lets the sender read back what it declared. A stored object attached to no participant record changes no replica state.
Uses definition from: RSH-08-006
RSH-08-007 MUST Participant status is self-declared. The CASE_MANAGER MUST refuse, before the commit, a received Add(ParticipantStatus) that targets the status history of a participant record that is not the sender's own, whichever dimensions it carries. A record is the sender's own when its attributedTo is the sender. The dimensions are RM, VF, D and the P, X and A of its case status. The only exceptions are the on-behalf assertions of RSH-08-014.

A received activity is a statement about the state of the sender (HP-00-001), and RSH-08-001 makes the sender the subject of an RM declaration. With no subject check on Add(ParticipantStatus), a participant can write any status on the record of a different participant, and the CASE_MANAGER commits it.
Extends: RSH-08-001
RSH-08-014 MAY A sender holding CASE_MANAGER or CASE_OWNER MAY assert v→V for a Vendor-role participant, or d→D for a Deployer-role participant (PRM-06-003, PRM-06-004). The two moves cannot be asserted in one status. This holds only when the status changes nothing else: RM is as the target holds it, and the status carries no case status.

The on-behalf trigger sends only the PRM-06 moves, so the receive side admits those moves and no others (ADR-0121). The two moves cannot share one status: such a status asserts Vf and D at once, the compound state VfD — a fix deployed before it was ready — which is not among the 32 CSB-17-001 enumerates. PRM-06-008 already requires the entailments on an on-behalf d→D, so that status is refused, and a permission for it would be one no sender can exercise.
Refines: PRM-06-003
Refines: PRM-06-004
Supersedes: RSH-08-007
Whole Accept or Reject of a Received Status

A received Add(ParticipantStatus, target=<participant>/statuses) or Add(CaseStatus, target=<case>/statuses) states a whole status, so the CASE_MANAGER accepts it as sent or refuses all of it. It never records a status the sender did not send. Derived from ADR-0107 and ISSUE-3741.

ID Priority Requirement Related
RSH-09-001 MUST A CASE_MANAGER receiving an Add(ParticipantStatus, target=<participant>/statuses) MUST either accept the status whole, recording exactly the status it received, or refuse the whole update.

The case ledger records what each participant asserted, and every replica copies what it records (CLP-07-013, CM-23-016). A status partly accepted is one nobody sent (ADR-0107).
RSH-09-010 MUST NOT The CASE_MANAGER MUST NOT record, commit or replicate a status that differs from the ParticipantStatus it received. Filling a dimension the sender omitted with a value of its own is one such difference.

A status rewritten before it is recorded is one nobody sent: the ledger could then neither show what the sender claimed nor let a replica verify it (ADR-0107). An omitted dimension is absent from the status the sender sent (ADR-0075), so recording it as absent is recording the status as sent.
Refines: RSH-09-001
RSH-09-002 MUST When any acceptance rule refuses a received status, the CASE_MANAGER MUST refuse the whole update. It appends nothing, commits no ledger entry for it and adopts nothing from it.

A status partly accepted would record one nobody sent (RSH-09-001), so a refusal by any one rule refuses the whole status.
Refines: RSH-09-001
RSH-09-011 MUST The CASE_MANAGER's refusal notice for a status refused under RSH-09-002 MUST name every refused dimension and the reason for each.

A sender can correct an update only if it learns everything that is wrong with it in one answer (EH-07-001). Naming one reason at a time would cost a round trip per mistake.
Extends: RSH-09-002
RSH-09-003 MUST A received ParticipantStatus MUST be refused when any of these holds: the participant's recorded RM state is CLOSED, which is terminal; its RM state moves backwards (RSH-06-002); it states a fix-readiness value but the sender does not hold the VENDOR role, or a deployment value but the sender does not hold the DEPLOYER role; a stated fix-readiness, deployment or public-state (P/X/A) value is neither the participant's most recent recorded value nor a forward move from it. A dimension the sender omits is not refused, and does not reset the recorded value a later status is judged against. Every status states an RM state: one that leaves rmState out states the initial START. The embargo state the status embeds is not judged against the case: the case derives EM from its embargo register.

Each rule refuses a claim no sequence of events could produce from the participant's recorded state. A non-adjacent forward move is accepted (RSH-06-001, CSB-16-001): a peer may have advanced several steps between messages. EM belongs to the embargo register (ADR-0122), and the report's P/X/A reaches the case only through the adoption gate (RSH-01-003).
Extends: RSH-09-001
RSH-09-004 MUST A CASE_MANAGER MUST refuse the whole update when a received ParticipantStatus, as received, violates any cross-machine entailment. The entailments are RM↔VF and RM↔D (CSB-18-001), and VF↔D (CSB-17-001).

Each dimension can be acceptable alone when the combination is not possible. A fix that is ready or deployed requires a report that the participant accepted, and a deployed fix requires a ready fix. A replica refuses to apply such a status (RSH-09-006). Thus a recorded status of this type commits an entry that no replica can apply.
Extends: RSH-09-001
Uses definition from: CSB-17-001
Uses definition from: CSB-18-001
RSH-09-012 MUST The CASE_MANAGER MUST evaluate the same entailment set on a received ParticipantStatus that its emit path evaluates.

One shared evaluator keeps the emit path and the receive path the same, so the CASE_MANAGER never refuses a status it would itself send, or sends one it would refuse.
Extends: RSH-09-004
RSH-09-005 MUST A participant that receives Add(CaseStatus, target=<case>/statuses) from the case's CASE_MANAGER MUST accept it whole if two conditions hold, and refuse the whole update if either fails. Its EM state must be identical to the EM state the case derives from its embargo register. Its P/X/A state must be the case's own or a monotone forward move from it.

EM changes only through the embargo messages that cause each register step (ADR-0122), so a status can report EM but never move it. P/X/A bits only advance, and a remote peer may report a combined advance that skips intermediate steps, so the received path uses the monotone check rather than the single-step adjacency that applies to local writes (CSB-16-002). A status partly accepted would record one nobody sent (RSH-09-001).
RSH-09-006 MUST NOT A receiver MUST NOT apply the participant status that an Add(CaseLedgerEntry) entry adds if that status violates any composite-state entailment. It judges the participant state the entry carries. The entailments are RM↔VF and RM↔D (CSB-18-001), and VF↔D (CSB-17-001).

A CASE_MANAGER that is buggy or hostile can commit an entry whose participant state violates the entailments the emit and receive paths enforce (RSH-09-004). Without this check every replica silently adopts an impossible combination it would have refused to emit.
Uses definition from: CSB-17-001
Uses definition from: CSB-18-001
RSH-09-013 MUST When a receiver declines a status update under RSH-09-006, it MUST send Create(ProcessingFault) with failure class StatusAssertionRefused/ImpossibleState to the CASE_MANAGER.

The CASE_MANAGER must learn that a replica could not apply its entry. A Create(ProcessingFault) rather than a Reject(CaseLedgerEntry) avoids a CASE_MANAGER replay loop: the committed entry cannot be uncommitted, so replaying it would be refused forever (ASK-07-001).
Extends: RSH-09-006
RSH-09-009 MUST NOT A received ParticipantStatus MUST NOT be refused for the sender's case roles over the public-state (P/X/A) values that its embedded CaseStatus states. A participant holding any role, OBSERVER alone included, can report that the vulnerability is public, that an exploit is public or that attacks are observed. Adoption decides whether a reported value becomes canonical case state (RSH-01-003), not the acceptance rules.

P, X and A record the state of the world, not anything a participant did, so no role owns them. A Vendor cannot be the only party able to say that an exploit is public: an Observer or a monitoring service is often the first to see it. The adoption gate, not a role check, protects canonical case state from a wrong report.
Extends: RSH-09-003
See also: RSH-01-003 — context for the reader

Response Format

The Vultron protocol uses ActivityStreams activities for both requests and responses. When handlers process inbound activities, they generate response activities (Accept, Reject, Update, etc.) sent to the originating actor or other participants.

Accept Response
ID Priority Requirement Related
RF-02-001 MUST Accept responses MUST use Accept activity type

A receiver recognizes an acceptance by the activity type, and Accept is the AS2 term peers match on. Any other type would not be read as an acceptance.
RF-02-002 MUST Accept responses MUST include object field referencing accepted activity or object

An Accept with no object does not say what it accepts. An initiator with several requests outstanding could not tell which one changed state.
RF-02-004 MUST When accepting an offered object, the object of the Accept activity MUST be the Offer activity itself, carried inline or by reference, not the underlying object being offered.

An Accept of the offered object is ambiguous when that object has been offered more than once, and receivers match an acceptance as Accept(Offer). Naming the Offer says which proposal was accepted. Inline or by reference leaves the form to the implementation (AKM-05-003).
RF-02-005 MUST When accepting an Invite, the object of the Accept activity MUST be the Invite activity itself, carried inline or by reference, not the case, embargo, or any other domain object.

An Accept of the case or embargo does not say which Invite it answers, and several Invites can be open at once. Receivers match the answer as Accept(Invite), so naming the Invite selects the right use case and closes that Invite.
Refines: RF-02-002
Reject Response
ID Priority Requirement Related
RF-03-001 MUST Reject responses MUST use Reject activity type

A receiver recognizes a refusal by the activity type, and Reject is the AS2 term peers match on. Any other type would not be read as a refusal.
RF-03-002 SHOULD Reject responses SHOULD include reason in content field

A bare Reject tells the initiator that its proposal failed but not why, so it cannot correct the proposal or decide whether to escalate. A reason gives the participant something to act on; it is a SHOULD because a refusal can stand without one.
RF-03-003 MUST When rejecting an offered object, the object of the Reject activity MUST be the Offer activity itself, carried inline or by reference, not the underlying object being offered.

The Offer is the proposal the initiator tracks. Referencing it ties the Reject to that one proposal, so the initiator can close it, even when the same object has been offered more than once. Inline or by reference leaves the form to the implementation (AKM-05-003).
TentativeReject Response
ID Priority Requirement Related
RF-04-001 MUST TentativeReject responses MUST use TentativeReject activity type

A TentativeReject is a provisional refusal, which the receiver handles differently from a final Reject. Only a distinct activity type lets the receiver tell the two apart.
RF-04-002 SHOULD TentativeReject responses SHOULD include reason in content field

A provisional refusal invites a revised proposal. Without a reason the initiator cannot tell what would make the proposal acceptable; it is a SHOULD because a refusal can stand without one.
RF-04-003 MUST When tentatively rejecting an offered object, the object of the TentativeReject activity MUST be the Offer activity itself, carried inline or by reference, not the underlying object being offered.

The Offer is the proposal the initiator tracks. Referencing it ties the TentativeReject to that one proposal, even when the same object has been offered more than once. Inline or by reference leaves the form to the implementation (AKM-05-003).
Error Response
ID Priority Requirement Related
RF-05-001 SHOULD Error responses SHOULD use ActivityStreams error extensions

The protocol defines error messages whose recipients inquire about the error (VP-03-010, VP-03-011, VP-11-005). Expressed in the AS2 vocabulary, an error travels and is parsed through the same inbox pipeline as every other activity, with no second channel.
Response Delivery
ID Priority Requirement Related
RF-06-002 MUST Response activities MUST be addressed to the INITIATING actor's inbox, not to the inbox that received the original activity

Activities are state-change assertions; the initiator must receive the response to update their model of the case state
Response Correlation
ID Priority Requirement Related
RF-08-001 MUST Response activities MUST include inReplyTo field

A participant can have several requests outstanding. inReplyTo names the activity a response answers, so the initiator matches the response to its request without inferring it from the object.
RF-08-004 MUST A Reject(CaseLedgerEntry) MUST name in inReplyTo the inbound activity that prompted it: the Add(CaseLedgerEntry) it could not apply, or the Announce(VulnerabilityCase) whose copy is ahead of the sender's chain.

The object of this Reject is a ledger entry, or nothing, not an activity, so the response cannot name what it answers through its object. The inbound activity is the one each sender holds on every path. The Create(ProcessingFault) for a refused entry names its Add the same way (SYNC-16-003).
Refines: RF-08-001
Idempotent Responses
ID Priority Requirement Related
RF-09-001 MUST Response generation MUST be idempotent

Delivery is at-least-once, so a receiver sees some activities more than once. If each copy produced a new response, the initiator would receive duplicate or conflicting answers and could apply the same state change twice.

Behavior Tree Integration

Requirements for integrating py_trees behavior trees into Vultron handler functions. Covers the BT execution model, state management via the DataLayer, handler integration patterns, actor isolation, concurrency constraints, and failure diagnosis. Complex protocol workflows such as report validation, case creation, and embargo management must be implemented as BT nodes or subtrees.

CASE_MANAGER Role Management
ID Priority Requirement Related
BT-10-002 MUST Case creation MUST establish the case's CASE_MANAGER by recording a participant that holds the CASE_MANAGER role.

The CASE_MANAGER is a role that a participant holds. It is not a separate entity. When case creation records the role on a participant, any actor can take the role, and every participant finds the CASE_MANAGER in the participant records of the case.
BT-10-007 MUST NOT Case creation MUST NOT require a per-case Service actor.

A Service record for each case only repeats what the CASE_MANAGER role already shows. A container also cannot prepare such a record before use, because the case does not exist until a report arrives.
Extends: BT-10-002
BT-10-008 MUST NOT Case creation MUST NOT mint a per-case actor identity. The actor that enacts the role keeps its own actor identity, and the activity's context carries the case that a message concerns.

An actor takes part in many cases and keeps one identity in all of them. A container cannot host a per-case actor identity. The sender calculates that identity from the report id or case id, so no container can register it, and every message to it fails. A future process that runs one case gets its own actor identity for the same reason.
Extends: BT-10-002
BT-10-003 MUST The actor holding the CASE_MANAGER role for a case MUST process that case's messages. The authority is that role, not any particular actor that enacts it.

When message processing follows the role and not one specific object, any actor that holds the role can do the work. This includes an actor that the Case Owner delegates the role to, and the Case Owner itself. If an obligation names a separate case actor, implementations create one for each case, which BT-10-002 forbids.
Depends on: BT-10-002
BT-10-004 MUST The actor holding the CASE_MANAGER role for a case MUST enforce that case's authorization decisions.

Each authorization decision of a case needs one enforcer that every participant can name. The CASE_MANAGER processes the messages of the case (BT-10-003), so it is the actor that admits or refuses them.
BT-10-009 MUST The CASE_MANAGER MUST hold its authority over a case's authorization decisions through its role, not through a per-case actor identity.

When authority follows the role, it moves with a delegation, and it does not depend on one specific software actor. It also operates when the CASE_MANAGER is a person or an organization and not a service, which is the general case. BT-10-006 tells how the gates in this codebase test for the role.
Extends: BT-10-004
BT-10-005 SHOULD The CASE_MANAGER SHOULD record an invitee's RM state as RM.RECEIVED when it emits the stub Invite (CM-11-006).

When the CASE_MANAGER emits the stub Invite, the invitee holds no case yet and has made no triage decision. RM.RECEIVED records that the report reached the invitee, and nothing more.
Extends: CM-11-006

Event-Driven Control Flow

Defines the event-driven processing model for Vultron actors: how primary events enter the system, how cascading consequences are produced automatically, and what constraints apply to demo scripts and integration tests.

Cascade Implementation
ID Priority Requirement Related
EDF-03-004 MUST The cascading consequence of a primary event MUST be fully determined by the handling actor's processing of that event, with no required intermediate local action, except at explicit external decision points (see EDF-04).

A peer sees only what an actor emits. If an actor needs an extra local step before it completes the consequences of an event, its peers wait for something that the protocol does not show them. When the processing of the event alone determines its consequences, every implementation that receives the same event does the same work. The only exception is a point where the actor must wait for a decision (EDF-04).

14.7 Transport and Security

The requirements on transport and security: the Hypertext Transfer Protocol (HTTP) transport, the inbox endpoint, the outbox, message signing, and encryption.

HTTP Protocol Requirements

HTTP protocol requirements for the Vultron API, covering status codes, headers, and content negotiation.

Content-Type Validation
ID Priority Requirement Related
HTTP-01-001 MUST Inbox endpoint MUST accept application/activity+json Content-Type

ActivityPub only says a server SHOULD treat application/activity+json as equivalent to the JSON-LD media type it names for delivery (HTTP-01-002). Vultron makes that SHOULD a MUST, so the rule is Vultron's own, not inherited.
HTTP-01-004 MUST A sender MUST deliver an activity to an inbox with Content-Type: application/activity+json or Content-Type: application/ld+json; profile="https://www.w3.org/ns/activitystreams".

ActivityPub requires a POST to an inbox to use the ld+json ActivityStreams profile. Every Vultron inbox also accepts application/activity+json (HTTP-01-001, HTTP-01-002), so Vultron lets a sender use either form. That is looser than ActivityPub, so the rule is Vultron's own. A receiver that refuses other media types (HTTP-01-003) refuses plain application/json.
Extends: HTTP-01-001
Response Headers
ID Priority Requirement Related
HTTP-04-001 MUST Endpoints returning ActivityStreams objects MUST use Content-Type: application/activity+json.

ActivityPub allows an ActivityStreams document to be served as either application/activity+json or application/ld+json; profile="https://www.w3.org/ns/activitystreams". Requiring the first picks one form among those the standard allows, so the rule is Vultron's own (MS-12-009), as the inbox's media-type rule is (HTTP-01-001). Plain application/json is ambiguous for federation clients that discover capabilities via Content-Type.

Inbox Endpoint

The inbox endpoint is the primary entry point for actor-to-actor communication in Vultron. It receives ActivityStreams activities via HTTP POST, validates them, and queues them for asynchronous processing.

Activity Validation
ID Priority Requirement Related
IE-04-001 MUST The endpoint MUST validate each activity's structure against the message form its type requires

A receiver acts on an activity according to its type. A malformed activity can be read as the wrong message, or its processing can fail part of the way through. If the receiver checks the form when the activity arrives, it refuses the activity once, with a clear reason, and later steps work on an activity whose form is known (ADR-0032).
Activity Addressing
ID Priority Requirement Related
IE-11-001 MUST The inbox endpoint MUST refuse any Activity whose addressing fields (to, cc, bto, bcc) are all non-empty and none of them names the receiving actor.

Per-actor DataLayer isolation (ADR-0073) makes each actor's store the authoritative answer to "whose replica is this?". That invariant is only trustworthy if the store's owner was the intended recipient of every Activity it processed. Which HTTP response carries the refusal is this codebase's choice, not a protocol rule: it answers HTTP 400 in place of the 202 (IE-07-002, project), so the sender learns of the refusal from the answer to its own delivery.
IE-11-004 MUST NOT The inbox endpoint MUST NOT write anything to the receiving actor's store for an Activity that IE-11-001 refuses.

A record of a misaddressed Activity would make the store hold an activity that its owner was not meant to receive. The store would then no longer answer "whose replica is this?" with certainty (ADR-0073).
Extends: IE-11-001
IE-11-002 MUST The inbox endpoint MUST accept Activities whose addressing fields (to, cc, bto, bcc) are all absent or unresolvable (Liberal Accept). An address is unresolvable if it cannot be confirmed to refer to a specific individual actor — for example, a collection URI such as {case_id}/participants.

Requiring explicit addressing would break flows where Activities are sent without formal addressing (e.g., internal relay, legacy senders). The narrowest thing that can be refused is provable exclusion; uncertainty defaults to acceptance. Fan-out deliveries using collection URIs (e.g. {case_id}/participants) cannot be resolved to individual actors at inbox processing time and must therefore be accepted.
IE-11-003 MUST The inbox endpoint MUST consider all four addressing fields — to, cc, bto, bcc — when determining whether the receiving actor is named as a recipient. A match on any one field is sufficient.

ActivityStreams has several audience properties, and Vultron decides which of them count as addressing, so the rule is Vultron's own. Vultron defines no use for audience on any object or activity, so an actor named only there is not addressed. Vultron sets only to (OX-08), but another implementation can name this actor only in cc, bto or bcc. If the inbox checks only to, it refuses that activity wrongly. HP-10 decides what an address only in cc means.

Outbox

Requirements for actor outboxes, which hold response activities generated by handlers. Covers outbox structure, population, delivery, local and federated dispatch, idempotency, outbound reference dehydration, and outbox addressing rules.

Undelivered-Activity Correlation

Requirements linking a permanently undelivered activity back to the canonical case ledger entry that recorded the event the activity carries, so that divergence between the canonical log and a participant's replica is observable rather than silent. Derived from CONCERN-2657 and ADR-0080.

ID Priority Requirement Related
OX-14-002 MUST NOT A canonical CaseLedgerEntry commit MUST NOT be deferred until delivery of the corresponding outbound activity is confirmed.

Gating the commit on delivery makes an actor's own decision history hostage to the network, inverts the guards-then-commit-then-effects ordering CLP-10-006 requires, and creates an unanswerable partial-delivery question when some recipients succeed and others fail. Delivery confirmation is a transport-level receipt and is not agreement to the delivered content; the two layers stay separate.

Signing

Requirements for signing the activities an actor sends and verifying the activities it receives, using object-level proofs carried inside the activity (FEP-8b32) so that a proof stays checkable after a relay or a ledger commit. HTTP Signatures and production key handling are out of scope here (ENC-01, OX-10).

Proofs on Sent Activities
ID Priority Requirement Related
SIG-01-001 MUST Every activity an actor sends MUST carry a proof made with its author's key.

A receiver cannot otherwise tell who wrote an activity, so any client could post an activity in another actor's name (#509). The proof sits inside the activity, so it still shows who wrote the content after the CASE_MANAGER relays it or commits it to the ledger, which a signature on one HTTP delivery cannot show.
SIG-01-002 MUST A proof MUST be a DataIntegrityProof using the eddsa-jcs-2022 cryptosuite, with proofPurpose assertionMethod and a verificationMethod naming a key in its author's actor profile.

Signer and verifier must agree on one proof form, or a correct proof is refused. FEP-8b32 with eddsa-jcs-2022 (Ed25519 over the RFC 8785 canonical form) is the form ActivityPub implementations use for object integrity, and naming the key by the author's profile tells the receiver where to get it (SIG-02-001).
Extends: SIG-01-001
SIG-01-003 MUST A proof MUST cover the whole activity as sent, every nested object included, except the proof itself.

A proof that covers only part of an activity lets anyone change the rest without detection. The objects nested in an activity carry most of what a receiver acts on, such as a report's content or a ledger entry's snapshot.
Key Discovery
ID Priority Requirement Related
SIG-02-001 MUST A receiver MUST take the key that verifies a proof only from the author's actor profile, fetched from the author's URL, or a cached copy of that fetch.

A key the receiver got anywhere else, such as from the activity itself or from a third actor, proves nothing about the author: anyone can sign with a key they made and name it. The author's profile is where the author's identity is already published, so it is the one source the receiver can trust as far as it trusts the author's id.
SIG-02-002 MUST An actor MUST serve its actor profile, its key included, to a request that carries no proof or signature.

A receiver fetches the author's profile to get the key that verifies the author's proof. Demanding a proof on that fetch would need a key the requester may not have yet, so key discovery could never start.
SIG-02-003 MUST A verifier MUST take a proof's key only from the author's own profile as served at the author's profile URL, freshly fetched or a cached copy of such a fetch, and never from a profile embedded in a received activity (SIG-02-004) or any other copy it did not obtain from that URL.

A copy of a peer's profile that came from somewhere other than that peer, such as an activity that embedded it, may carry a planted key that would let the planter sign as the peer. The peer's own URL is the one source the receiver can trust as far as it trusts the peer's id, so a fetch from it, or a cache of that fetch, is authoritative. The prototype fetches every time and keeps no cache; that is an implementation choice, not a protocol rule. Whether to pin the first key fetched (trust on first use), and how a fetched key is cached or rotated, are #1184's to decide.
Refines: SIG-02-001
SIG-02-004 MUST A receiver MUST discard the keys of every actor profile a received activity embeds, before it parses or stores the activity, except inside a ledger entry's payloadSnapshot, which it keeps as received and reads no key from.

A key embedded in a received activity was put there by its sender, who need not be the profile's actor. Discarding it at the parse edge means no parsed object and no stored copy carries a peer's key (SIG-02-003). The received body itself is kept as received, as evidence (VM-08-002), and no key is read from it. A payloadSnapshot is kept byte for byte, since its author's proof covers it (SIG-04-002), so a profile inside it keeps its keys; no key is read from a stored copy, so they are never used.
Implements: SIG-02-003
Verification and Refusal
ID Priority Requirement Related
SIG-03-001 MUST A receiver MUST verify an activity's proof before it acts on any of the activity's content.

Content acted on before verification has already been trusted: a forged activity could change state, be stored or be relayed before its refusal. Verifying first means a refused activity leaves nothing behind.
SIG-03-002 MUST A receiver MUST refuse an activity whose proof is missing or does not verify.

Verification that admits an unsigned activity protects nothing, since a forger simply leaves the proof out. The refusal holds in every deployment, test and demo: a switch that turns it off becomes the way a test passes and a deployment is left open.
Depends on: SIG-03-001
Proofs in the Case Ledger
ID Priority Requirement Related
SIG-04-001 MUST The CASE_MANAGER MUST keep the sender's proof, unchanged, in the payloadSnapshot of the ledger entry that records a received activity.

A replica acts on a participant's words that the CASE_MANAGER delivers. Only the participant's own proof, kept in the snapshot, lets the replica check that the participant wrote them; a snapshot without it asks the replica to trust the CASE_MANAGER for what another actor said. The snapshot is the activity as received (VM-08-003), so dropping the proof would also change it.
SIG-04-002 MUST A replica MUST refuse the whole Add(CaseLedgerEntry) when a proof it needs is missing or fails to verify. These are the CASE_MANAGER's proof on the Announce and, when the payloadSnapshot's actor is not the CASE_MANAGER, the author's proof on the snapshot.

The CASE_MANAGER's proof shows the entry came from the case's authority; the author's proof shows the participant wrote the act the entry records. Applying the entry on either alone would let a forged act enter the case through a genuine relay, or a genuine act be replayed by a forger. Refusing the whole entry keeps the replica's ledger a prefix of the CASE_MANAGER's.

Encryption

Requirements for encrypted messaging and actor key management using ActivityPub extension conventions. Ensures that sensitive vulnerability information can be protected in transit between actors.

Key Management
ID Priority Requirement Related
ENC-01-001 MUST Not yet in the reference implementation (tracked by #1184)

Each actor MUST generate a unique asymmetric key pair when its identity is first provisioned.

Key material binds to an actor identity, not to a case. An actor that enacts CVDRole.CASE_MANAGER for several cases uses one key pair for all of them, so per-case key separation is a consequence of deployment topology rather than a key-binding rule. Regenerating a key pair would invalidate any peer's cached public key and break encrypted communication mid-case. See notes/encryption.md for the topology discussion.
ENC-01-002 MUST Each actor MUST publish its public key in its actor profile as a Multikey listed under assertionMethod.

Peers need an actor's public key to verify the proofs it signs (SIG-02-001). assertionMethod is where an FEP-8b32 verifier looks for the key a proof's verificationMethod names, so no separate key-exchange channel is needed.
ENC-01-004 MUST Not yet in the reference implementation (tracked by #1184)

An implementation MUST store each private key securely.

Anyone who obtains an actor's private key can read messages encrypted to it, including embargoed vul details, and can forge activities in its name.
ENC-01-007 MUST NOT An implementation MUST NOT write a private key to a log or include one in an API response.

Logs and API responses are copied and retained widely, so a key that appears in them must be treated as disclosed. A prototype's seeded key makes no security claim, but code that leaks it would leak a production key the same way.
Extends: ENC-01-004
ENC-01-005 MUST Not yet in the reference implementation (tracked by #1184)

An actor's asymmetric key pair MUST be persisted and reused across process restarts for the lifetime of that actor identity.

Regenerating on restart would invalidate any peer's cached public key and break encrypted communication mid-case.
Extends: ENC-01-001
ENC-01-006 MUST NOT Not yet in the reference implementation (tracked by #1184)

A new key pair MUST NOT be generated on process resumption for an existing actor identity.

Generating a new key pair on restart breaks any encrypted channel established with the previous key, invalidating cached public keys held by case participants.
Extends: ENC-01-001
Message Encryption
ID Priority Requirement Related
ENC-02-001 MAY Case participants MAY encrypt messages sent to the CASE_MANAGER using an encryption key the CASE_MANAGER publishes in its actor profile.

Messages to the CASE_MANAGER can carry embargoed vul details that intermediaries must not read in transit. Encryption is optional because transport security can be enough for a deployment and no encryption scheme is yet standardized (ENC-02-002).
Refines: VP-15-004
ENC-02-002 SHOULD Not yet in the reference implementation (tracked by #5388)

When sending messages to case participants, the CASE_MANAGER SHOULD encrypt each outbound message individually to an encryption key the recipient publishes in its actor profile.

The specific encryption scheme (e.g., ECDH key agreement + AES-256-GCM, RSA-OAEP) is intentionally deferred pending a protocol-level agreement. Until a scheme is standardized, the choice is implementation-defined; interoperability between independently-built implementations is not yet a requirement.
Refines: VP-15-004

14.8 Inherited Requirements

These are the rules Vultron inherits from the standards beneath it: ActivityStreams 2.0 (AS2), ActivityPub, and the Hypertext Transfer Protocol (HTTP). They cover addressing and delivery, HTTP status codes, and rules that only restate AS2, such as every object ID being an Internationalized Resource Identifier (IRI). Where Vultron asks for one form among several that a standard allows, the rule is a Vultron requirement on one of the pages before this one, not an inherited one.

Vocabulary Model

Requirements governing how ActivityStreams 2.0 vocabulary types are defined, registered, configured, and deserialized in the Vultron wire layer. The vocabulary model is the foundation of the inbound pipeline: every activity must be deserialized into a known vocabulary type before semantic extraction can assign it a domain meaning.

Serialization Rules
ID Priority Requirement Related
VM-07-002 MUST Serialized messages MUST use the ActivityStreams 2.0 property names, which are camelCase, never another spelling such as Python snake_case field names.

ActivityStreams 2.0 defines its property names in camelCase, and the Vultron context defines the Vultron properties in the same form. A receiver that reads a message by those names does not find a snake_case key, so the value is lost. Using the defined names is what lets another implementation read the message.

Message Validation

Requirements for validating ActivityStreams 2.0 activities at the inbox handler boundary, covering ActivityStreams structure and semantic validation. Invalid activities are rejected with appropriate error responses before dispatch.

Activity Structure Validation
ID Priority Requirement Related
MV-01-001 MUST Incoming payloads MUST conform to ActivityStreams 2.0 structure

Vultron messages are ActivityStreams 2.0 activities. Thus a payload that is not a correct AS2 activity has no defined meaning for the receiver. When the parser refuses the payload, the malformed input does not get to semantic extraction or to the handlers. These stages can then rely on the AS2 structure.
URI Validation
ID Priority Requirement Related
MV-05-001 MUST The system MUST validate that ID and reference fields contain valid URIs

ActivityStreams 2.0 gives every id and every reference as an IRI, so a value that is not one is not a well-formed activity. Vultron inherits the rule.

Semantic Extraction

The inbox handler extracts semantic meaning from ActivityStreams activities by matching activity type and object type patterns. This semantic type determines which handler function processes the activity.

Pattern Matching
ID Priority Requirement Related
SE-01-002 MUST A receiver MUST cope with an object given either inline or as a URI reference, as ActivityStreams 2.0 allows.

ActivityStreams 2.0 lets a sender give an object inline or by its URI, and conforming peers use both forms. If a receiver accepts only one form, it refuses or misreads correct messages from those peers.

Actor Knowledge Model

Defines the Actor Knowledge Model: a Vultron Actor's knowledge of the world is strictly bounded by the ActivityStreams 2.0 activities it has received. Actors must not assume recipients hold objects that were not explicitly included in prior activities; DataLayer access is private and non-shareable, and all inter-Actor communication occurs exclusively through the AS2 wire protocol.

Actor Addressing and Resolution
ID Priority Requirement Related
AKM-05-001 MUST NOT The absence of a local record of a peer actor MUST NOT prevent an actor from addressing an outbound activity to that peer. The peer's deliverable http(s) URI is sufficient for addressing; a fully resolved actor record is an enrichment (directory service), not a precondition for protocol participation.

An actor often first learns of a peer only as a URI, for example in a recommendation or a report. If addressing required a local record, the actor could not invite or answer that peer until a directory had been consulted, which would make a directory service a precondition for taking part in a CVD case.

Code Style Specifications

Defines code formatting, import organization, and coding style standards for Python code in the Vultron project.

Datetime and Timezone Conventions
ID Priority Requirement Related
CS-13-006 MUST Wire-format datetime fields MUST serialize as RFC 3339 date-times with an explicit offset, so no naive or offset-free value reaches the wire.

ActivityStreams 2.0 requires every date-time value to follow the RFC 3339 date-time form, in which the offset is mandatory. A peer cannot read a value without an offset as one instant, so it cannot compare it with other times. CS-13-005 holds Vultron's rules on which offset a timestamp carries.

Idempotency

Requirements for handling duplicate activity submissions gracefully, ensuring repeated identical requests produce the same outcome without unintended side effects.

Activity ID Uniqueness
ID Priority Requirement Related
ID-01-001 MUST All activities MUST have globally unique id field (URI)

ActivityPub requires every object, activities included, to carry a unique global identifier; ActivityStreams 2.0 alone leaves id optional. Duplicate detection (ID-02) relies on it.

Object ID

Requirements for the format and handling of object identifiers throughout the Vultron system. Establishes full-URI IDs as the canonical form for all ActivityStreams objects and DataLayer records.

ID Format
ID Priority Requirement Related
OID-01-001 MUST All ActivityStreams object IDs MUST use full URI form

ActivityPub requires every object it distributes to carry a publicly dereferenceable URI as its identifier, which a relative or bare identifier is not. ActivityStreams 2.0 alone only says relative references SHOULD NOT be used. Vultron inherits the ActivityPub rule.
OID-01-002 MUST IDs MUST be unique within the issuing actor's deployment; cross-deployment uniqueness is achieved by requiring full URI form (OID-01-001) with a deployment-controlled authority component.

Restates ActivityPub's identifier rule: an object's URI has an authority belonging to the server that originated it, so that server keeps it unique and uniqueness across deployments follows from the full URI form.
See also: OID-01-001 — context for the reader

Response Format

The Vultron protocol uses ActivityStreams activities for both requests and responses. When handlers process inbound activities, they generate response activities (Accept, Reject, Update, etc.) sent to the originating actor or other participants.

Response Activity Structure
ID Priority Requirement Related
RF-01-001 MUST Response activities MUST conform to ActivityStreams 2.0

Responses travel through the same AS2 inbox pipeline as every other activity. A response that does not conform to AS2 cannot be parsed or matched to a semantic by its receiver, so the initiator would never learn the answer.
Response Delivery
ID Priority Requirement Related
RF-06-001 MUST Response activities MUST be delivered to the relevant actors' inboxes

ActivityPub delivers every activity to the inboxes of its addressees; a response is no exception. Which actor a response goes to is Vultron's rule (RF-06-002).

HTTP Protocol Requirements

HTTP protocol requirements for the Vultron API, covering status codes, headers, and content negotiation.

Content-Type Validation
ID Priority Requirement Related
HTTP-01-002 MUST Inbox endpoint MUST accept application/ld+json; profile="https://www.w3.org/ns/activitystreams" Content-Type

This is the media type ActivityPub names for delivery to an inbox. Vultron inherits the rule rather than defining it.
HTTP-01-003 MUST Not yet in the reference implementation (tracked by #4666)

Inbox endpoint MUST reject requests with invalid Content-Type using HTTP 415

HTTP defines 415 Unsupported Media Type as the answer to a request whose content is in a format the target resource does not support.
Implements: IE-03-001
HTTP Status Codes

The status codes HTTP itself defines for each outcome, which Vultron inherits (foundation, http). Where HTTP leaves the choice open, as with 422 for a schema failure, the code is this codebase's choice and the spec is project.

ID Priority Requirement Related
HTTP-03-001 MUST The API MUST return 200 OK for successful reads.

Standard HTTP success code for GET and other read operations.
HTTP-03-003 MUST The API MUST return 202 Accepted for queued processing.

Indicates the request was accepted but processing is deferred to a background job.
HTTP-03-004 MUST The API MUST return 400 Bad Request for malformed input.

Signals that the client submitted a syntactically invalid request that cannot be parsed.
HTTP-03-005 MUST The API MUST return 404 Not Found for missing resources.

Indicates the requested resource does not exist in the system.
HTTP-03-006 MUST The API MUST return 405 Method Not Allowed for unsupported methods.

Informs the client that the HTTP method used is not supported on this endpoint.
HTTP-03-007 MUST Not yet in the reference implementation (tracked by #4596)

The API MUST return 413 Content Too Large for oversized payloads.

Rejects requests exceeding the configured payload size limit (see HTTP-02-001).
HTTP-03-008 MUST Not yet in the reference implementation (tracked by #4666)

The API MUST return 415 Unsupported Media Type for invalid Content-Type.

Rejects requests whose Content-Type header is not an accepted media type (see HTTP-01-003).
HTTP-03-010 MUST Not yet in the reference implementation (tracked by #4667)

The API MUST return 429 Too Many Requests for rate-limit violations.

Signals that the client has exceeded the permitted request rate and must back off.
HTTP-03-011 MUST The API MUST return 503 Service Unavailable when it is temporarily unable to handle a request, such as while overloaded, under maintenance, or before the storage it needs is ready.

HTTP defines 503 for a server that is temporarily unable to handle the request because of overload or scheduled maintenance, a condition expected to clear after some delay. Vultron inherits that rule. A transient error inside a request the server could handle is not that condition, so it does not draw this code.

Inbox Endpoint

The inbox endpoint is the primary entry point for actor-to-actor communication in Vultron. It receives ActivityStreams activities via HTTP POST, validates them, and queues them for asynchronous processing.

Endpoint Configuration
ID Priority Requirement Related
IE-02-001 MUST The endpoint URL MUST be discoverable from actor profile

ActivityPub requires every actor object to carry its inbox property, so a peer finds the endpoint from the profile rather than by a URL convention, which also leaves each deployment free to place it.
IE-02-002 MUST The endpoint MUST accept activities delivered to it by HTTP POST.

ActivityPub delivers an activity to an inbox by HTTP POST. Vultron inherits the rule. That POST is the only method the inbox serves is this codebase's choice (IE-02-005).
IE-02-003 MUST The endpoint MUST reject non-POST requests with HTTP 405

The inbox is a delivery target, not a collection other actors may read: ActivityPub grants an inbox read only to the actor's own authenticated owner, and Vultron has no authentication, so a GET here would expose another actor's activities. The 405 covers both trailing-slash forms, and it does not fall out of having no GET route: the profile route is a path catch-all (/{actor_id:path}) that answers 404 to an unrouted GET, so the inbox path needs its own method refusal declared ahead of it.
Refines: HTTP-03-006
Satisfies: IE-02-005
Request Handling
ID Priority Requirement Related
IE-03-001 MUST Not yet in the reference implementation (tracked by #4666)

The endpoint MUST validate Content-Type header

The Content-Type header tells the receiver how to read the body. A body sent as another media type may not be an ActivityStreams document. If the inbox checks the header first, it can refuse such a body with a clear answer (HTTP-01-003) before it parses the body.
IE-03-003 MUST Not yet in the reference implementation (tracked by #4596)

Requests exceeding the maximum request body size MUST be rejected with HTTP 413.

Rejecting oversized payloads with an explicit 413 prevents resource exhaustion and signals the limit violation to the sender.
Implements: IE-03-002
Refines: HTTP-03-007
Error Responses
ID Priority Requirement Related
IE-07-001 MUST The endpoint MUST answer with the status code HTTP defines for each transport failure: HTTP 400 for a malformed request, HTTP 405 for a method other than POST, and HTTP 413 for a request body over the size limit.

HTTP defines these status codes for these failures. Any peer with an HTTP client understands them without knowledge of Vultron, so the inbox uses them as HTTP defines them.
Refines: HTTP-03-004
Refines: HTTP-03-006
Refines: HTTP-03-007

Outbox

Requirements for actor outboxes, which hold response activities generated by handlers. Covers outbox structure, population, delivery, local and federated dispatch, idempotency, outbound reference dehydration, and outbox addressing rules.

Outbox Population
ID Priority Requirement Related
OX-02-002 MUST Each outbox activity MUST conform to ActivityStreams 2.0 structure

Recipients are ActivityStreams 2.0 (AS2) and ActivityPub peers. A peer routes a body by its AS2 type, and it reads the terms of the body through @context. A body without that structure does not mean anything to the recipient.
Outbox Delivery
ID Priority Requirement Related
OX-03-001 MUST Activities in an actor's outbox MUST be delivered to recipient inboxes

ActivityPub's delivery rule: a server posts each activity in an actor's outbox to the inbox of every addressee. Vultron inherits it.

Agentic Readiness

Requirements for API and CLI design that enable reliable interaction by automated agents and AI systems. Covers machine-parseable interfaces, structured response formats, and observable behavior that supports agentic workflows.

Actor Discovery Profile
ID Priority Requirement Related
AR-10-002 MUST The profile endpoint MUST return HTTP 404 when the actor is not found

HTTP defines 404 Not Found as the answer to a request for a resource the server does not have (HTTP-03-005). Vultron inherits the rule.

15. IANA and Namespace Considerations [N/I]

Vultron vocabulary namespace. The Vultron ActivityStreams 2.0 (AS2) vocabulary namespace is https://certcc.github.io/Vultron/ns. This is the initial, provisional Uniform Resource Identifier (URI), hosted on GitHub Pages. A permanent URI registration (for example, via a w3id.org redirect) is planned for a future version of this specification. See ADR-0069.

JSON-LD context document. The normative JavaScript Object Notation for Linked Data (JSON-LD) context is identified by https://certcc.github.io/Vultron/ns/context.jsonld. Every outbound Vultron message lists this URI in its @context, after the AS2 namespace (§5.2 Serialization):

Requirements

ID Priority Requirement Related
VM-10-001 MUST Outbound Vultron wire messages MUST set the top-level @context to exactly the list ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld"], AS2 first, or, for a signed message (SIG-01-001), to exactly ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld", "https://w3id.org/security/data-integrity/v2"]: the data-integrity context is the third and final entry, and no other context is added.

Derived from ADR-0069 (docs/adr/0069-vultron-namespace-uri.md). AS2 Core §2.1 asks every producer to reference the ActivityStreams namespace in @context, and an AS2 receiver that does not process JSON-LD, as most ActivityPub software does not, recognizes a message by finding that exact string. The Vultron context declares the CVD-specific types (VulnerabilityCase, EmbargoEvent, etc.) that the ActivityStreams namespace does not. The Vultron context document also imports AS2, but a receiver need not dereference it (VM-10-003), so citing the Vultron URI alone hides the AS2 reference from a plain-JSON receiver.
Uses definition from: SIG-01-001

That URI does not currently dereference. The context document is withheld from publication until it is served at the wire-versioned path that ADR-0106 defines. At this version the namespace is therefore a stable identifier, not a retrievable document. A receiver processes a message without fetching it:

Requirements

ID Priority Requirement Related
VM-10-003 MUST NOT A receiver MUST NOT require dereferencing the Vultron JSON-LD context URI (VM-10-001) to process a message.

A receiver reads Vultron's compact JSON form and needs no JSON-LD expansion, so the context URI is an identifier, not an input. A fetch per message would also make processing depend on the network and on the host serving the context. Today the URI does not resolve at all: the context document is withheld until it is served at the wire-versioned path ADR-0106 defines, so a receiver that fetched it would fail on every sender's message.
Uses definition from: VM-10-001

AS2 extension type naming conventions. Vultron type names follow PascalCase without an as_ prefix in wire output (for example, "type": "VulnerabilityCase" rather than "type": "as:VulnerabilityCase"). The Vultron JSON-LD context declares all type names. A message still lists the AS2 namespace before the Vultron context URI in its @context, because a receiver need not fetch the Vultron context to learn that it imports AS2 (§5.2 Serialization).

IANA registration. No new IANA registrations are required by the current version of this specification. If the Vultron namespace moves to a standards-track document, an IANA media type registration for the Vultron JSON-LD profile may be appropriate at that time.


16. Security Considerations [N/I]

16.1 Trust Model

Actor identity. The protocol uses actor URIs as process identifiers. An actor URI is the identity anchor for all messages sent by that actor, and for the canonical case ledger if the actor holds the CASE_MANAGER role. Actor URI equality is identity equality:

Requirements

ID Priority Requirement Related
OID-01-010 MUST A receiver MUST treat two messages whose actor URIs are equal once a trailing slash is removed from each as coming from the same actor.

Actor ids are full URIs (OID-01-001), and two implementations that disagree on which messages share an actor disagree on who did what. The equality is the one a receiver normalises to (OID-01-006). This rule states identity, not trust: whether a message really comes from the actor it names is the signing work (ADR-0164). Revisit it when signing lands, in case identity should follow the signing key.
Uses definition from: OID-01-001

The rule states identity, not trust. Whether a message really comes from the actor that it names is the work of the signatures below.

Verification. An actor signs each activity that it sends with a proof inside the activity, in the FEP-8b32 eddsa-jcs-2022 form (SIG-01-001, SIG-01-002). A receiver refuses an activity whose proof is missing or does not verify (SIG-03-002). The receiver gets the key from the actor profile of the author, and from no other source (SIG-02-001).

The proof stays in the activity when the CASE_MANAGER relays it or records it in the case ledger. A replica can thus check who wrote each ledger entry that it applies (SIG-04-001, SIG-04-002). HTTP Message Signatures on each delivery are not required; a production deployment can add them to authenticate the server that delivers a request. The reference implementation signs each activity that it sends, and its inbox refuses an activity whose proof is missing or does not verify.

Case bootstrap as the trust establishment mechanism. The Create(VulnerabilityCase) message that the report receiver sends to the reporter as itself is the trust root for a case (§10.3 Case Bootstrap and the Trust Root). Late joiners receive a case snapshot and prior ledger entries from the CASE_MANAGER. A late joiner trusts the CASE_MANAGER's delivery because it trusts the invitation that named the CASE_MANAGER. This chain is the minimal trust model; cryptographic ledger integrity (hash-chaining) provides tamper detection.

See also

16.2 Embargo Integrity

Protocol adherence. An active embargo is an agreement, not a technical enforcement. The protocol provides the signaling infrastructure — Participant Embargo Consent (PEC) state tracks which participants have consented, §9.5 Embargo Traffic Reaches Non-Signatories ensures all participants receive meta-protocol messages — but it cannot prevent a participant from disclosing outside the protocol.

Defection. If a participant discloses publicly while an embargo is ACTIVE, the CP (public awareness) message will trigger the embargo teardown cascade (§11.3 Status Adoption: One Authorization Gate). The teardown is a state machine consequence, not a penalty mechanism. The protocol has no built-in penalty for defection; enforcement is an out-of-band organizational matter.

Confidentiality gate. Sensitive case content is gated on embargo consent (§9.7 Gating Full Case Delivery). While an embargo is in force, a participant that is not a signatory to it, because its consent row for that embargo is not AGREED, does not receive full case details. This is the primary technical lever the protocol provides against inadvertent over-disclosure to non-consenting parties.

16.3 Replay and Idempotency

Message deduplication. Each ActivityStreams Activity carries a unique id, so a receiver can recognize a message it has already processed. Duplicate delivery does not change state.

Ledger idempotency. The canonical case ledger is append-only and hash-chained. A re-delivered Add(CaseLedgerEntry) adds no second entry, and replaying entries a receiver already holds changes nothing. The ledger NAK path (Reject(CaseLedgerEntry)) and gap-fill replay provide recovery from missed entries. A participant's Read(<case>/ledger) position statement recovers a missed last entry, which no later entry exposes as a gap; the CASE_MANAGER answers it only from an active participant (SYNC-17-002). The one exception is the resend of the Invites a participant still on the roster owes an answer to: an Invite carries no withheld case content, so an inert participant is resent its Invites too (SYNC-20-001).

Requirements

ID Priority Requirement Related
ID-01-001 MUST All activities MUST have globally unique id field (URI)

ActivityPub requires every object, activities included, to carry a unique global identifier; ActivityStreams 2.0 alone leaves id optional. Duplicate detection (ID-02) relies on it.
SYNC-03-003 MUST NOT A receiver MUST NOT add a duplicate entry to its log when the same log entry is delivered again, so that replication is idempotent.

The outbox retries and replays send entries again, so a receiver often gets one entry more than once. A duplicate in the log would break the gapless index and the hash chain, and its effects would apply twice (ID-02-001).
SYNC-08-003 MUST NOT Idempotent replay: reprocessing any canonical recorded log prefix (including duplicates) MUST NOT change the resulting state

Replays, retries and restarts make an actor process some entries more than once. If a second pass changed the state, recovery itself would corrupt the case.

16.4 Confidentiality

In-transit protection. The protocol does not currently mandate a specific in-transit encryption mechanism. Transport Layer Security (TLS) is the expected transport protection for HTTP delivery. A future version of this specification is expected to require TLS.

Key management. Each actor generates its own unique asymmetric key pair when its identity is first provisioned. It publishes the public key in its actor profile and stores the private key securely. The key pair lasts for the lifetime of the actor identity: the actor reuses it after a process restart and does not generate a new one. A private key never appears in a log or an API response.

Requirements

ID Priority Requirement Related
ENC-01-001 MUST Not yet in the reference implementation (tracked by #1184)

Each actor MUST generate a unique asymmetric key pair when its identity is first provisioned.

Key material binds to an actor identity, not to a case. An actor that enacts CVDRole.CASE_MANAGER for several cases uses one key pair for all of them, so per-case key separation is a consequence of deployment topology rather than a key-binding rule. Regenerating a key pair would invalidate any peer's cached public key and break encrypted communication mid-case. See notes/encryption.md for the topology discussion.
ENC-01-002 MUST Each actor MUST publish its public key in its actor profile as a Multikey listed under assertionMethod.

Peers need an actor's public key to verify the proofs it signs (SIG-02-001). assertionMethod is where an FEP-8b32 verifier looks for the key a proof's verificationMethod names, so no separate key-exchange channel is needed.
ENC-01-004 MUST Not yet in the reference implementation (tracked by #1184)

An implementation MUST store each private key securely.

Anyone who obtains an actor's private key can read messages encrypted to it, including embargoed vul details, and can forge activities in its name.
ENC-01-005 MUST Not yet in the reference implementation (tracked by #1184)

An actor's asymmetric key pair MUST be persisted and reused across process restarts for the lifetime of that actor identity.

Regenerating on restart would invalidate any peer's cached public key and break encrypted communication mid-case.
Extends: ENC-01-001
ENC-01-006 MUST NOT Not yet in the reference implementation (tracked by #1184)

A new key pair MUST NOT be generated on process resumption for an existing actor identity.

Generating a new key pair on restart breaks any encrypted channel established with the previous key, invalidating cached public keys held by case participants.
Extends: ENC-01-001
ENC-01-007 MUST NOT An implementation MUST NOT write a private key to a log or include one in an API response.

Logs and API responses are copied and retained widely, so a key that appears in them must be treated as disclosed. A prototype's seeded key makes no security claim, but code that leaks it would leak a production key the same way.
Extends: ENC-01-004

The rows on key generation, storage and persistence apply to a production deployment (ENC-01-001, ENC-01-004, ENC-01-005, ENC-01-006). The reference implementation is a prototype: it publishes each actor's key and keeps private keys out of logs and API responses (ENC-01-002, ENC-01-007). It does not yet generate, store or persist a key pair: it computes each actor's key pair from a seed tied to the actor id, which makes no security claim (#1184). Known Gaps lists the key management requirements that it does not yet meet.

Per-message encryption. A case participant can encrypt the messages it sends to the CASE_MANAGER. The CASE_MANAGER is expected to encrypt each message that it sends to a case participant individually. An encrypted message is encrypted to an encryption key that the recipient publishes in its actor profile. This version does not choose an encryption scheme, so until a scheme is standardized the choice is implementation-defined.

Requirements

ID Priority Requirement Related
ENC-02-001 MAY Case participants MAY encrypt messages sent to the CASE_MANAGER using an encryption key the CASE_MANAGER publishes in its actor profile.

Messages to the CASE_MANAGER can carry embargoed vul details that intermediaries must not read in transit. Encryption is optional because transport security can be enough for a deployment and no encryption scheme is yet standardized (ENC-02-002).
Refines: VP-15-004
ENC-02-002 SHOULD Not yet in the reference implementation (tracked by #5388)

When sending messages to case participants, the CASE_MANAGER SHOULD encrypt each outbound message individually to an encryption key the recipient publishes in its actor profile.

The specific encryption scheme (e.g., ECDH key agreement + AES-256-GCM, RSA-OAEP) is intentionally deferred pending a protocol-level agreement. Until a scheme is standardized, the choice is implementation-defined; interoperability between independently-built implementations is not yet a requirement.
Refines: VP-15-004

The reference implementation does not encrypt messages yet (#5388).

Confidentiality from the CASE_MANAGER. Content-level encryption that protects case details from the CASE_MANAGER itself, or that supports future multi-party computation, is not specified by this version. The CASE_MANAGER can read all case content that it receives, so that content is accessible to whoever operates the CASE_MANAGER.

Scope. This section covers the security requirements of the protocol as specified, including the key management and per-message encryption requirements above. Operational security practice beyond those requirements is out of scope. Examples are the means a deployment uses to protect stored keys, key backup and recovery, access control, and incident response for actor compromise.


17. References

17.1 Normative References

These documents are required to implement this specification.

Reference Title
RFC 2119 Key words for use in RFCs to Indicate Requirement Levels
RFC 8174 Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words
ActivityStreams 2.0 Core Activity Streams 2.0, World Wide Web Consortium (W3C) Recommendation
ActivityStreams 2.0 Vocabulary Activity Vocabulary, W3C Recommendation
JSON-LD 1.1 JSON-LD 1.1: A JSON-based Serialization for Linked Data, W3C Recommendation
RFC 8259 The JavaScript Object Notation (JSON) Data Interchange Format
FEP-8b32 Object Integrity Proofs, Fediverse Enhancement Proposal. The form of the proof an activity carries (§16.1 Trust Model)
Data Integrity EdDSA Cryptosuites Data Integrity EdDSA Cryptosuites v1.0, W3C Recommendation. Defines the eddsa-jcs-2022 cryptosuite
RFC 8785 JSON Canonicalization Scheme (JCS). The canonical form that eddsa-jcs-2022 signs, and that a case ledger entry hash covers (§5.2 Serialization)

17.2 Informative References

These documents provide context. They are not required to implement this specification.

Reference Title
ActivityPub ActivityPub, W3C Recommendation. The anticipated transport; not required by this version (§1.3 Relationship to Existing Standards)
ISO/IEC 29147:2018 Information technology — Security techniques — Vulnerability disclosure
ISO/IEC 30111:2019 Information technology — Security techniques — Vulnerability handling processes
CERT Guide to CVD The CERT Guide to Coordinated Vulnerability Disclosure. Source of this specification's definition of vulnerability (§2.1 Actors, Participants and Cases)
CVE Program Common Vulnerabilities and Exposures (CVE) Numbering Authority operational rules, referenced at §13.4.3 CVE ID Assignment
RFC 7033 WebFinger. The anticipated participant-discovery mechanism (§5.3 Transport)
RFC 9421 HTTP Message Signatures. Optional transport authentication for a production deployment, in addition to the proof in each activity (§16.1 Trust Model)

18. Informative Annexes

The annexes below illustrate and explain the protocol. Nothing in them is normative: where an annex and a normative section appear to disagree, the normative section governs.

Annex A — Worked Example: Single-Vendor CVD [I]

This annex traces one two-party case from first contact to closure. Each step names the message sent and the state transition it reports, so the sequence can be read against the state machine sections (§6 Report Management (RM) State Machine through §9 Participant Embargo Consent (PEC) State Machine).

Four embargo outcomes are shown — accepted, rejected, countered, and accepted then revised — because embargo negotiation is where two-party cases most often diverge.

A Finder Becomes a Reporter

As we mention in RM Interactions, Finders have a few hidden state transitions before the Coordinated Vulnerability Disclosure (CVD) process really begins. The figure below shows an example. The Finder must discover, validate, and prioritize their finding before they start the CVD process.

---
title: Finder Pre-Report Steps
---
sequenceDiagram
    actor Finder
    Finder ->> Finder: Discover
    Finder ->> Finder: Validate
    Finder ->> Finder: Prioritize

Finders become Reporters when they report a vulnerability to someone else. The next figure shows a Finder that sends a report (RS) together with an embargo proposal (EP) to a Vendor. The Vendor receives the report and updates their state to match.

Then the Vendor replies with three messages. It acknowledges receipt of the report (RK) and of the embargo proposal (EK). It also confirms that the Vendor is aware of the report (CV).

The EK response confirms that the Vendor received the embargo proposal (EP). It does not accept the proposal. We discuss acceptance in the next subsection.

---
title: Finder Submits Report and Embargo Proposal
---
sequenceDiagram
    actor Finder
    actor Vendor
    Finder ->> Finder: Discover, Validate, Prioritize
    Finder ->> Vendor: RS, EP
    note right of Vendor: Report Received
    note right of Vendor: Embargo Proposed
    note right of Vendor: Vendor Aware
    Vendor -->> Finder: RK, EK, CV

Vendor Evaluates Embargo

In this section, we show a variety of responses a Vendor might have to an embargo proposal.

Vendor Accepts Embargo

First is a basic accept sequence. The Vendor accepts the proposed embargo and tells the Reporter with an EA message. The Reporter acknowledges this with an EK in response.

---
title: Vendor Accepts Embargo Proposal
---
sequenceDiagram
    actor Reporter
    actor Vendor

    Reporter ->> Vendor: EP
    note right of Vendor: Embargo Proposed
    Vendor -->> Reporter: RK
    Vendor ->> Reporter: EA
    activate Reporter
    activate Vendor
    note right of Vendor: Embargo Active
    Reporter -->> Vendor: EK
    deactivate Reporter
    deactivate Vendor
Vendor Rejects Embargo

Next we show a rejected proposal. As above, this is a simple sequence. The Vendor rejects the proposal with an ER message, and the Reporter acknowledges this with an EK message.

---
title: Vendor Rejects Embargo Proposal
---
sequenceDiagram
    actor Reporter
    actor Vendor

    Reporter ->> Vendor: EP
    note right of Vendor: Embargo Proposed
    Vendor -->> Reporter: EK
    Vendor ->> Reporter: ER
    note right of Vendor: Embargo Rejected
    Reporter -->> Vendor: EK
Vendor Counterproposal

Here we show a Vendor embargo counterproposal. The Vendor responds to the prior EP message of the Reporter with an EP message of their own. The Reporter first acknowledges the counterproposal with an RK message. Then the Reporter evaluates it and accepts it with an EA message. Finally, the Vendor acknowledges the acceptance with an EK message.

But no embargo is active until the Reporter accepts it. This method of counterproposal might delay the start of an embargo.

---
title: Vendor Counterproposal
---
sequenceDiagram
    actor Reporter
    actor Vendor

    Reporter ->> Vendor: EP
    note right of Vendor: Embargo Proposed
    Vendor -->> Reporter: RK
    Vendor ->> Reporter: EP
    Reporter -->> Vendor: RK
    Reporter ->> Vendor: EA
    activate Vendor
    activate Reporter
    note right of Vendor: Embargo Active
    Vendor -->> Reporter: EK
    deactivate Vendor
    deactivate Reporter
Vendor Accepts then Proposes Revision

Yes, And...

"Yes-And" is a heuristic from improvisational theatre. In it, Participants are encouraged to agree with what their counterpart suggests and add to it, instead of rejecting it outright. It is a good model for cooperation among parties who share an interest in a positive outcome.

Finally, the following diagram shows what we think is a better approach than a simple counterproposal. In this "Accept-then-Counter" sequence, the Vendor first accepts the embargo that the Reporter proposed. Then the Vendor immediately sends a revision proposal of their own. The difference is that the Vendor accepts the proposal first, so they are in an active embargo state before they try to renegotiate.

This sequence is intended to agree with our earlier discussion of default embargo strategies. You can think of this as the "Yes-And" rule for embargo negotiations.

---
title: Vendor Accepts then Proposes Revision
---
sequenceDiagram
    actor Reporter
    actor Vendor

    Reporter ->> Vendor: EP
    note right of Vendor: Embargo Proposed
    Vendor -->> Reporter: RK
    Vendor ->> Reporter: EA
    activate Vendor
    activate Reporter
    note right of Vendor: Embargo Active
    Reporter -->> Vendor: EK
    Vendor ->> Reporter: EV
    note right of Vendor: Embargo Revise
    Reporter -->> Vendor: RK
    Reporter ->> Vendor: EC
    note right of Vendor: Embargo Active
    Vendor -->> Reporter: EK 
    deactivate Vendor
    deactivate Reporter

Vendor Sets Priority

Here we show two responses from a Vendor in the course of prioritizing a report.

Vendor Accepts Report

This figure shows a Vendor that accepts the report for further work with an RA message. The further work is probably to develop a patch.

---
title: Vendor Accepts Report
---
sequenceDiagram
    actor Reporter
    actor Vendor

    Vendor ->> Vendor: Receive, Validate, Prioritize
    Vendor ->> Reporter: RA
    note right of Vendor: Report/Case Accepted
    Reporter -->> Vendor: RK
Vendor Defers Report

In contrast, this figure shows the Vendor as it defers the report with an RD message. In both cases, the Reporter acknowledges the Vendor's messages with an RK message.

---
title: Vendor Defers Report
---
sequenceDiagram
    actor Reporter
    actor Vendor

    Vendor ->> Vendor: Receive, Validate, Prioritize
    Vendor ->> Reporter: RD
    note right of Vendor: Report/Case Deferred
    Reporter -->> Vendor: RK

Annex B — Worked Example: Multi-Party CVD [I]

This annex extends Annex A to a case with a coordinator and a second vendor. It shows the coordinator acting as proxy for the reporter, a participant joining a case that already has an active embargo, and the teardown-publish-close sequence across three parties.

Coordination With a Coordinator

The next two diagrams show how a Reporter engages a Coordinator, and how the Coordinator then engages a Vendor. In the first diagram, the Reporter sends a report together with an embargo proposal to the Coordinator (\(RS,EP\)). The Coordinator acknowledges receipt with an \(RK,EK\) response. After it evaluates the proposed embargo, the Coordinator accepts it with an EA message. Then the Coordinator validates and prioritizes the report, and sends an RV and an RA as it does so.

---
title: Reporter Engages Coordinator
---
sequenceDiagram
    actor Reporter
    actor Coordinator

    Reporter ->> Coordinator: RS,EP
    note right of Coordinator: Report Received
    note right of Coordinator: Embargo Proposed
    Coordinator -->> Reporter: RK,EK
    Coordinator ->> Reporter: EA
    activate Coordinator
    activate Reporter
    note right of Coordinator: Embargo Active
    Reporter -->> Coordinator: EK
    Coordinator ->> Reporter: RV
    note right of Coordinator: Report Valid
    Reporter -->> Coordinator: RK
    Coordinator ->> Reporter: RA
    note right of Coordinator: Report/Case Accepted
    Reporter -->> Coordinator: RK
    deactivate Coordinator
    deactivate Reporter

Coordinator-as-proxy can be sub-optimal

In this scenario, we show the Coordinator as a proxy between the Reporter and the Vendor. This is how people practiced CVD in the past, but it is not necessarily the most efficient way to operate. CVD Platforms like VINCE show that the process can be more efficient when CVD case participants share one space.

In the next diagram, the Coordinator acts as a proxy for the Reporter. The Coordinator notifies the Vendor and sends the embargo information in an \(RS,EP\) message of its own. The Vendor agrees to the existing embargo, and then validates (RV) and prioritizes (RA) the report. The case's embargo is already active, so the Vendor's agreement is its own consent to the embargo, an Accept of the Invite, and not an EA: EA is the decision that moves the case's embargo from proposed to active. The Coordinator passes the relevant responses from the Vendor to the Reporter.

The Vendor accepted the report for further work, so the Vendor then creates a fix for the reported vulnerability. When the fix is complete, the Vendor tells the Coordinator that it is ready. The Coordinator then sends this information to the Reporter in the CF message.

---
title: Coordinator Notifies Vendor
---
sequenceDiagram
    actor Reporter
    actor Coordinator
    actor Vendor

    Coordinator ->> Vendor: RS,EP
    Vendor -->> Coordinator: RK,EK,CV
    Coordinator ->> Reporter: CV
    Vendor --> Vendor: Evaluate Embargo
    Reporter -->> Coordinator: CK
    activate Vendor
    note right of Vendor: Embargo Active
    Vendor ->> Coordinator: Accept(Invite)
    activate Coordinator
    Coordinator ->> Reporter: Accept(Invite)
    activate Reporter
    Vendor --> Vendor: Validate Report
    Coordinator -->> Vendor: EK
    Reporter -->> Coordinator: EK

    note right of Vendor: Report Valid
    Vendor ->> Coordinator: RV
    Vendor --> Vendor: Prioritize Report
    Coordinator -->> Vendor: RK

    note right of Vendor: Report/Case Accepted
    Vendor ->> Coordinator: RA
    Vendor --> Vendor: Create Fix
    Coordinator -->> Vendor: RK

    note right of Vendor: Fix Ready
    Vendor ->> Coordinator: CF
    Coordinator ->> Reporter: CF

    Coordinator -->> Vendor: CK
    Reporter -->> Coordinator: CK
    deactivate Vendor
    deactivate Coordinator
    deactivate Reporter

Embargo Teardown, Publish, and Close

Any Participant can initiate an embargo teardown. In the following diagram, we show the case where the Coordinator initiates it. The Coordinator sends an embargo termination message (ET) to all parties in the case. In this scenario, these parties are the Reporter and the Vendor. Recipients of the ET message acknowledge receipt and update their EM state to match.

Embargo Teardown, Publication, and Closure Can Start with Any Participant

For all three scenarios in this section, Participants do not have to act in a specific order. We could also show the Reporter as it initiates an embargo teardown because of a leaked media report. Or we could show the Vendor as it exits an embargo early because their fix was ready sooner than expected.

---
title: Coordinator Initiates Embargo Teardown
---
sequenceDiagram
    actor Reporter
    actor Coordinator
    actor Vendor

    Coordinator ->> Reporter: ET
    Coordinator ->> Vendor: ET
    note right of Vendor: Embargo Terminated
    Reporter -->> Coordinator: EK
    Vendor -->> Coordinator: EK

Embargo Termination is not Publication

Our protocol only sets a discrete end to the embargo. It intentionally does not address a publication schedule. After the embargo has been exited, any Participant may publish at any time.

Participants can choose to coordinate their publication schedules more closely, but the protocol does not require it. Some situations might need more concise publication scheduling. We examine this concern again in Process Implementation Notes.

Publishing After Embargo Teardown

After the embargo has been exited, any Participant may now publish. In the following figure, we show the Vendor as it publishes first. The Vendor tells the Coordinator that it has published. It uses a CP message, which says that information about the vulnerability is now public.

The Coordinator relays this information to the Reporter. Both the Reporter and the Coordinator publish their own reports shortly thereafter.

---
title: Publishing After Embargo Teardown
---
sequenceDiagram
    actor Reporter
    actor Coordinator
    actor Vendor

    Vendor --> Vendor: Publish
    note right of Vendor: Public Aware
    Vendor ->> Coordinator: CP
    Coordinator ->> Reporter: CP
    Reporter -->> Coordinator: CK
    Reporter --> Reporter: Publish
    Reporter ->> Coordinator: CP
    Coordinator ->> Vendor: CP
    Coordinator -->> Reporter: CK
    Vendor -->> Coordinator: CK
    Coordinator --> Coordinator: Publish
    Coordinator ->> Reporter: CP
    Coordinator ->> Vendor: CP
    Reporter -->> Coordinator: CK
    Vendor -->> Coordinator: CK

Report Closure is a Per-Participant Choice

Report closure is a per-Participant choice. We chose to show a simple case where all Participants agreed at approximately the same time that no more work was necessary. Participants will not always agree at the same time, and they do not have to.

Closing the Case

In the next diagram, the Reporter has no more work to do on the case. So the Reporter closes their report and tells the Coordinator with an RC message. This prompts the Coordinator to review their open tasks and decide to close their own report. Then the Coordinator relays this to the Vendor, who also closes their report.

---
title: Participants Close Their Reports
---
sequenceDiagram
    actor Reporter
    actor Coordinator
    actor Vendor

    Reporter --> Reporter: Close
    Reporter ->> Coordinator: RC
    Coordinator -->> Reporter: RK
    Coordinator --> Coordinator: Close
    Coordinator ->> Vendor: RC
    Vendor -->> Coordinator: RK
    Vendor --> Vendor: Close
    note right of Vendor: Case Closed
    Vendor ->> Coordinator: RC
    Coordinator -->> Vendor: RK

Runnable scenarios

The reference implementation ships these flows as executable scenarios, which are the most current statement of what it supports:

Annex C — Notation Reference [I]

The conventions this specification uses for state names and case-state notation are stated at §1.4 Document Conventions. This annex collects the mathematical and diagram notation used in the formal treatment, and the notation for writing a Wire Activity.

Mathematical Notation

All of these definitions assume the standard Zermelo-Fraenkel set theory. The following notation is used:

Set Theory Symbols

Symbol Meaning
\(\{ \dots \}\) depending on the context: (1) an ordered set in which the items occur in that sequence, or (2) a tuple of values
|\(x\)| the count of the number of elements in a list, set, tuple, or vector \(x\)
\(\subset,=,\subseteq\) the normal proper subset, equality, and subset relations between sets
\(\in\) the membership (is-in) relation between an element and the set it belongs to
\(\prec\) the precedes relation on members of an ordered set: \(\sigma_i \prec \sigma_j \textrm{ if and only if } \sigma_i,\sigma_j \in s \textrm{ and } i < j\) where \(s\) is an ordered set
|\(X\)| the size of (the number of elements in) a set \(X\)
\(\langle X_i \rangle^N_{i=1}\) a set of \(N\) sets \(X_i\), indexed by \(i\); used in the Formal Protocol in the context of Communicating Finite State Machines, taken from the article On Communicating Finite State Machines by Brand and Zafiropulo

Logic Symbols

Symbol Meaning
\(\implies\) implies
\(\iff\) if-and-only-if (bi-directional implication)
\(\wedge\) the logical AND operator
\(\lnot\) the logical NOT operator

Directional Messaging Symbols

Symbol Meaning
\(\rightharpoonup{}\) a message emitted (sent) by a process
\(\leftharpoondown{}\) a message received by a process

DFA Symbols

Symbol Meaning
\(\xrightarrow{}\) a transition between states, usually labeled with the transition type (e.g., \(\xrightarrow{a}\))
\((\mathcal{Q},q_0,\mathcal{F},\Sigma,\delta)\) specific symbols for individual DFA components that are introduced when needed in Chapters
\(\Big \langle { \langle S_i \rangle }^N_{i=1}, { \langle o_i \rangle }^N_{i=1}, { \langle M_{i,j} \rangle}^N_{i,j=1}, { succ } \Big \rangle\) formal protocol symbols that are introduced at the beginning of the Formal Protocol

Diagram Notation

A variety of diagramming techniques are used throughout the documentation.

State Diagrams

Depictions of DFA as figures use common state diagram symbols, as shown in the example below.

stateDiagram-v2
    direction LR
    [*] --> q0
    q0 --> q1 : a
    q0 --> q2 : b
    q1 --> q2 : a
    q1 --> q1 : b
    q2 --> q0 : a
    q2 --> q1 : b
    q2 --> [*]
Sequence and Class Diagrams

Sequence and class diagrams follow Unified Modeling Language (UML) conventions

---
title: Sequence Diagram Example
---
sequenceDiagram
    participant A as Alice
    participant B as Bob
    A ->> B: Authentication Request
    B->>A: Authentication Response
---
title: Class Diagram Example
---
classDiagram
    Class01 <|-- Class02
    Class03 *-- Class04
    Class05 o-- Class06
    Class07 .. Class08
Behavior Tree Diagrams

A few additional notation details specific to Behavior Trees are introduced when needed.

Wire Activity Notation

A Wire Activity is an ActivityStreams 2.0 (AS2) activity of a given shape. This specification and the documentation write one as Verb(Object)[field=Value].

  • Verb. The activity's own AS2 type comes first: Offer, Accept, Add.
  • Object in parentheses. The parentheses hold the type of the activity's object: Offer(VulnerabilityReport) is an Offer whose object is a VulnerabilityReport.
  • Nesting. When the object is itself an activity, the parentheses hold that activity in the same notation: Accept(Offer(VulnerabilityReport)) is an Accept whose object is an Offer of a VulnerabilityReport.
  • Bracketed fields. Brackets after an activity name its other fields that tell occasions apart, each as field=Value, with a comma between two of them. The brackets qualify the activity they follow: in Add(Note)[target=VulnerabilityCase] the target is the Add's, and in Accept(Invite(EmbargoEvent)[target=Actor, context=VulnerabilityCase]) the context is the Invite's. A value is the type the field holds, or a literal value such as a state name. Written without its brackets, as Invite(EmbargoEvent), an activity names every occasion of that shape. A field that tells no occasions apart is described in the surrounding text, not in the notation.
  • Type names. Each name is the type value the sender puts on the wire, AS2 or Vultron extension (such as EmbargoEvent), never the name of a class in an implementation. An embargo is sent with type EmbargoEvent, so the notation writes Invite(EmbargoEvent), Remove(EmbargoEvent) and Create(EmbargoEvent).
  • No addressing. The notation describes the activity's shape, not where it goes. Recipients, roles and the sender are never written in it; an occasion table gives them in its "Send to" and "Sent by" columns (Message Types).

A known defect in the reference implementation

The reference implementation currently also accepts a plain AS2 Event where an embargo is expected. This is a defect tracked in #5155, and a sender cannot rely on it.

A Wire Activity is the shape a sender puts on the wire. It does not name a formal protocol message: the Protocol Shorthand, such as RS or EP, does.

Annex D — Possible Case Histories [I]

Case State has 32 compound states, but far fewer orderings among them are reachable: a fix cannot be deployed before it is ready, and vendors learn of a vulnerability no later than the public does. Applying those constraints to the six case-state events reduces 720 naive orderings to 70 possible case histories.

This annex derives that result. It is informative: the ordering constraints themselves are stated in §8.3 Case State as a Compound Tuple, and this annex counts the histories they allow.

Sequences of Events and Possible Histories in CVD

This page is not normative

This page is not considered a core part of the Vultron Protocol as proposed in the main documentation. Although within the page we might provide guidance in terms of SHOULD, MUST, etc., the content here is not normative.

In CS Input Symbols, we began by identifying a set of events of interest in CVD cases. Then we constructed a state model describing how the occurrence of these events can interact with each other. In this section, we look at paths through the resulting state model.

Sequences of Events

Before we can discuss the possible histories of CVD, we need to define the concept of a sequence of events.

Sequences Formally Defined

A sequence \(s\) is an ordered set of some number of events \(\sigma_i \in \Sigma\) for \(1 \leq i \leq n\) and the length of \(s\) is \(|s| \stackrel{\mathsf{def}}{=}n\).

In other words, a sequence \(s\) is an input string to the DFA defined in the CVD Case State Model.

\[s \stackrel{\mathsf{def}}{=}\left( \sigma_1, \sigma_2, \dots \sigma_n \right)\]

Case Histories

CS Model Input Symbols (\(\Sigma^{cs}\)) Defined
\[\Sigma^{cs} = \{\mathbf{V},\mathbf{F},\mathbf{D},\mathbf{P},\mathbf{X},\mathbf{A}\}\]

Here we diverge somewhat from the notation used for the RM and EM models, which use lowercase letters for transitions and uppercase letters for states. Because CS state names already use both lowercase and uppercase letters, here we use a bold font for the symbols of the CS DFA to differentiate the transition from the corresponding substate it leads to: e.g., \(vfd\cdot\cdot\cdot \xrightarrow{\mathbf{V}} Vfd\cdot\cdot\cdot\).

Armed with the definition of a sequence, we can now define a history.

Vulnerability Disclosure Case History Formally Defined

A vulnerability disclosure case history \(h\) is a sequence \(s\) containing one and only one of each of the symbols in \(\Sigma\); by definition \(|h| = |\Sigma| = 6\). Note this is a slight abuse of notation; \(|\textrm{ }|\) represents both sequence length and the cardinality of a set.

\[\begin{split} h \stackrel{\mathsf{def}}{=}s : & \forall \sigma_i, \sigma_j \in s \textrm{ it is the case that } \sigma_i \neq \sigma_j \textrm{ and } \\ & \forall \sigma_k \in \Sigma \textrm{ it is the case that } \exists \sigma_i \in s \textrm{ such that } \sigma_k = \sigma_i \end{split} \]

where two members of the set \(\Sigma\) are equal if they are represented by the same symbol and not equal otherwise.

The set of all potential histories, \(\mathcal{H}_p\), is a set of all the sequences \(h\) that satisfy this definition.

The Possible Histories of CVD

Given that a history \(h\) contains all six events \(\Sigma\) in some order, there could be at most 720 (\(_{6} \mathrm{P}_{6} = 6! = 720\)) potential histories. However, because of the causal requirements outlined in CS Transitions, we know that Vendor Awareness (V) must precede Fix Ready (F) and that Fix Ready must precede Fix Deployed (D).

The DFA developed in CS Process Model provides the mechanism to validate histories: a history \(h\) is valid if the DFA accepts it as a valid input string. Once this constraint is applied, only 70 possible histories \(h \in \mathcal{H}p\) remain viable. We denote the set of all such valid histories as \(\mathcal{H}\) and have \(|\mathcal{H}| = 70\). The set of possible histories \(\mathcal{H}\) corresponds to the 70 allowable paths through \(\mathcal{Q}^{CS}\) as can be derived from the CS transition function \(\delta^{CS}\) in CS Transitions. and the diagram in Case State Model Definition.

Other Definitions Used in the Table Below

Table of Possible Histories

The set of possible histories \(\mathcal{H}\) is listed exhaustively in the table below.

# \(h \in \mathcal{H}\) rank \(\mathbb{D}^h\) count \(f_h\)
0 (A, X, P, V, F, D) 1 0 0.0833
1 (A, P, V, X, F, D) 2 2 0.0417
2 (A, V, X, P, F, D) 3 2 0.0278
3 (X, P, V, A, F, D) 4 3 0.1250
4 (V, A, X, P, F, D) 5 3 0.0208
5 (P, V, A, X, F, D) 6 4 0.0417
6 (A, V, P, X, F, D) 7 3 0.0139
7 (A, P, V, F, X, D) 7 3 0.0208
8 (X, P, V, F, A, D) 8 4 0.0625
9 (V, A, P, X, F, D) 9 4 0.0104
10 (P, V, X, A, F, D) 10 5 0.0417
11 (V, P, A, X, F, D) 11 5 0.0104
12 (P, V, A, F, X, D) 11 5 0.0208
13 (V, X, P, A, F, D) 11 5 0.0312
14 (A, V, P, F, X, D) 12 4 0.0069
15 (A, P, V, F, D, X) 13 4 0.0208
16 (V, A, P, F, X, D) 14 5 0.0052
17 (X, P, V, F, D, A) 15 5 0.0625
18 (P, V, X, F, A, D) 16 6 0.0208
19 (A, V, F, X, P, D) 17 4 0.0093
20 (V, P, X, A, F, D) 18 6 0.0104
21 (P, V, F, A, X, D) 19 6 0.0139
22 (V, X, P, F, A, D) 19 6 0.0156
23 (V, P, A, F, X, D) 20 6 0.0052
24 (V, A, F, X, P, D) 21 5 0.0069
25 (P, V, A, F, D, X) 22 6 0.0208
26 (A, V, P, F, D, X) 23 5 0.0069
27 (A, V, F, P, X, D) 24 5 0.0046
28 (P, V, F, X, A, D) 25 7 0.0139
29 (V, P, X, F, A, D) 25 7 0.0052
30 (V, A, P, F, D, X) 26 6 0.0052
31 (V, A, F, P, X, D) 27 6 0.0035
32 (P, V, X, F, D, A) 28 7 0.0208
33 (V, P, F, A, X, D) 29 7 0.0035
34 (V, F, A, X, P, D) 30 6 0.0052
35 (V, X, P, F, D, A) 31 7 0.0156
36 (P, V, F, A, D, X) 32 7 0.0139
37 (V, P, A, F, D, X) 33 7 0.0052
38 (V, P, F, X, A, D) 34 8 0.0035
39 (A, V, F, P, D, X) 35 6 0.0046
40 (V, F, A, P, X, D) 36 7 0.0026
41 (V, P, X, F, D, A) 37 8 0.0052
42 (P, V, F, X, D, A) 37 8 0.0139
43 (V, A, F, P, D, X) 38 7 0.0035
44 (V, P, F, A, D, X) 39 8 0.0035
45 (V, F, P, A, X, D) 40 8 0.0026
46 (V, F, X, P, A, D) 41 8 0.0078
47 (A, V, F, D, X, P) 42 6 0.0046
48 (P, V, F, D, A, X) 43 8 0.0139
49 (V, A, F, D, X, P) 44 7 0.0035
50 (V, P, F, X, D, A) 45 9 0.0035
51 (V, F, A, P, D, X) 46 8 0.0026
52 (V, F, P, X, A, D) 46 9 0.0026
53 (A, V, F, D, P, X) 47 7 0.0046
54 (P, V, F, D, X, A) 48 9 0.0139
55 (V, P, F, D, A, X) 49 9 0.0035
56 (V, F, X, P, D, A) 50 9 0.0078
57 (V, F, P, A, D, X) 51 9 0.0026
58 (V, A, F, D, P, X) 52 8 0.0035
59 (V, F, A, D, X, P) 53 8 0.0026
60 (V, P, F, D, X, A) 54 10 0.0035
61 (V, F, P, X, D, A) 55 10 0.0026
62 (V, F, A, D, P, X) 56 9 0.0026
63 (V, F, P, D, A, X) 57 10 0.0026
64 (V, F, D, A, X, P) 58 9 0.0026
65 (V, F, P, D, X, A) 59 11 0.0026
66 (V, F, D, A, P, X) 60 10 0.0026
67 (V, F, D, X, P, A) 61 11 0.0052
68 (V, F, D, P, A, X) 61 11 0.0026
69 (V, F, D, P, X, A) 62 12 0.0026

Now that we have defined the set of histories \(\mathcal{H}\), we can summarize the effects of the transition function \(\delta\) developed in CS Transitions as a set of patterns it imposes on all histories \(h \in \mathcal{H}\):

  1. The causality constraint of the vendor fix path must hold.
  2. The model makes the simplifying assumption that vendors know at least as much as the public does. In other words, all histories must meet one of two criteria: either Vendor Awareness precedes Public Awareness (P) or Vendor Awareness must immediately follow it.
  3. The model assumes that the public can be informed about a vulnerability by a public exploit. Therefore, either Public Awareness precedes Exploit Public (X) or must immediately follow it.

Formalizing the Constraints on Histories

Vendor Fix Path causality must hold

\[\mathbf{V} \prec \mathbf{F} \prec \mathbf{D}\]

Vendor Awareness precedes or is caused by Public Awareness

\[\mathbf{V} \prec \mathbf{P} \textrm{ or } \mathbf{P} \rightarrow \mathbf{V}\]

Public Awareness precedes or is caused by Exploit Public

\[\mathbf{P} \prec \mathbf{X} \textrm{ or } \mathbf{X} \rightarrow \mathbf{P}\]

This model is amenable for analysis of CVD, but we need to add a way to express preferences before it is complete. That is the subject of the Desirable Histories section.

See also

  • CS Transitions — the complete transition grammar the derivation above rests on

Annex E — Relationship to ActivityPub [I]

Vultron uses the ActivityStreams 2.0 vocabulary as its wire format. This version does not require full ActivityPub server behavior; the roadmap is at §1.3 Relationship to Existing Standards.

Where Vultron follows ActivityPub conventions:

  • Actors are identified by Uniform Resource Identifier (URI) and expose an inbox and an outbox.
  • Messages are Activities with type, actor, object and id.
  • Delivery is a Hypertext Transfer Protocol (HTTP) POST to the recipient's inbox.

Where Vultron adds constraints ActivityPub does not impose:

  • Case-scoped messages route through the participant holding the CASE_MANAGER role rather than directly between participants (§10.2 Routing Topology).
  • A case ledger entry's payload snapshot is the asserted activity exactly as it was sent, references included (§10.4 Ledger Replication and Case Delivery), because the entry hash covers only what the snapshot carries.
  • The Vultron vocabulary extends the ActivityStreams vocabulary with the object types of §4.3 Object Types.

Requirements

ID Priority Requirement Related
CLP-07-011 MUST The payloadSnapshot of a CaseLedgerEntry MUST be the verbatim AS2 activity that was asserted, with no field of it dropped, re-serialized, inlined, patched or merged. For an activity the CASE_MANAGER received, it is the JSON body as received (VM-08-002). For one the CASE_MANAGER emits, it is the body it delivered (VM-08-003). An activity the CASE_MANAGER sends and ledgers is one activity. So the case's genesis entry is the Create(VulnerabilityCase) it sends for the case, not a second activity built for the ledger. The metadata the CASE_MANAGER adds lives on the entry, outside the snapshot: the index, the hashes, the commit and receipt times, and the case it names in its context.

The payload snapshot is the replication substrate, and the entry hash covers it, so what it holds is what every replica treats as the event. A snapshot rebuilt from the receiver's object graph records the receiver's reconstruction, not what the sender claimed, and every rewrite is one more thing a replica must reproduce exactly to verify a hash (ADR-0107).
Uses definition from: VM-08-002
Refines: VM-08-003

See also

Annex F — Behavior Trees as an Implementation Pattern [I]

The reference implementation expresses its protocol logic as behavior trees. This is one workable pattern, not a requirement: this specification states what an implementation must do, not how to structure the code that does it. A conformant implementation may use any internal structure.

The pattern is described at Behavior Logic, and the reference implementation's trees are at vultron/core/behaviors/.

Annex G — Capability Shapes [I]

Capability shapes define optional, pluggable capabilities that connect to call-out points in the behavior engine. Capability shapes and capability sets (§13.2 Capability Sets) are independent: an implementation may provide the Case Observer capability set and no capability shapes at all.

A capability shape defines a contract — what the call-out point accepts and what it returns. A concrete implementation that satisfies the contract is a Vultron-compatible capability of that shape.

Informative: why \"shape\"

A shape is a contract, not a component and not an autonomous system. Any mechanism that satisfies the contract fits the shape: a human following a procedure, a script, a model, or a service.

G.1 The Four Capability Shapes

Four shapes cover the ways an external capability can be consulted. They differ in what they are given, what they return, and whether they change anything outside the case. All four are consulted by the protocol, and each answers within the single tick that consults it.

Shape Contract: accepts Contract: returns Notes
Evaluator A situation and a set of options A structured recommendation Its result gates downstream execution.
Retriever A query Structured facts from an external source A boolean is the simplest structured fact; a yes/no external query is a Retriever.
Composer Context A new content artifact written to the blackboard The discriminator vs. Actuator: if a content artifact lands on the blackboard, it is a Composer.
Actuator A trigger, with one target and an idempotency id derived from the act and the target Yes when the side effect is confirmed, no when it decides not to act, error when it cannot confirm Invokes an external system for a side effect. Produces no content artifact. Never repeats a side effect for an idempotency id it has acted on.

Distinguishing Composer from Actuator

Both shapes call external systems. The discriminator is whether a content artifact is written to the blackboard. If the only output is a SUCCESS/FAILURE confirming an external side effect, the shape is Actuator, not Composer.

Informative: the Sentinel pattern is not a capability shape

A Sentinel monitors a condition and acts when it fires. The protocol never consults it, so it answers no call-out point and has no contract of the kind tabled above — no accepted input, no returned value, no blackboard interaction. It is a call-in pattern, the reverse direction of every shape above.

The discriminator is who initiates, not where the information comes from. A capability is consulted and answers within the tick that asks. A Sentinel decides for itself that the moment has come. A Sentinel may well be a case Participant — typically holding the Observer role — in which case it learns case state through ordinary ledger replication and acts by sending ordinary protocol messages, with both visible to every participant. It may equally be operator-side machinery with no case identity, driving one actor through its trigger endpoints and invisible to the case. That choice is a protocol-visibility decision.

Two consequences for an implementer. A capability that answers a question the protocol asks is one of the four shapes, never a Sentinel — including one that answers only yes or no, which is a Retriever. And a Sentinel needs none of the capability-shape machinery: it needs a way to observe, a decision rule, and something to call.

G.2 Relationship to Conformance

Capability shapes are not part of the Case Observer, Case Decision or Case Hosting capability set requirements. An implementation at any capability set level may provide any number of shapes, and a conformance claim does not state which (§13.6 Capability Shapes).

A capability of a shape is one that satisfies the contract defined above. The technology used to fulfill the contract is not specified: a shape may be fulfilled by a human, an automated script, a Large Language Model (LLM), or any other mechanism.

G.3 Relationship to the Reference Implementation

In the Python reference implementation the three taxonomy levels map onto three distinct artifacts:

Level Reference-implementation artifact
Capability shape A base class that fixes the lifecycle for that shape
Capability A declaration naming the shape and the typed blackboard ports the capability reads and writes
Capability implementation A factory callable satisfying the backend Protocol, injected through a domain bundle

The intent, set by ADR-0097, is that the contract a capability declares is machine-readable and belongs to the core layer, so a substituted implementation is checked against it rather than trusted. The shape base classes and one declaration per capability live in the core layer, and each declaration names its contract as typed ports. The simulation layer's stand-in for a capability binds to that declaration rather than restating it.

This mapping is specific to the hexagonal architecture of the reference implementation. Other implementations are not required to use this structure.

See also

  • ADR-0024 (original shape taxonomy; the term "call-out point")
  • ADR-0025 (call-out point abstraction)
  • ADR-0097 (four shapes; core-declared contracts; Sentinel as a call-in pattern)
  • docs/reference/vultron-taxonomy.md

Open Questions

Each question below is unresolved at the time of issue. Every one also appears inline at the point in the specification where it first matters, so a reader meeting the gap in context sees it there rather than only here.

Open question: disputing an asserted vendor awareness

The first VFD transition — v→V, vendor becomes aware — has two drive paths. The vendor can report it for itself, and the CASE_MANAGER or the Case Owner can assert it on the vendor's behalf (§13.4.1 Participant-Specific CS Transitions (VFD)). The protocol expects evidence of the notification to ground that assertion, and the reference implementation does not check for it.

Open questions: can the subject Vendor dispute an awareness that another party asserted for it? Is transport-level delivery success, a Hypertext Transfer Protocol (HTTP) 200 response, enough evidence for the assertion?

Do not infer a rule from this document's silence.

Open question: what a sender does after a processing fault

Error message types (RE, EE, CE) are deliberately unmodeled (ADR-0049). An actor that cannot process an inbound activity from an authenticated sender reports it with Create(ProcessingFault) (ASK-07-001). The fault names the failed activity and a failure class, and its receiver rules are specified (§4.11 Faults and Acknowledgments, ASK-07). On the sending side, a fault about an outstanding ask closes that ask (ASK-07-007). A fault about an embargo message calls for an inquiry (VP-11-005), and so does a fault about a report-management or case-status message that does not say what went wrong (RMB-07-001, CSB-07-001).

Open: whether the sender resends the failed activity, drops it, or escalates to a person, and whether that choice depends on the failure class. Until this is settled, that choice belongs to each implementation.

Open question: which HTTP responses a receiving actor returns

This version does not say which HTTP status code a receiving actor returns when it refuses a message. For example, it does not say whether an invalid activity gets 422, an activity addressed only to other actors gets 400, or a message that cannot be decrypted gets 400.

One option is for the protocol to specify these responses, so that a sending actor can rely on them and act on them. The other is to leave them to each server implementation. A Vultron actor built on a stock ActivityPub server returns whatever that server returns, so a protocol rule could conflict with the server it runs on.

Until this is settled, these codes are recorded as the reference implementation's choices, not as protocol requirements. The codes that HTTP itself defines, such as 405 for an unsupported method and 413 for a body that is too large, are not part of this question.

Open question: acquiring a role after joining a case

This specification says how the Case Owner offers a role to a participant, and how the participant accepts or declines the offer. It does not say how a participant already in a case asks for an additional one.

A participant admitted as a Vendor that later also needs the Coordinator role has no protocol path to request it. In practice the request is made out of band, or as an Add(Note) on the case, and the Case Owner then issues a role offer. Neither is a specified mechanism.

Open: whether the protocol should define a role-request activity, whether a participant may give up a role it already holds, and how a role that is removed rather than added is represented in the case history.

Open question: may the Case Owner delegate activating an embargo to the CASE_MANAGER?

Activating a proposed embargo is the Case Owner's decision for the case. The owner sends Add(EmbargoEvent) with target naming the VulnerabilityCase, and inReplyTo naming the Invite(EmbargoEvent) that proposed it. Ending an embargo can already be delegated: the CASE_MANAGER may send the Remove(EmbargoEvent) on the owner's behalf. Activation has no such path.

What is settled is how the owner's own answer bears on any activation. The owner's Accept(Invite(EmbargoEvent)) or Reject(Invite(EmbargoEvent)) is its consent as a participant, and its decision for the case never rewrites that answer. An owner that declined a proposal accepts it before it activates it. So if activation is ever delegated, only an owner that has accepted the proposal can authorize the CASE_MANAGER's Add.

Open: whether the owner may delegate activation at all; how a delegation is expressed on the wire, for example as part of the owner's published embargo policy or as an instruction for one case; and whether the CASE_MANAGER's Add names the owner's Accept or the proposal's Invite in inReplyTo. Once a resolution is reached, it will be reflected in this reference and in the embargo message requirements.