Skip to content
Reference

Protocol Specification Known Gaps

This page lists each protocol and foundation requirement of the Vultron Protocol Specification that the tests do not show the main branch of the reference implementation fully meets. It is generated from the tests on main, so it cannot fall behind them. When the tests show that main meets all of a requirement, the requirement leaves this page.

The page has three sections. The first lists the requirements that a test shows main does not yet meet, with the issues that track the work. Their rows in the Requirements Catalog, and every callout of them, carry the marker "Not yet in the reference implementation". The second lists the requirements that main meets only in part. Some of their tests pass, but at least one test is held as an expected failure or a skip, and the section names the issues that track the held part.

The third section lists the requirements that no test checks. A requirement in the third section is not known to be missing from main: no test shows main does it.

The page describes the reference implementation, not the protocol. For the questions that the specification itself leaves unresolved, see Open Questions. Each requirement links to its row in the Requirements Catalog.

Requirements a test shows main does not yet meet

Each requirement below has tests, and every one of them is held by a strict expected failure (xfail) or a skip. So a test shows that main does not yet meet the requirement. The requirements are grouped by the issues that the held tests cite.

Tracked by #1184

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-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

Tracked by #2883

Requirements

ID Priority Requirement Related
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.
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-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-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.
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

Tracked by #2883 and #3918

Requirements

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

Tracked by #2884

Requirements

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-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.

Tracked by #2884 and #3918

Requirements

ID Priority Requirement Related
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

Tracked by #2885

Requirements

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-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

Tracked by #2887

Requirements

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

Tracked by #2889

Requirements

ID Priority Requirement Related
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-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

Tracked by #2890

Requirements

ID Priority Requirement Related
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

Tracked by #3355

Requirements

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.

Tracked by #3659

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

Tracked by #3698

Requirements

ID Priority Requirement Related
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

Tracked by #3702

Requirements

ID Priority Requirement Related
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

Tracked by #4241 and #4242

Requirements

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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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
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-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.

Tracked by #4596

Requirements

ID Priority Requirement Related
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).
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

Tracked by #4666

Requirements

ID Priority Requirement Related
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-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).
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.

Tracked by #4667

Requirements

ID Priority Requirement Related
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.

Tracked by #5388

Requirements

ID Priority Requirement Related
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

Tracked by #5636

Requirements

ID Priority Requirement Related
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

Tracked by #5637

Requirements

ID Priority Requirement Related
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.

Tracked by #6236

Requirements

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-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-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).

Tracked by #6237

Requirements

ID Priority Requirement Related
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-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-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.

Tracked by #6241

Requirements

ID Priority Requirement Related
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.

Tracked by #6465

Requirements

ID Priority Requirement Related
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

Requirements a test shows main meets only in part

Each requirement below has tests that pass and at least one test that is held by a strict expected failure (xfail) or a skip. So the tests show that main meets part of the requirement, but not all of it. The requirements are grouped by the issues that the held tests cite.

Tracked by #2884

Requirements

ID Priority Requirement Related
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.

Tracked by #3698

Requirements

ID Priority Requirement Related
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

Tracked by #3918 and #3964

Requirements

ID Priority Requirement Related
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).

Tracked by #6295

Requirements

ID Priority Requirement Related
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-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
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

Tracked by #6411

Requirements

ID Priority Requirement Related
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

Tracked by #6413

Requirements

ID Priority Requirement Related
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).
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.

Tracked by #6465

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-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

Requirements no test checks

For each requirement below, no test shows main does this. No test is marked for the requirement, so the test suite says nothing about whether main meets it. It does not mean that main lacks the behavior. The requirements are grouped by their Requirements Catalog page.

Vultron Protocol

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.
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-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-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-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.
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-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-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-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-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-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.
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.
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-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.
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-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.
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-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-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-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.
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-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-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
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-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-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-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-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.
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.
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.
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

Messages and Vocabulary

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-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.
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
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-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.
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).
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-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.
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.

Report, Embargo and Case State Behavior

Requirements

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-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-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-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-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
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
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
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

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-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

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-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
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-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.
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.
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-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
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.
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-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
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
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-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-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
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
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
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
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
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
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
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
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.
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
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
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
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
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
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
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
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-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-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
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
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
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
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-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

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
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.

Case Management

Requirements

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.
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-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-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
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-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-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-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.
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-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-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-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-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-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
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-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
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-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-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-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-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
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-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
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-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-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
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-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-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-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-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
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
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.

Case Ledger and Replication

Requirements

ID Priority Requirement Related
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-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
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-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.
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-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-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-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.
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-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-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.
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.
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-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-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-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).
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-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-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.
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-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-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-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-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
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.
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.
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-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-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-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-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-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

Message Processing

Requirements

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).
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.
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-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-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.
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
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.

Transport and Security

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
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.

Inherited Requirements

Requirements

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.
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
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).