Coordination, Interactions, and Lifecycle
This page is normative
This page is considered a core part of the Vultron Protocol. This is a normative section of the documentation.
The whole specification on one page
The specification is also published as a single page that holds every section and annex in order, for printing or for searching the whole text at once.
This page holds sections 10 to 12 of the Vultron Protocol Specification: how the CASE_MANAGER coordinates a case, the cascade rules that couple the state machines, including the Case State (CS) dimensions, and the lifecycle of a participant within a case.
10. Case Coordination [N]
Every case has a CASE_MANAGER.
The CASE_MANAGER is a protocol role (CVDRole.CASE_MANAGER), and a participant holds it from case creation onward.
The participant that holds it may be the actor that created the case, or an actor that the case's creator delegated case maintenance to.
This section names the authority the CASE_MANAGER: whichever participant holds the role for the case (§2.2 Roles).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-02-014 |
MUST | A VulnerabilityCase MUST have both a CASE_OWNER participant and a CASE_MANAGER participant from the moment of creation onward. Neither slot may be left empty or deferred to a later operation. Role delegation transfers the CASE_MANAGER role without a gap.An empty CASE_OWNER or CASE_MANAGER slot leaves every role check without an answer from the moment the case exists, and a case created without either has no participant entitled to repair it (ADR-0088). Both creation paths register a CASE_MANAGER: a dedicated CASE_MANAGER actor (ADR-0041), or the creating actor holding both roles. With a CASE_MANAGER always present, every case-scoped message has the CASE_MANAGER to go through (PCR-08-001). |
Extends: CM-02-001 |
CM-24-014 |
MUST | An actor that finds no CASE_MANAGER for a case MUST fail the act, never sending the activity directly to another participant instead (CM-24-008). An actor that finds no CASE_MANAGER reads a corrupt roster, since a case always has one (CM-02-014). A direct send to a participant would bypass the ledger and the recipient rules (PCR-08-001). It would also hide the corruption behind an apparent success. A failed act shows the corruption (ADR-0113). |
This section specifies what the CASE_MANAGER does for its case. It is the only writer of the case's shared state (§10.1 Single-Writer Authority), and every case-scoped message passes through it (§10.2 Routing Topology). The case-creation message is the root of every participant's trust in it (§10.3 Case Bootstrap and the Trust Root). It replicates the case ledger to every active participant and delivers the case to each new one (§10.4 Ledger Replication and Case Delivery). It also decides which participants' claims become the case's canonical status (§10.5 Claims and Canonical Status).
The cascades that the CASE_MANAGER runs when one state machine's transition obliges another are specified at §11 Model Interactions and Cascade Rules. How a participant joins a case, changes role in it and leaves it is at §12 Participant Lifecycle Within a Case.
Informative: the dedicated Case Actor is an implementation choice
The reference implementation runs one Case Actor service per container, which holds the CASE_MANAGER role for all the cases it manages.
That choice goes further than the protocol requires.
The protocol requires a participant that holds the role, and any participant can hold it, including the Case Owner itself.
Nothing in this section depends on whether the holder is a dedicated actor.
10.1 Single-Writer Authority
The participant holding the CASE_MANAGER role is the only entity authorized to write the case's shared state.
That shared state is the Public aware, eXploit public, Attacks observed (PXA) axis, the EM state, the Embargo Register, and the case ledger.
No other participant writes shared case state directly.
Every such change goes through the CASE_MANAGER.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
VP-17-001 |
MUST | Every change to the canonical case state MUST go through the CASE_MANAGER, so no participant changes that state directly. This single-writer axiom prevents concurrent-write races and ensures that all shared state changes flow through the actor's consistency checks and persistence layer. The CS participant-specific axes (RM, VFD) are owned by each participant's CaseParticipant record and are intentionally excluded from this restriction. |
The participant-specific axes are report management and Vendor aware, Fix ready, fix Deployed (VFD).
Each participant's own CaseParticipant record owns these axes, and they are explicitly not subject to this restriction.
A participant is the authority on its own report management and VFD state.
This rule exists to make concurrent claims resolvable. Two participants may report contradictory observations about the world at the same moment. With one writer, the case has one answer, and the decision about which claim becomes that answer is explicit (§10.5 Claims and Canonical Status) rather than a race. The routing rule below follows from it.
10.2 Routing Topology
Once a case exists, every case-scoped message follows this path:
Participant → CASE_MANAGER → CaseLedgerEntry → Announce(CaseLedgerEntry) → all Participants
- A participant addresses a case-scoped Activity to the CASE_MANAGER alone, never to the other participants.
- The CASE_MANAGER records the message in the case ledger, and the ledger entry is what it sends on to the other participants.
Announceof aCaseLedgerEntryis the only way a participant learns of an admitted change to shared case state.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
PCR-08-001 |
MUST | After a case is created and its CASE_MANAGER introduced, a participant MUST address each case-scoped message to that CASE_MANAGER alone, never directly to another participant. Case-scoped messages include notes, status updates, embargo proposals, RM transitions and any other protocol message about the case. The one exception is RK, Read(Offer(VulnerabilityReport)). RK answers the reporter's original Offer outside the case. So an addressee of that Offer sends RK to the reporter, never to the CASE_MANAGER (RMB-08-003, RMB-08-005).A participant sends each case-scoped message to the CASE_MANAGER, so that the CASE_MANAGER can check the sender, record the change in the case ledger and send it on to the other participants (PCR-08-003). A message sent straight to a peer gets none of these steps, so the peer's replica and the canonical case disagree. RK is not a case message: it answers the reporter's Offer, which the reporter sent to that receiver before the case existed, so the answer goes back to the reporter (RMB-08-003). |
See also: RMB-08-005 — context for the reader |
PCR-08-005 |
MUST | A participant MUST take the sole to: recipient of a case-scoped message from its case replica. That recipient is the participant holding the CASE_MANAGER role, never the case's full participant list.The case's full participant list includes actors that are not entitled to every message (CM-10-004), and it reaches peers that the CASE_MANAGER has not yet checked the message for. Taking the CASE_MANAGER from the participant's own replica gives one recipient that the participant already trusts. |
|
PCR-08-003 |
MUST | The CASE_MANAGER MUST, for every participant message it receives and accepts, commit a CaseLedgerEntry recording the outcome and broadcast Announce(CaseLedgerEntry) to the case's active participants (CM-10-004) as the standard cascade. This cascade is the only mechanism by which participants learn of accepted case-state changes.Participants learn of case changes only from the ledger. If the CASE_MANAGER applied a change without an entry, or recorded an entry without sending it, the other replicas would never learn of the change and would disagree with the canonical case. |
Uses definition from: CM-10-004 |
PCR-08-002 |
MUST NOT | A participant actor MUST NOT assume that other participants will receive its case-scoped messages through any channel other than the CASE_MANAGER's Announce(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 Announce(CaseLedgerEntry) tells a participant what the case ledger holds. A participant that sends its message to other participants as well gives them a change that the CASE_MANAGER has not yet checked or recorded, and they may act on a change that the CASE_MANAGER later refuses. |
There are exactly two exceptions, and both are confined to case bootstrap. Both occur before the reporter has been introduced to the CASE_MANAGER, so the reporter has none to route through (§10.3 Case Bootstrap and the Trust Root):
- Pre-case report submission — the reporter sends the report directly to the vendor.
No case exists, and therefore no participant holds the
CASE_MANAGERrole. - Case creation handshake — the receiving party sends the case-creation message back to the reporter as itself. That message introduces the actor that holds the role (§10.3 Case Bootstrap and the Trust Root). When that actor is not the receiving party, its first message to the reporter is a later sync. The reporter holds that sync if it arrives before the introduction.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-01-010 |
MUST | When the actor enacting CASE_MANAGER is not the report receiver, the CASE_MANAGER MUST NOT address its Create(VulnerabilityCase) to the original report submitter. That activity goes to the report receiver (the Case Owner), which relays the introduction (CBT-01-001). The CASE_MANAGER's first message to the submitter is an Announce. A submitter that receives it before the introduction holds it under CBT-03-001 and CBT-03-002.The submitter never addressed the CASE_MANAGER, so a Create from it cannot be checked against anything the submitter wrote (CBT-01-005). Introducing the CASE_MANAGER through the actor the submitter chose keeps one trust anchor for the submitter and removes the route that trusted a sender because its own snapshot named it (ADR-0132). |
Uses definition from: CBT-01-001 Derives from: CBT-01-005 See also: CBT-03-001 — context for the reader See also: CBT-03-002 — context for the reader |
The report acknowledgment, RK, falls outside this rule rather than adding a bootstrap exception.
It answers the reporter's original report offer, outside the case, so it goes to the reporter directly, never to the CASE_MANAGER.
The routing requirements above state this exception.
This is a routing rule, not a prohibition on talking
The rule above scopes Vultron protocol messages about a case. It does not say that participants may not communicate with each other, and the protocol has no way to enforce such a thing. Participants routinely talk directly — by mail, by phone, in a shared channel — and that is outside the protocol's scope.
What the rule means is narrower. A case-scoped Vultron Activity delivered directly from one participant to another is not part of the protocol. A receiving implementation has no obligation to apply it. Case state changes through the ledger or not at all.
Informative: why route through one writer
Routing through a single writer avoids the coordination cost of agreeing an order among peers, while still leaving each participant its own replica and its own view. The cost is that the CASE_MANAGER is a single point of coordination authority for the case, and its availability bounds how fast that case can progress.
This is scoped per case. The role is held for one case at a time, different cases may be managed by different actors, and the role is transferable (§12.3 Case Ownership Transfer).
The protocol deliberately leaves more decentralized realizations open. One example is a ledger shared among peers. It would remove the single point of authority, but it would need agreement on ordering. This version does not specify one, and no implementation of one exists.
10.3 Case Bootstrap and the Trust Root
A case's trust is established at its bootstrap, the step from the pre-case exchange to a case with a CASE_MANAGER.
The case-creation message is the trust root.
When a case is created for a report, the receiving party sends the reporter a case-creation message as itself: the actor the reporter chose.
That message introduces the actor holding the CASE_MANAGER role, which may be the receiving party or another actor it delegated case maintenance to.
The reporter trusts the introduction because it came from the actor the reporter addressed, and never because a case snapshot names its own sender.
Every participant's trust in the ledger derives from it: a participant accepts entries from the CASE_MANAGER because it accepts the message that established which actor holds the role.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-01-001 |
MUST | When a case is created in response to an inbound Offer(VulnerabilityReport), the actor that received the report (the report receiver) MUST establish trust at the original report submitter by sending it, as itself, a one-time Create(VulnerabilityCase) activity. When the CASE_MANAGER is a different actor from the report receiver, that activity introduces the CASE_MANAGER the receiver delegated case maintenance to (ADR-0132).The reporter must learn that its report became a case, and which actor coordinates the case. The submitter chose the report receiver and wrote a record of that choice before the case existed. A case that arrives first from an actor the submitter never addressed gives it nothing to check the sender against, and a roster the sender wrote is not an anchor. The receiver already knows the CASE_MANAGER, so it vouches for it. |
|
CBT-01-005 |
MUST NOT | A report submitter MUST NOT trust a newly introduced CASE_MANAGER unless its bootstrap Create(VulnerabilityCase) comes from the report's receiver and references the submitted report.The report receiver is an actor the submitter chose when it sent the report. The record the submitter wrote when it sent the report ties the report to that actor, so the sender cannot forge it (PCR-05-001). The sender writes the roster in the snapshot, so any actor can name itself CASE_MANAGER there. The report reference also stops an actor from attaching an unrelated case to the submitter. |
|
CBT-01-017 |
MUST | The report submitter MUST check the bootstrap of CBT-01-005 against a record it wrote itself before the case arrived, never against the snapshot's roster. The sender writes the roster in the snapshot, so any actor can name itself CASE_MANAGER there. The record the submitter wrote when it sent the report ties the report to the actor it chose, so the sender cannot forge it (PCR-05-001). |
Implements: CBT-01-005 |
CBT-01-011 |
MUST | A participant MUST refuse a bootstrap Create(VulnerabilityCase) from a sender no trust anchor it wrote names as the expected sender, and store nothing from it. A snapshot naming that sender as CASE_MANAGER does not change this (CBT-01-017).The sender wrote the snapshot, so a roster in it proves nothing about the sender's authority (ADR-0132; notes/participant-case-replica.md). |
Refines: CBT-01-005 See also: CBT-01-017 — context for the reader |
The case-creation message carries the whole case inline.
A receiver seeds its replica of the case from this one message, and it trusts no actor to fetch a missing part from until it accepts the message.
So the message carries the complete case and each CaseParticipant record inline rather than by reference.
It may name the report by reference: the receiver offered that report, so it already holds it.
A receiver that finds a required participant missing, or named only by reference, rejects the message as a protocol error.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-01-002 |
MUST | The bootstrap Create(VulnerabilityCase) activity MUST carry the complete VulnerabilityCase inline, rather than a reference, a minimal stub or a partial trust-only payload.The receiver seeds its Participant Case Replica from this activity. A stub or a partial case leaves it nothing complete to seed from. A reference leaves it nothing to read: it has no trusted source to fetch the case from, because it trusts the CASE_MANAGER only after it accepts this activity (ADR-0170). |
Refines: AKM-03-001 |
CBT-01-007 |
MUST | The bootstrap Create(VulnerabilityCase) payload MUST carry each CaseParticipant record the case lists inline.The receiver seeds its replica from this payload, and later guards read the participant records it seeds, such as the participant checks on a sender. A record the payload leaves out is one the replica lacks when a guard needs it. A record named only by reference is left out too: the receiver does not fetch it (AKM-05-007), because before it accepts this activity it has no trusted source to fetch it from (ADR-0170). |
Refines: CBT-01-002 |
CBT-05-008 |
MUST | This rule covers a receiver that finds required participant data absent from a bootstrap Create(VulnerabilityCase) (CBT-01-007). It MUST reject the bootstrap as a protocol error, never skipping the participant, inferring its state, or synthesizing a record from data the payload lacks.Silent reconstruction of missing protocol data masks protocol bugs: a fallback that fills in missing data "from domain knowledge" makes the protocol look as if it works when it does not, so the failure must be visible to be diagnosed and fixed. Replicas are built only from ledger content; data not in the ledger did not happen. A participant the payload names only by reference is absent too: CBT-01-007 requires it inline, and the receiver does not fetch it (AKM-05-007). |
Derives from: CBT-01-007 |
A late joiner inherits that trust transitively. An actor invited after the case is under way never sees the original creation message. It trusts the invitation that named the CASE_MANAGER. It then receives the case snapshot and the prior ledger entries from the CASE_MANAGER (§10.4 Ledger Replication and Case Delivery). It trusts them because it trusts that invitation.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-04-001 |
MUST | For a participant added after case creation, the trust-establishing message MUST be InviteActorToCase from the CASE_MANAGER rather than Create(VulnerabilityCase).A late joiner submitted no report, so it holds no record that ties a case to an actor it chose. The stub Invite gives it one: the joiner chooses to accept it, and the accepted Invite is its Trust Anchor for the case (PCR-03-004). A Create(VulnerabilityCase) from an actor the joiner never dealt with gives it nothing to check the sender against. |
|
CBT-04-002 |
MUST | The trust-establishing invite for a late joiner MUST identify both the case and the CASE_MANAGER that will send subsequent Announce(VulnerabilityCase) updates.The joiner checks each later Announce(VulnerabilityCase) against the Trust Anchor the Invite left. If the Invite does not name both the case and the CASE_MANAGER, the joiner cannot tell which sender to trust for which case. |
The hash-chaining of the ledger lets the joiner verify it received an unbroken history. This is a check against tampering and omission, not a second source of trust.
The threat model, identity verification, and the limits of this trust chain are covered at §16.1 Trust Model.
10.4 Ledger Replication and Case Delivery
The CASE_MANAGER keeps every active participant's replica in step with the case through two operations.
| Operation | What the CASE_MANAGER does |
|---|---|
| Ledger replication | Sends each committed ledger entry to every active participant, as Announce(CaseLedgerEntry). This is the only way a participant learns of an admitted change to shared case state (§10.2 Routing Topology) |
| Case delivery | Sends a participant the full case once it is an active participant (§9.7 Gating Full Case Delivery), then the ledger entries committed before it joined, oldest first (§11.1 Admitting a Participant) |
Their wire activities are given at §4.12 Ledger Replication Messages and §4.7 Case and Participant Messages. Both operations reach only active participants. Being in the case's participant list is not enough.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-10-004 |
MUST | The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(Actor)[target=VulnerabilityCaseStub])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122). |
Uses definition from: CM-14-001 Uses definition from: CM-18-001 Uses definition from: CM-31-001 |
CM-17-005 |
MUST NOT | Presence in the case participant list MUST NOT be treated as acceptance of the invitation or as entitlement to case content. An invitee is in the list from the stub Invite onward (CM-11-006); only an active participant (CM-10-004) is entitled to case content. The CASE_MANAGER tracks every invitee from the moment it is invited, including one that declines, so the participant list holds inert participants. Any consumer that reads membership as "accepted" would hand case content to an actor that has not consented. |
Uses definition from: CM-10-004 See also: CM-11-006 — context for the reader |
A ledger entry records the asserted activity as it was sent. Its payload snapshot is the received body of an activity the CASE_MANAGER received, or the body it delivered for one it sent itself. Each nested object stays as the asserting activity carried it. It stays inline where its sender inlined it, and by reference where its sender named an object every replica already holds.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CLP-07-011 |
MUST | The payloadSnapshot of a CaseLedgerEntry MUST be the verbatim AS2 activity that was asserted, with no field of it dropped, re-serialized, inlined, patched or merged. For an activity the CASE_MANAGER received, it is the JSON body as received (VM-08-002). For one the CASE_MANAGER emits, it is the body it delivered (VM-08-003). An activity the CASE_MANAGER sends and ledgers is one activity. So the case's genesis entry is the Create(VulnerabilityCase) it sends for the case, not a second activity built for the ledger. The metadata the CASE_MANAGER adds lives on the entry, outside the snapshot: the index, the hashes, the commit and receipt times, and case_id.The payload snapshot is the replication substrate, and the entry hash covers it, so what it holds is what every replica treats as the event. A snapshot rebuilt from the receiver's object graph records the receiver's reconstruction, not what the sender claimed, and every rewrite is one more thing a replica must reproduce exactly to verify a hash (ADR-0107). |
Uses definition from: VM-08-002 Refines: VM-08-003 |
CLP-07-006 |
MUST | The CASE_MANAGER MUST record each nested object of a payloadSnapshot exactly as the asserted activity carried it, never inlining, resolving or replacing a reference. An entry the CASE_MANAGER authors carries in full every object it records. A received entry is the received body (CLP-07-011). So an object is inline where its sender inlined it, as a sender does every object its recipient cannot be expected to hold. It is bare where its sender named an object the case's replicas already hold (AKM-02-002). A replica that does not hold an object named by reference dereferences it.A protocol rule, not this prototype's inline-object shortcut (AKM-03-003): the entry hash covers the payloadSnapshot and nothing outside it, so an object carried in full is under the hash every participant verifies, and an object named by id is only identified by it. Filling a reference in at the CASE_MANAGER would put the receiver's reconstruction in place of what was sent, and a replica could not tell the sender's claim from the fill-in (ADR-0107). |
See also: AKM-02-002 — context for the reader See also: CLP-07-011 — context for the reader |
CLP-07-018 |
MUST NOT | The CASE_MANAGER MUST NOT refuse an entry for a bare reference anywhere but the snapshot's own object, whose type is half of the entry's signature.A sender may name by id any object the case's replicas already hold (AKM-02-002), so a bare reference elsewhere is a valid entry. Only the snapshot's own object must be inline, because its type selects the entry's signature. |
Derives from: CLP-07-006 |
The CASE_MANAGER never fills a reference in. The entry hash covers the snapshot and nothing outside it. A filled-in snapshot would thus record the CASE_MANAGER's reconstruction, not what was sent. The entry hash is computed over the RFC 8785 JSON Canonicalization Scheme (JCS) serialization of the content it covers (§5.2 Serialization), so every replica hashes the same bytes for it. How a message carries an object inline or by reference is specified at §5.2 Serialization.
10.5 Claims and Canonical Status
Two status records carry the case's state, and they are the most easily confused types in the protocol (§4.3 Object Types). The difference between them is one of authority rather than content.
- A
ParticipantStatusis a claim. It carries what one participant reports about its own state, or observes about the world. Any participant may write one, and writing one does not change what the case asserts. - A
CaseStatusis canonical. It carries what the case asserts: its embargo state and what is publicly known. Only the CASE_MANAGER writes it (§10.1 Single-Writer Authority).
A claim becomes canonical only when the CASE_MANAGER adopts it.
Adoption is an authorization decision with a named default, not an automatic consequence of receipt (§11.3 Status Adoption: One Authorization Gate).
The two types are not interchangeable.
A participant that emits CaseStatus is asserting authority it does not hold.
A CASE_MANAGER that treats an inbound ParticipantStatus as canonical has skipped the decision.
The status messages depend on who is sending. The six case state shorthands (§4.9 Case State Messages) do not have one wire form; they have two, and the sender's authority decides which applies:
- A participant reporting its own VFD progress, or an observation about the world, sends
Addof aParticipantStatus. This is a claim. - The CASE_MANAGER, having adopted a claim, sends
Addof aCaseStatustargeting the case. This is the canonical write.
A participant never sends Add of a CaseStatus, and a receiver refuses one from any sender other than the CASE_MANAGER.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
RSH-04-001 |
MUST NOT | An actor that is not the CASE_MANAGER MUST NOT emit Add(CaseStatus).CaseStatus encodes shared EM and PXA state for the entire case. The CASE_MANAGER is the authoritative writer of canonical case state (ADR-0046, CLP-09). Allowing participants to emit Add(CaseStatus) directly would bypass the adoption authorization model. |
|
RSH-04-007 |
MUST | A participant that is not the CASE_MANAGER MUST report the CaseStatus it suggests by embedding it in its own Add(ParticipantStatus).A participant cannot send Add(CaseStatus) (RSH-04-001), but its view of P, X or A still needs to reach the case. Embedding it in the participant's own status puts it through the adoption gate (RSH-01-003). |
Extends: RSH-04-001 |
RSH-04-005 |
MUST | A receiver MUST refuse a received Add(CaseStatus) unless the case's CASE_MANAGER sent it to a participant.RSH-04-001 reserves Add(CaseStatus) for the CASE_MANAGER, which sends it to participants inside a case ledger entry. add_case_status_tree has no StatusAdoptionGate, so admitting it from another sender would adopt that participant's P, X or A report without the Case Owner approval RSH-07-001 requires. A participant embeds the P, X or A it reports in its own Add(ParticipantStatus) instead (RSH-04-007), which the CASE_MANAGER adopts through the gate (RSH-01-003). |
Derives from: RSH-04-001 Refines: HP-01-006 |
RSH-04-012 |
MUST | When a receiver refuses an Add(CaseStatus) under RSH-04-005, it MUST write nothing past intake and send nothing.A refused status is one the receiver must not act on. A write past intake would change case state on the refused claim, and a reply would answer a sender that had no right to send it. |
Extends: RSH-04-005 |
An implementation that maps all six shorthands to CaseStatus regardless of sender will have participants asserting authority they do not hold.
The rest of the shorthand mapping is at §4.13 Formal Message Set.
11. Model Interactions and Cascade Rules [N]
The five state machines are not independent. A transition in one produces obligations in others, and this section specifies those couplings.
Each coupling is a cascade: a state change raises a domain event, and the CASE_MANAGER handles that event by applying further changes. Every cascade step is authorized separately, and where the order of steps matters this section says so. The cascades below are the complete set that this specification requires.
Recall: which machine owns which state
| Machine | Ownership | Written by |
|---|---|---|
| Report Management (RM) | Participant-specific | The participant is the source, and the CASE_MANAGER records each value on the participant's record. The CASE_MANAGER also writes the invitee's initial Received when it sends the stub Invite, keeps Received when the invitee accepts it, and writes Closed when the invitee rejects it. |
| Vendor aware, Fix ready, fix Deployed (VFD) | Participant-specific | The participant is the source, and the CASE_MANAGER records each value on the participant's record. For a vendor invitee, the CASE_MANAGER also writes the initial vfd when it sends the stub Invite, and Vfd when the invitee accepts or rejects it. |
| Embargo Management (EM) | Shared case state | The CASE_MANAGER only |
| Public aware, eXploit public, Attacks observed (PXA) | Shared case state | The CASE_MANAGER only |
| Participant Embargo Consent (PEC) | Per-participant | The CASE_MANAGER only |
11.1 Admitting a Participant
When an actor accepts the stub Invite, the CASE_MANAGER admits it to the case and
delivers the case content. The CASE_MANAGER created the actor's inert participant
record, at RM state Received, when it sent the stub Invite
(§12.2 Invitation and Acceptance).
The steps are ordered because each one supplies a precondition for the next.
---
title: Admitting a participant
---
sequenceDiagram
autonumber
participant I as Invited actor
participant CM as CASE_MANAGER
participant P as Active participants
I->>CM: Accept(Invite(Actor)[target=VulnerabilityCaseStub])
CM->>CM: Commit ledger entry for the acceptance
CM->>P: Announce(CaseLedgerEntry)
CM->>CM: Record effect: RM stays Received, embargo consent AGREED
CM->>I: Announce(VulnerabilityCase) — full case content
CM->>I: Prior ledger entries, oldest first
CM->>I: Invite(Actor)[target=VulnerabilityCase] — full-case Invite
On receiving Accept(Invite), the CASE_MANAGER performs these four steps in
this order:
- Commit a ledger entry recording the acceptance, and send that entry to every active participant.
- Record the acceptance's effect on the participant.
Its RM state stays
Received. Its consent row for the active embargo, if any, becomesAGREED, unless the participant had declined that embargo. - When the participant is now active, send
Announce(VulnerabilityCase)carrying the full case snapshot, then replay the ledger entries committed before this participant joined, oldest first. - Send the full-case Invite, which asks the participant to judge the case.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-17-004 |
MUST | When the CASE_MANAGER receives Accept(Invite(Actor)[target=VulnerabilityCaseStub]) from an invitee, it MUST, in this order: (1) commit a ledger entry for the Accept and fan it out to every active participant (CM-10-004); (2) record the Accept's effect on the participant (CM-11-001); (3) when the participant is now active, send it Announce(VulnerabilityCase) and replay all prior CaseLedgerEntry records to it in log-index order (CM-11-008); and (4) send it the full-case Invite (CM-11-010).Each step needs the step before it. The ledger records the Accept before any step acts on it (CLP-10-006). The participant's record must show that it joined before the participant is active and entitled to content (CM-10-004). The participant must hold the case and its history before it can make a decision about the case. Delivery to each recipient is in order (ADR-0112). Thus the full-case Invite, which the CASE_MANAGER queues last, arrives when the participant can answer it (CM-11-010). |
Uses definition from: CM-11-001 Uses definition from: CM-11-008 Uses definition from: CM-11-010 Uses definition from: CM-10-004 |
CM-11-001 |
MUST | When a participant accepts the stub Invite (Accept(Invite(Actor)[target=VulnerabilityCaseStub])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this. |
Uses definition from: CM-10-001 Extends: BT-10-005 |
CM-11-008 |
MUST | When the CASE_MANAGER processes Accept(Invite(Actor)[target=VulnerabilityCaseStub]) and the participant is active (CM-10-004), it MUST send the participant Announce(VulnerabilityCase) and begin replaying the case ledger to it without waiting for any further signal from the participant.The participant is entitled to case content from the moment it is active, and the history is part of what it then judges. The Accept is the readiness signal; out-of-order arrival is buffered (SYNC-14, SYNC-15) and a real gap is recovered by Reject(CaseLedgerEntry) and replay. |
Uses definition from: CM-10-004 |
CM-11-010 |
MUST | After CM-11-008, the CASE_MANAGER MUST send the participant the full-case Invite, Invite(Actor)[target=VulnerabilityCase], queued after the last replayed ledger entry.The participant already holds the case from the Announce, so the Invite only asks the question and carries no copy of the case. Delivery to each recipient is ordered (ADR-0112), so queuing the Invite after the replay means it usually arrives once the participant can answer it. The protocol does not rely on that order (ADR-0161): CM-11-033 covers an Invite that arrives first. |
Depends on: CM-11-008 |
CM-11-031 |
MUST | The full-case Invite MUST name the case by ID and carry the log_index and entry_hash of the CASE_MANAGER's ledger tail when it issued the Invite.The Invite's ledger position is the floor the participant must reach before answering (ADR-0121). It travels as the Invite's ledgerPosition, the property every case activity carries (VAM-04-011, SYNC-18-001, ADR-0156). |
Extends: CM-11-010 |
CM-11-032 |
MUST | A receiver MUST refuse a full-case Invite whose sender is not the CASE_MANAGER on its replica of the case. Only the case's CASE_MANAGER may ask a participant to judge the case. The receiver judges the Invite only when it holds the replica (CM-11-033), so the replica's CASE_MANAGER is the only record the sender check needs. The stub-Invite trust anchor decides an earlier question: whether the Announce may create that replica (PCR-03-004). |
|
CM-11-033 |
MUST | A receiver MUST NOT judge a full-case Invite for a case it holds no replica of. The protocol does not rely on delivery order (ADR-0161), so the Invite can arrive before the Announce (CM-11-010). It is case-scoped: the inbox's defer check holds it until the Announce creates the replica, then replays it (HP-01-041). With no trust anchor, no Announce can create the replica (PCR-03-004), so the held Invite expires unprocessed (CBT-03-003) and the receiver fails closed. |
Extends: CM-11-032 Depends on: HP-01-041 |
Recall: report management states
| State | Meaning |
|---|---|
| Start | No report has been received |
| Received | A report has arrived; triage is not yet complete |
| Invalid | This participant assessed the report as invalid |
| Valid | This participant assessed the report as valid |
| Deferred | This participant is deferring further action |
| Accepted | This participant accepted the report for active work |
| Closed | This participant closed the report |
Full definitions are in §6.1 States.
Step 3 delivers the content that step 2 authorizes: the embargo consent recorded in step 2 is what the delivery gate tests (§9.7 Gating Full Case Delivery). Step 4 follows the replay, so the participant judges a case it already holds.
11.2 Embargo Revision and Termination Cascades
A change to the embargo in force propagates to participants' consent, because consent is given to specific terms. A change that is only proposed does not. Each cascade below starts from a step on the case's embargo register (§7.1.1 The Embargo Register), and the EM state follows from the register.
Recall: embargo management states
| State | Meaning | Embargo register entries |
|---|---|---|
| None | No embargo is in effect for this case, and none is proposed | none ACTIVE, PROPOSED or TERMINATED |
| Proposed | At least one embargo is proposed, and none is in force | one or more PROPOSED, none ACTIVE |
| Active | An embargo is in force, and no revision is open | one ACTIVE, none PROPOSED |
| Revised | An embargo is in force, and at least one revision of it is open | one ACTIVE, one or more PROPOSED |
| Exited | The embargo has been torn down | one TERMINATED |
Full definitions are in §7.1 States.
A revision is proposed (EM enters, or stays at, Revised).
The register gains a PROPOSED entry for the revision, and every other participant gets an UNINVITED row for it.
No consent to the embargo in force changes: the prior embargo is still in force and every signatory to it remains one.
The CASE_MANAGER records the proposer's row for the revision as AGREED, because proposing terms is consenting to them.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-18-001 |
MUST | Each participant record MUST hold one embargo consent row for every entry in the case's embargo register. Each row holds one of five states. The UNINVITED state means not asked, and is the start state. The INVITED state means asked, with no answer yet. The AGREED state records agreement, and DECLINED records an explicit refusal or a withdrawal. The TIMED_OUT state means invited, with the RSVP deadline passed and no answer. A participant is a signatory when its row for the register's ACTIVE entry is AGREED. A participant has lapsed when three things hold. An entry is ACTIVE, and the participant's row for it is neither AGREED nor DECLINED. Following replaces back from the ACTIVE entry, the first entry whose row is AGREED or DECLINED has an AGREED row. Both positions are read from the rows and the register, never stored (CM-18-016). With no ACTIVE entry, nobody is a signatory and nobody has lapsed.One row for each pair of participant and embargo records each answer one time. To find if a participant is bound by the active embargo, a reader looks at the row for the active embargo. Thus there is no second record to reconcile, and a first proposal and a revision use the same rules (ADR-0122). TIMED_OUT is different from DECLINED, so that every reader can tell silence from a refusal (ADR-0118). A terminated embargo is a fact of the register, not a fact about each participant. A lapse follows the replaces chain. Thus only an embargo that was in force can bind, and a withdrawal from a later embargo ends the binding of an earlier embargo. |
|
CM-18-019 |
MUST | Proposing an embargo MUST write an UNINVITED consent row for it on every current participant.A participant that was not asked holds a row that says so. Thus no reader infers "not asked" from a missing record, and a check can use the register to find a row for each participant and each embargo (CM-18-001). |
Implements: CM-18-001 |
CM-18-020 |
MUST | Creating a participant record MUST write an UNINVITED consent row on it for every entry already in the case's embargo register.A participant that joins after embargoes were proposed was asked about none of them. A row for each entry records that, so the participant holds a row for every entry from its creation on (CM-18-001), and no reader meets a missing row. |
Implements: CM-18-001 |
CM-18-021 |
MUST NOT | A reader MUST NOT read a missing consent row as any consent state. A missing row is a defect. Every row is written (CM-18-019, CM-18-020), so a missing row comes only from a fault. A reader that treated it as UNINVITED, or as any other state, would hide the fault, and could count a participant as asked, bound or free when it is not. |
Extends: CM-18-001 |
EP-05-002 |
MUST NOT | A revision proposal (ACTIVE → REVISE) and any further counter-revision (REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force. The proposer's row for the proposed embargo becomes AGREED (MSM-07-022). Every other participant gets an UNINVITED row for it (CM-18-001). Every other row stays as it is until the Case Owner activates a revision (EP-05-001, EP-05-003). Until then the prior embargo stays in force, and every signatory to it remains one.A participant cannot lapse until the embargo on the case differs from the one they agreed to. Lapsing on proposal would strand signatories when the revision is rejected, report participants who are still bound and still receive embargoed content as not bound, and lapse the proposer of the revision (ADR-0093). With per-embargo rows a proposal only ever adds rows for the proposed embargo. |
Uses definition from: CM-18-001 Refines: MSM-07-022 See also: EP-05-001 — scope boundary: a different transition See also: EP-05-003 — context for the reader |
The Case Owner activates the revision.
The register activates the revision's entry and supersedes the entry in force, in one step.
EM returns to Active, or stays at Revised while another revision is open.
The owner's row for the revision becomes AGREED unless it already is.
If the revision ends no later than the embargo it replaces, the CASE_MANAGER applies CARRY_OVER.
That transition goes to the revision's row of every participant whose row for the replaced embargo is AGREED, a DECLINED revision row included.
If the revision ends later, no row is written.
In that case, a signatory to the replaced terms whose row for the revision is not AGREED has lapsed.
That lapse is read from its rows and the register (§9.3 Signatory and Lapsed).
A participant that has already agreed to the revision is its signatory by lookup.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
EMB-18-005 |
MUST | Every change to a case's embargo register MUST move the case's EM state only along an EM transition for the change's EM trigger: a proposal is propose, an activation is accept, a rejection, or the cancellation of open proposals with no embargo in force, is reject, and a termination is terminate. The EM transitions are propose: N→P, P→P, A→R, R→R; reject: P→N, P→P, R→A, R→R; accept: P→A, P→R, R→A, R→R; and terminate: A→X, R→X. A rejection leaves Proposed, and a rejection or an acceptance leaves Revise, only when no proposal remains open; an acceptance from Proposed moves to Active, or to Revise while another proposal stays open.EM is computed from the embargo register (ADR-0122), not replaced by it: the EM state machine remains the protocol's model, and the register is a layer beneath it. With several proposals open, rejecting or activating one leaves the others open: a rejection keeps EM in Proposed or Revise until the last one is off the table, and an activation from Proposed puts the embargo in force with the others pending as revisions, in Revise (ADR-0130). |
Extends: EMB-18-001 |
EP-05-001 |
MUST NOT | This rule covers the Case Owner's activation of a revised embargo that ends later than the embargo it replaces (REVISE → ACTIVE). The CASE_MANAGER MUST NOT carry any participant's consent over to it.A participant who signed for terms T1 has not consented to longer terms T2; treating them as a signatory once T2 is in force would imply consent they never gave. A participant is bound by the revised embargo only through an AGREED consent row for it, so each signatory to the replaced embargo that has not agreed to the revised one has lapsed (CM-18-001), and no write is needed to lapse them. The rule applies at activation rather than at proposal because the participant remains bound by T1 for as long as T1 is the active embargo (ADR-0093, ADR-0122). |
Uses definition from: CM-18-001 |
EP-05-003 |
MUST | This rule covers the Case Owner's activation of a revised embargo that ends no later than the one it replaces. The CASE_MANAGER MUST apply CARRY_OVER to the revised embargo's row of each participant with an AGREED row for the replaced embargo. That includes a participant whose row for the revision is DECLINED (CM-10-001, CM-18-003, MSM-07-005).Shorter terms ask nothing new: agreeing to N days is agreeing to every shorter period, the same containment that makes shortest-wins (EP-04-003) safe without asking anyone, so their agreement is carried over by writing the row. That holds for a participant that declined the shorter revision too: its decline objected to losing time, not to keeping the embargo, and the decline stays in the ledger (ADR-0122). |
Uses definition from: CM-18-001 Uses definition from: CM-18-003 Refines: MSM-07-005 See also: CM-10-001 — context for the reader |
MSM-07-005 |
MUST | This rule covers the Case Owner's Add(EmbargoEvent)[target=VulnerabilityCase] (MSM-07-008) that replaces active embargo A with revision B. The register activates B and supersedes A, so the derived EM goes REVISE → ACTIVE, or stays REVISE while another proposal is open (EMB-18-005). Implementations MUST settle every participant's consent rows against B. Only the owner's acceptance changes the embargo on the case; other participants' accepts and rejects are recorded per embargo and inform that decision. When it replaces the embargo in force, each participant's standing has to be read again against the new terms (ADR-0093). |
Uses definition from: CM-18-003 Uses definition from: MSM-07-008 Uses definition from: EMB-18-005 |
MSM-07-021 |
MUST NOT | A revision proposal (EV, ACTIVE → REVISE, or a counter-revision REVISE → REVISE) MUST NOT change any participant's consent to the embargo in force. While a revision is merely proposed the prior embargo is still in force and every signatory to it is still bound by it, so nothing about their consent has changed (ADR-0093). |
|
MSM-07-022 |
MUST | When a participant proposes a revision, implementations MUST mark the proposer's row for the proposed embargo AGREED. Proposing terms is agreeing to them, so the proposer needs no Invite of its own proposal. |
Extends: MSM-07-021 |
MSM-07-023 |
MUST | The CASE_MANAGER MUST commit each carried-over row as its own CASE_MANAGER Update(EmbargoConsent) ledger entry, after the Accept's entry. The owner's own row is what its Accept states, applied from the Accept's entry.The CASE_MANAGER decides the carry-over. Committing each carried-over row as its own entry keeps every replica's consent rows in step with the CASE_MANAGER's. |
Implements: EP-05-003 |
MSM-07-024 |
MUST | Every replica MUST copy the CASE_MANAGER's carried-over consent entries rather than run the carry-over itself (ADR-0124, CLP-07-013, CM-23-016). A replica that ran the containment comparison on its own state could reach a different answer from the CASE_MANAGER's. |
Depends on: MSM-07-023 Refines: CM-23-016 See also: CLP-07-013 — context for the reader |
MSM-07-020 |
MUST NOT | This rule covers the owner's activation of revision B in place of active embargo A, where B ends later than A. Implementations MUST NOT write any consent row to lapse a participant. A participant whose row for B is not AGREED is not a signatory to B, and has lapsed if it had agreed to A (CM-18-001). Longer terms ask for more than the signatories of A promised, so only those who agreed to B are bound by B, and the rows say so without a write. |
Refines: MSM-07-005 Uses definition from: CM-18-001 |
The Case Owner rejects the revision.
The register rejects the revision's entry.
EM returns to Active once no other revision is open.
No consent row changes, the owner's included, and the prior terms stand.
One case differs: when the rejected revision is the last open one and the case is already public, exploited or attacked, the same act also terminates the embargo.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
MSM-07-009 |
MUST | The wire activity REJECT_EMBARGO_PROPOSAL_ON_CASE (wire form: Reject(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST reject the named proposal's embargo register entry. Once no other proposal is open, the derived EM becomes NONE (ER) or stays ACTIVE with the prior terms in force (EJ). It stays PROPOSED or REVISE while another proposal is open (EMB-18-005). The owner's rejection decides the proposal for the case; whether the owner, as a participant, also refuses those terms is a separate Reject of the Invite (MSM-07-004). The owner's own row does not constrain the rejection: an owner that accepted terms for itself may still reject them for the case (ADR-0180). Keeping the two apart lets the owner keep the prior terms without declining them (ADR-0122). |
Uses definition from: VAM-05-009 Uses definition from: EMB-18-005 |
MSM-07-030 |
MUST | The CASE_MANAGER MUST accept REJECT_EMBARGO_PROPOSAL_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006). Deciding a proposal for the case is the Case Owner's authority, so no other participant's activity may reject it for the case. |
Extends: MSM-07-009 Refines: HP-01-006 |
MSM-07-033 |
MUST | The CASE_MANAGER MUST refuse REJECT_EMBARGO_PROPOSAL_ON_CASE before committing it when the named embargo is not an open proposal of the case. There is nothing to decide, and a committed entry naming no open proposal would be applied by every replica that copies it. |
Extends: MSM-07-009 |
MSM-07-031 |
MUST NOT | REJECT_EMBARGO_PROPOSAL_ON_CASE MUST NOT change any participant's consent rows, the Case Owner's included. The owner's decision for the case is not its consent as a participant; that is a Reject of the Invite (MSM-07-004). |
Extends: MSM-07-009 |
MSM-07-032 |
MUST | This rule covers REJECT_EMBARGO_PROPOSAL_ON_CASE of the last open revision while CS is public, exploited or attacked. The CASE_MANAGER MUST also terminate the embargo in the same act (EMB-04-002). It trial-applies both steps before committing either. It commits the Reject's entry carrying the REJECT step, then its own ET Remove(EmbargoEvent) entry carrying the TERMINATE step. A refused termination commits neither.Reverting to the prior terms is not viable once disclosure has happened, so the rejection ends the embargo. Deciding both steps together means a replica copying both entries ends with the revision REJECTED and EM EXITED, as the CASE_MANAGER does. |
Extends: MSM-07-009 Refines: EMB-04-002 |
EMB-04-002 |
MUST | The CASE_MANAGER in EM Revise (q^em ∈ R) with CS in a public/exploit/attack state (q^cs ∉ ···pxa) that commits the Case Owner's EJ of the last open revision MUST emit ET in the same act to terminate the embargo, rather than reverting to Active. Reverting to Active is not viable once public disclosure has occurred. VP-09-001 requires termination in these states. "Rather than reverting" describes where the act ends: EM ends EXITED, never back in Active. Inside the act, the CASE_MANAGER records the rejection as decided (the revision REJECTED) and then terminates the embargo, as two entries a replica copies in order (MSM-07-032, CM-23-016). ECA DetailsPreconditions - EM state is Revise; CS matches pattern ...P.. - EM state: REVISE- CS pattern: ...P..- EM state is Revise; CS matches pattern ....X. - EM state: REVISE- CS pattern: ....X.- EM state is Revise; CS matches pattern .....A - EM state: REVISE- CS pattern: .....ASteps 1. [CASE_MANAGER] Commit the Case Owner's EJ, then emit ET to terminate the embargo in the same act → ET queued for participants; EM transitions to EXITED Postconditions - ET emitted; EM state is EXITED |
Refines: VP-09-001 — Embargoes SHALL terminate immediately when public/exploit Uses definition from: MSM-02-004 — EJ shorthand wire-type mapping |
The embargo is terminated (EM enters Exited).
The register terminates the entry in force and cancels every open proposal in the same step.
No consent row is written.
With no ACTIVE entry, no participant is a signatory and none has lapsed.
Every row for the terminated and canceled entries is frozen as it stood, so an accept that arrives afterwards records nothing.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
EP-08-004 |
MUST | When an embargo terminates (EM ACTIVE or REVISE → EXITED), the implementation MUST close every open proposal, cancelling it in the same embargo register step that terminates the embargo (ADR-0122), not only the entry for the terminated embargo itself. Every proposal open while EM is ACTIVE or REVISE is a revision of the active embargo, and a revision of an embargo that no longer exists cannot be accepted.A case has at most one active embargo (VP-04-002), so while EM is ACTIVE or REVISE every open proposal is by construction a revision of that embargo; no field linking a revision to the embargo it revises is needed to know which proposals a termination decides. EP-08-003's text reaches the terminated embargo; this entry reaches the proposals about it. |
Refines: EP-08-003 |
MSM-07-006 |
MUST | When an ET / REMOVE_EMBARGO_EVENT_FROM_CASE wire activity terminates the embargo register's ACTIVE entry, implementations MUST leave the case with no active embargo. The same step cancels every open proposal, so the derived EM becomes EXITED. No separate outbound wire activity is emitted; the participant position is derived from the case. A register with a TERMINATED entry accepts no further change (ADR-0122), so a terminated embargo can never be invited to again. That is a fact about the case, which every replica holds once it replays the teardown. |
Uses definition from: MSM-02-007 |
MSM-07-025 |
MUST NOT | When an ET terminates the embargo register's ACTIVE entry, implementations MUST NOT write any participant's consent rows. With no active embargo no participant is a signatory and no row binds anyone. An Accept or Reject that arrives afterwards records nothing (EMB-17-004). The termination is a fact about the case, so it does not need copying onto each participant record as a terminal consent state. Leaving the rows as they were also keeps the history of who agreed to what, and every row of a final entry is frozen (CM-18-003). |
Extends: MSM-07-006 See also: EMB-17-004 — context for the reader |
EMB-17-004 |
MUST | This rule covers a case with no Active and no Proposed Embargo (EM EXITED or NONE). There, the CASE_MANAGER MUST answer a late Accept of an embargo its register holds with the refusal notice alone (MSM-07-012). A redelivery of the same Accept gets the same result. Follows the EMB-07-003 precedent for post-terminal messages: no transition. There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested — but the actor's case participation is independent of embargo consent and MUST survive. The sender is still owed word that its answer did not count, which the refusal notice gives (CLP-05-001). An Accept of terms the case never held gets a processing fault instead (MSM-07-039). See ADR-0065. ECA DetailsPreconditions - EM state is EXITED (embargo terminated) or NONE (no embargo started) - EM state: EXITED, NONESteps 1. [system] Refuse the Accept with the refusal notice, committing nothing and sending nothing else → Participant consent rows are unchanged; participant remains in the case; no ledger entry is committed and only the refusal notice is sent Postconditions - No embargo state change; accepting actor remains a case participant |
Refines: EMB-17-001 Refines: MSM-07-012 |
EMB-17-015 |
MUST NOT | The CASE_MANAGER MUST NOT commit any ledger entry for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004). An entry acknowledging the Accept would change nothing at any receiver. The Accept is refused, and a refusal is never written to the ledger (CLP-04-007). |
Part of: EMB-17-004 |
EMB-17-016 |
MUST NOT | This rule covers a late Accept of an embargo the register holds, in a case with no Active and no Proposed Embargo (EMB-17-004). The CASE_MANAGER MUST NOT send any activity in reply to it but the refusal notice. There is nothing to invite the actor to, so a fresh invitation would manufacture a negotiation nobody requested. The refusal notice is owed: it tells the sender its answer did not count (MSM-07-012). |
Part of: EMB-17-004 |
EMB-17-017 |
MUST | The CASE_MANAGER MUST leave the participant's consent rows unchanged for a late Accept that arrives when the case has no Active Embargo and no Proposed Embargo (EMB-17-004). Nothing is recorded after a termination (EM EXITED), and a TIMED_OUT row stays TIMED_OUT when no embargo has started (EM NONE) (ADR-0118). The Accept names an embargo that is no longer, or not yet, in force, so no row can bind to it. The actor's case participation is independent of embargo consent and survives. |
Part of: EMB-17-004 |
After a teardown.
The termination's own ledger entry, fanned out as Announce(CaseLedgerEntry), records the end.
The activity that tells the other participants depends on which actor started the teardown:
- A received
Remove(EmbargoEvent). The Case Owner sends the CASE_MANAGER aRemove(EmbargoEvent)before the embargo's end time. The CASE_MANAGER tears the embargo down and then sendsAnnounce(EmbargoEvent)to every other active participant. - A teardown the CASE_MANAGER starts. The CASE_MANAGER ends the embargo itself, by its own decision, at the end time, or in the P/X/A cascade of §11.3 Status Adoption: One Authorization Gate.
Its own
Remove(EmbargoEvent)is then the notice, and it sends that activity to every other active participant. NoAnnounce(EmbargoEvent)follows it.
When the teardown comes before the embargo's end time, on either path, the CASE_MANAGER also sends a direct Remove(EmbargoEvent) notice to each signatory the ledger fan-out does not reach.
A teardown at the end time sends no such notice, because every signatory already knows the end time.
No message is sent for consent, because none is written.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
EP-09-009 |
MUST NOT | The CASE_MANAGER's commit of a received embargo activity, fanned out as Announce(CaseLedgerEntry), is the acknowledgement the EMB behavioural requirements express as "emit EK". Implementations MUST NOT define or emit an EK message to acknowledge an embargo activity.No EK exists in the production stack and MSM-02-009 records that its purpose is served by ledger hash-chain continuity. Under the relay every accepted embargo activity is committed and announced, so the record the specs want the receiver to produce already exists; a second acknowledgement would be a message with no reader (#3918). |
Refines: MSM-02-009 |
EMB-19-001 |
MUST | The actor that holds the CASE_MANAGER role for the case MUST author the activity that tells the other participants of an embargo teardown. That activity is an Announce(EmbargoEvent) after a received Remove(EmbargoEvent), and the CASE_MANAGER's own Remove(EmbargoEvent) for a teardown it starts.The teardown changes canonical case state, so the actor that holds the CASE_MANAGER role announces it, and the participants are its audience. The tree that commits the teardown runs as the CASE_MANAGER, because the ledger commit is gated on that role. An announcement addressed to the CASE_MANAGER would therefore go to the announcing actor itself, and the teardown would reach nobody. |
|
CM-31-009 |
MUST | This rule covers each signatory that the ledger fan-out does not reach: one removed (CM-31-001), or one at RM CLOSED that the CM-23-004 fan-out skips. When the active embargo is terminated, the CASE_MANAGER MUST send each such signatory a direct Remove(EmbargoEvent). Termination includes the case becoming public.A participant that stopped receiving case content while bound stays bound, and without this it never learns that the obligation ended early. A past-dated Announce(EmbargoEvent) is not used: its meaning would depend on the receiver's clock, and an early end is an event, not a date that passed. |
Uses definition from: CM-31-001 Supersedes: CM-23-004 |
CM-31-030 |
MUST | When a shorter revision replaces the active embargo, the CASE_MANAGER MUST send each signatory that CM-31-009 covers a direct Announce(EmbargoEvent) with the new terms. No notice is owed for a longer revision, or for expiry on the agreed date.A participant bound by the embargo must learn that its obligation shortened, and a paused replica cannot learn it from the ledger. A longer revision does not bind a participant that never agreed to it, and expiry on the agreed date is already known to it. A revision that ends at the same time as the embargo it replaces is on the EP-05-003 carry-over arm, so it is sent like a shorter one. |
Extends: CM-31-009 Supersedes: CM-23-004 |
CM-31-031 |
MUST NOT | The CASE_MANAGER MUST NOT put any other case content in a CM-31-009 or CM-31-030 notice. The notice exists only to tell a bound participant that the embargo ended or shortened. The recipient has stopped receiving case content, so anything more would leak content it is not entitled to. |
Extends: CM-31-009 Extends: CM-31-030 |
EMB-19-004 |
MUST NOT | The CASE_MANAGER MUST NOT address the teardown Announce(EmbargoEvent) (EMB-19-001) to the CASE_MANAGER.The tree that commits the teardown runs as the CASE_MANAGER, because the ledger commit is gated on that role. An announcement addressed to the CASE_MANAGER would go to the announcing actor itself and loop back for no additional record. |
Extends: EMB-19-001 |
EMB-19-003 |
MUST | The CASE_MANAGER MUST address the teardown Announce(EmbargoEvent) (EMB-19-001) to every active participant (CM-10-004) except itself.The teardown changes canonical case state, and the participants are the audience of that change. |
Extends: EMB-19-001 Uses definition from: CM-10-004 |
Recall: participant embargo consent states
| State | Meaning |
|---|---|
UNINVITED |
Not asked about this embargo; the start state of every row |
INVITED |
Asked, with no answer yet; carries that invitation's RSVP deadline |
AGREED |
Agreed to this embargo: explicitly, as its proposer, by seeding, or by carry-over |
DECLINED |
Explicitly refused this embargo, or withdrew from it |
TIMED_OUT |
Invited, and the RSVP deadline passed with no answer; not a refusal |
Full definitions are in §9.1 States.
Every one of these changes reaches the case ledger, and every replica applies it by copying.
The act's own activity carries its whole register step: a termination's entry also cancels every open proposal, and an activation's entry also supersedes the embargo it replaces.
Where the act's activity states a row itself, as the owner's Add states the owner's agreement, the act's entry carries that row.
Each other consent row that the CASE_MANAGER writes as a consequence of the act is its own CASE_MANAGER entry after the act's entry.
Examples are an UNINVITED row, the proposer's AGREED row or a CARRY_OVER.
That entry is a Create(EmbargoConsent) for a new row or an Update(EmbargoConsent) for a changed one, and it carries the row in full.
A replica copies those rows and never decides a carry-over, an expiry or a lapse itself.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CLP-07-013 |
MUST | The CASE_MANAGER MUST commit every change it makes to the case file as its own CaseLedgerEntry, never making a change that has no committed entry. The act's entry comes first. When the act's own activity states a change, that entry is the change's entry, and applying it writes only what the activity states. Examples are Add(Note)[target=VulnerabilityCase] carrying the note, and an invitee's Accept of the stub Invite marking its own consent and joining. A decision the CASE_MANAGER takes from local policy or the clock may change the case file. Such a decision is committed as the change it makes, before the change is made. A decision that changes nothing is not committed, such as noticing that a deadline has passed or that a closure is complete (ADR-0152). Moving the case's ledger position (ledgerPosition) to an entry as it is committed (SYNC-16-005) is part of applying that entry. It is not a change to the case file of its own, and takes no entry.Two replicas at the same ledger position must hold the same case file, and a replica infers nothing. If a change is not in the ledger, it did not happen (ADR-0124). One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times. Full records are ledger content that the hash chain must cover (CLP-07-006). |
Extends: CLP-07-002 Uses definition from: SYNC-16-005 |
CLP-07-021 |
MUST | Each change an act causes, beyond what the act's own activity states, MUST follow the act's entry as its own CASE_MANAGER-authored entry. The entries follow in the order the CASE_MANAGER writes them. Each one's payloadSnapshot carries the object in full (CLP-07-006). A record the change adds to one of the case's content lists (its reports, notes, statuses, vulnerability items or case references) is recorded as an Add of the record with the case as its target. Any other record the CASE_MANAGER brings into existence is recorded as a Create, and a changed record as an Update.One act can cause several changes, such as a stub Invite and the participant record it creates for the invitee. If only the act is recorded, each replica must create the record itself, with its own ids and clock times, and replicas at one ledger position then differ. Full records are ledger content that the hash chain must cover (CLP-07-006). A record that belongs to a case list needs the case as the entry's target: a Create has none, so a replica would have to decide which list the record joins, which is lifecycle logic a replica must not run (CM-23-044). The one Add both brings the record and lists it. |
Extends: CLP-07-013 See also: CLP-07-006 — context for the reader |
CM-23-016 |
MUST | A participant's case replica is the case as it stood when the replica was seeded, plus the ledger entries since. A replica MUST apply the entries in ledger order by copying the objects they carry, so replicas at one ledger position hold identical case files. The CASE_MANAGER is the single writer (ADR-0108), and the ledger records each change when the CASE_MANAGER makes it (CLP-07-013). If each replica copies what the entries carry, in the same order, two replicas at the same position hold the same case file as each other and as the CASE_MANAGER. CM-23-023 gives the rule for closure. This requirement gives it for every replicated change (ADR-0124). |
|
CM-23-044 |
MUST NOT | A replica applying an entry MUST NOT mint an id, read a clock, read local policy or state outside the case, or run lifecycle logic. Walking the RM transition table from its own stored state to a target state is such logic. A replica can find its own path from its own state, which can be out of date. It can then write an RM state that the ledger never recorded. A replica that builds a record itself gives it an id and a time that differ from those of the CASE_MANAGER. In both cases, the replicas diverge from the CASE_MANAGER (ADR-0124). |
Extends: CM-23-016 |
11.3 Status Adoption: One Authorization Gate
A participant's report does not become canonical case state on arrival. It passes one authorization point, the adoption gate, where the CASE_MANAGER decides whether the claim becomes canonical case state. That one decision also authorizes what the adopted state calls for, such as ending an embargo, so the CASE_MANAGER asks no second approval.
Adoption
A participant reports an observation by sending Add(ParticipantStatus) to the
CASE_MANAGER. A participant does not send Add(CaseStatus): writing canonical
case status is reserved to the CASE_MANAGER
(§10.1 Single-Writer Authority).
The CASE_MANAGER records the claim in the case ledger first, and then decides whether to adopt it as canonical.
Who authorizes adoption. The CASE_MANAGER adopts a Case Owner's report without seeking approval. The Case Owner is the party whose authorization the other reports need, so asking it to approve its own report would be circular. For every other sender, the protocol's default is that the CASE_MANAGER obtains Case Owner authorization before it adopts the report as canonical case state. This default is deliberate: without it, any admitted participant could force a change to canonical case state.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
RSH-07-006 |
MUST NOT | Before it adopts a P, X or A value that the Case Owner reports, the CASE_MANAGER MUST NOT ask the Case Owner to approve it. The Case Owner is the authority that RSH-07-001 asks. Asking it to approve its own report would be circular and would hold the case's canonical state on a question with only one possible answer. The report is still judged by the acceptance rules of RSH-09. |
|
RSH-07-001 |
MUST | Before it adopts a P, X or A value that a non-owner participant reports, the CASE_MANAGER MUST by default obtain the Case Owner's authorization. Adoption makes the value canonical case state. A permissive default lets any admitted participant, a hostile or defective sentinel included, force PXA adoption and start the embargo teardown with no Case Owner confirmation. So the default is conservative, and permissive behavior needs an explicit opt-in (ADR-0076). The authorization also covers the teardown the adopted value calls for (ADR-0166). The rule says what a receiver does with a reported status, so every CASE_MANAGER obeys it. The Case Owner's own report is RSH-07-006. |
A deployment where every admitted participant is trusted, and where the cost of Case Owner approval is too high, can configure a permissive policy instead. That configuration is an explicit operator choice, not a default. It is not a way to unblock a path that the gate is correctly blocking.
Not yet in main: asking the Case Owner
The reference implementation does not yet ask the Case Owner to authorize a non-owner's report. The request it would send is an authorization ask (ASK-01-001), which Known Gaps lists as not yet met, tracked by #2885. Meanwhile, the core default records a non-owner's report but does not adopt it, and asks no one. The FastAPI server makes that explicit choice: it is configured with the permissive policy, so it adopts the report without asking. A Case Owner's own report is adopted without asking, as RSH-07-006 says.
What is adopted.
The CASE_MANAGER accepts a reported status as sent or refuses all of it, and the refusal names every refused value and why.
A valid vfd update is refused with an rm value in the same report that cannot be accepted, and the sender corrects and resends the status.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
RSH-09-001 |
MUST | A CASE_MANAGER receiving an Add(ParticipantStatus)[target=CaseParticipant] MUST either accept the status whole, recording exactly the status it received, or refuse the whole update.The case ledger records what each participant asserted, and every replica copies what it records (CLP-07-013, CM-23-016). A status partly accepted is one nobody sent (ADR-0107). |
|
RSH-09-010 |
MUST NOT | The CASE_MANAGER MUST NOT record, commit or replicate a status that differs from the ParticipantStatus it received. Filling a dimension the sender omitted with a value of its own is one such difference.A status rewritten before it is recorded is one nobody sent: the ledger could then neither show what the sender claimed nor let a replica verify it (ADR-0107). An omitted dimension is absent from the status the sender sent (ADR-0075), so recording it as absent is recording the status as sent. |
Refines: RSH-09-001 |
RSH-09-002 |
MUST | When any acceptance rule refuses a received status, the CASE_MANAGER MUST refuse the whole update. It appends nothing, commits no ledger entry for it and adopts nothing from it. A status partly accepted would record one nobody sent (RSH-09-001), so a refusal by any one rule refuses the whole status. |
Refines: RSH-09-001 |
RSH-09-011 |
MUST | The CASE_MANAGER's refusal notice for a status refused under RSH-09-002 MUST name every refused dimension and the reason for each. A sender can correct an update only if it learns everything that is wrong with it in one answer (EH-07-001). Naming one reason at a time would cost a round trip per mistake. |
Extends: RSH-09-002 |
On adoption, the CASE_MANAGER commits the adopted status as its own Add(CaseStatus) case ledger entry, setting every public-state flag the report sets and clearing none.
It writes the entry directly, never by sending an Add(CaseStatus) to itself, and a receiver refuses an Add(CaseStatus) from any other sender.
Recording the claim executes no side-effect: side-effects follow the canonical write.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
RSH-01-003 |
MUST | When the CASE_MANAGER adopts the CaseStatus that a sender's ParticipantStatus embeds, it MUST record the post-adoption CaseStatus in the canonical case ledger. It records nothing when the adoption changes neither EM nor PXA (RSH-04-009).Adoption is the only path that moves the P, X or A state of a participant into the case status (RSH-04-005). Replicas learn the adopted status only from the ledger, so an adoption with no record leaves them stale. A record that copies the PXA of the case again adopts nothing. |
See also: RSH-04-009 — context for the reader |
RSH-01-005 |
MUST | The post-adoption CaseStatus of RSH-01-003 MUST set each of P, X and A that either the case's current PXA state or the adopted CaseStatus sets. It clears none that the case already sets.A record that clears a latch that the case set already undoes the report of another participant. P, X and A latch on only, so the union of the two is the only result that loses no report. |
Extends: RSH-01-003 |
RSH-04-004 |
MUST | The CASE_MANAGER MUST make the CaseStatus record of RSH-04-002 and RSH-04-003 by committing a canonical CaseLedgerEntry that carries the new CaseStatus. It then announces the entry with Announce(CaseLedgerEntry) for participant replica sync.Replicas learn of the CASE_MANAGER's own EM or PXA change only from the announced entry, so the record is a committed entry that the CASE_MANAGER announces. |
Implements: RSH-04-002 Implements: RSH-04-003 |
RSH-04-008 |
MUST NOT | The CASE_MANAGER MUST NOT adjudicate its own CaseStatus as a received message. It is the authority for its own outbound state changes.The CASE_MANAGER's own EM or PXA transition is an authoritative state change, not a received message. A received Add(CaseStatus) is admitted only from the CASE_MANAGER at a participant replica (RSH-04-005, RSH-08-003), so judging its own change as one would apply a rule meant for others. |
Extends: RSH-04-004 |
RSH-04-009 |
MUST NOT | The CASE_MANAGER MUST NOT commit or record a CaseStatus snapshot whose EM and PXA equal those of the case's last committed CaseStatus (CLP-07-013, ADR-0152). It measures the change against the ledger, not against the case's current status, which already carries the register's EM (ADR-0122).Replicas learn of a change only from the announced entry. An entry that repeats the last committed CaseStatus would hand every replica a duplicate that records no change. |
Extends: RSH-04-004 Refines: CLP-07-013 |
RSH-04-005 |
MUST | A receiver MUST refuse a received Add(CaseStatus) unless the case's CASE_MANAGER sent it to a participant.RSH-04-001 reserves Add(CaseStatus) for the CASE_MANAGER, which sends it to participants inside a case ledger entry. add_case_status_tree has no StatusAdoptionGate, so admitting it from another sender would adopt that participant's P, X or A report without the Case Owner approval RSH-07-001 requires. A participant embeds the P, X or A it reports in its own Add(ParticipantStatus) instead (RSH-04-007), which the CASE_MANAGER adopts through the gate (RSH-01-003). |
Derives from: RSH-04-001 Refines: HP-01-006 |
RSH-04-012 |
MUST | When a receiver refuses an Add(CaseStatus) under RSH-04-005, it MUST write nothing past intake and send nothing.A refused status is one the receiver must not act on. A write past intake would change case state on the refused claim, and a reply would answer a sender that had no right to send it. |
Extends: RSH-04-005 |
The default is Case Owner authorization, not automatic adoption
With a permissive default, any admitted participant could force a canonical PXA change, and through it an embargo teardown, with no Case Owner confirmation. That includes a hostile or malfunctioning participant admitted as an external monitor. A conservative default makes that a protocol guarantee rather than a deployment posture.
Side-effects
After the canonical write, the CASE_MANAGER evaluates what the new canonical state requires. When the adopted status sets Public Aware, Exploit Public, or Attacks Observed (§8.2 PXA — Public Aware, Exploit Public, Attacks Observed), the CASE_MANAGER ends an active embargo in the same act.
The check follows the canonical write, never precedes it.
What is written is the CaseStatus record that holds the case's shared EM and PXA values.
The check reads that written record, so the side-effect always follows from canonical state, not from an unadopted claim.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
RSH-03-001 |
MUST | The CASE_MANAGER MUST trigger embargo teardown when the canonical CaseStatus carries CS.P (public awareness), CS.X (exploit public), or CS.A (attacks observed). All three flags signal a breach of the conditions that justify an active embargo. Covering only CS.P (as the prior PublicDisclosureBranchNode did) leaves exploit and attack signals without a teardown trigger. |
One authorization covers the teardown
The adoption gate is the only authorization point. The Case Owner's authorization of a non-owner's P, X or A value, or the Case Owner's own report of it, also authorizes the embargo teardown that the value calls for. No second approval is asked, so the case never settles with public awareness, a public exploit or observed attacks beside an active embargo, which the cross-machine invariants of §8.3 Case State as a Compound Tuple forbid. The invariants are judged when each CASE_MANAGER act commits: inside the adopting act, the adopted status is recorded just before the termination. A policy that must delay a teardown decides at adoption, by not adopting yet. If the teardown fails for another reason, the reference implementation records the contradiction as a diagnostic note on the case rather than leaving it silent.
Where the gate model applies
The adoption gate governs any reported status. Its authorization question matters most for the participant-agnostic PXA values, which any participant may report (§13.4.2 Participant-Agnostic CS Transitions (PXA)) — including reports about other participants.
See also
12. Participant Lifecycle Within a Case [N]
A case is not a fixed set of parties. Actors join, take on roles, hand responsibilities to one another, and leave. This section specifies that lifecycle: how an actor acquires a role, how it is brought into a case, how case ownership moves, and how a participant is removed.
12.1 Role Assignment [N]
A role is granted through the case's authority chain. An actor does not acquire a case role by declaring that it holds one. The reason is that the other participants act on role claims. They send a Vendor the report content and treat a Coordinator's routing decisions as authoritative. A self-declared role would let an actor take on authority the Case Owner never granted.
- A case begins with a Case Owner — the actor whose disclosure decision the case exists to serve. Case ownership is not delegated, though it can be transferred (§12.3 Case Ownership Transfer).
- The Case Owner can offer an additional role to an actor that is already a participant.
The offer is an
Offer(CaseParticipantRole)addressed to the case's CASE_MANAGER only, never to the receiving actor. The CASE_MANAGER records the offer and forwards it to the receiving actor, which answers the CASE_MANAGER withAcceptorReject. The CASE_MANAGER records the answer and grants the role on anAccept. The Case Owner makes role offers. A CASE_MANAGER whose policy delegates role offers to it can also make one, under the same checks. The Case Owner and CASE_MANAGER roles cannot be offered. Ownership moves by transfer. How the CASE_MANAGER role is handed to another actor is not yet specified. - The CASE_MANAGER records each actor's roles on that actor's
CaseParticipantentry in the case.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-33-001 |
MUST | A Case Owner offering a role MUST address Offer(CaseParticipantRole) to the case's CASE_MANAGER only, never to the target.A participant sends case-scoped messages only to the CASE_MANAGER (PCR-08-001). An Offer that goes directly to the target bypasses the CASE_MANAGER. The CASE_MANAGER then cannot check the answer against a recorded Offer, and cannot ledger it. |
Refines: PCR-08-001 |
CM-33-007 |
MUST | When the CASE_MANAGER admits a role Offer, it MUST commit a CaseLedgerEntry for that Offer.The recorded Offer is what the CASE_MANAGER checks the target's answer against (CM-33-005). An Offer it never ledgered could not be answered. |
Extends: CM-33-001 |
CM-33-008 |
MUST | After it commits an admitted role Offer, the CASE_MANAGER MUST forward the Offer to the target, with inReplyTo set to the recorded Offer's id. The forward's actor is the CASE_MANAGER and its attributed_to the Case Owner (CM-24-001, CM-24-002).The target takes case messages from the CASE_MANAGER only (PCR-03-001), so it learns of the Offer from the forward. The inReplyTo lets the CASE_MANAGER resolve an answer to the forward back to the Offer it recorded (CM-33-005). |
Extends: CM-33-001 Refines: CM-24-001 Refines: CM-24-002 |
CM-33-009 |
MUST NOT | The CASE_MANAGER MUST NOT grant an offered role when it receives the role Offer. It grants the role when it commits the Accept (CM-02-016). An Offer is a proposal, not the grant. A role granted on the Offer would hold even if the target declined it. |
Extends: CM-33-001 See also: CM-02-016 — context for the reader |
CM-33-002 |
MUST | The CASE_MANAGER MUST refuse a received Offer(CaseParticipantRole) whose sender is not the case's Case Owner, committing no ledger entry and sending no forward.A role grant decides who runs part of the case. That is the decision of the Case Owner, as ownership transfer is (CM-02-005). |
Refines: HP-01-006 Refines: CM-02-005 |
CM-33-010 |
MAY | Where its policy delegates role offers to it, a CASE_MANAGER MAY commit a role Offer on its own case and send it to the target. The checks of CM-33-003 apply to that Offer. A Case Owner can delegate its decisions to the CASE_MANAGER in advance. The Offer is then the CASE_MANAGER's own, so it has no Case Owner's Offer to forward. |
Uses definition from: CM-33-003 |
CM-33-011 |
MAY | An implementation MAY omit the CASE_MANAGER-originated role Offer path of CM-33-010. The Case Owner path alone lets every case grant roles. Thus a path that starts at the CASE_MANAGER adds convenience, not capability, and an implementation can omit it. |
Uses definition from: CM-33-010 |
CM-33-003 |
MUST | The CASE_MANAGER MUST refuse a role Offer in any of five cases. In two, the Offer carries no readable CVD role, or it offers CASE_OWNER or CASE_MANAGER. In three, its target is not a participant in the case, already holds the offered role, or is the CASE_MANAGER itself.A grant only adds a role. Thus an accepted CASE_OWNER or CASE_MANAGER offer would give the case two holders of a role that it has exactly one of (CM-21-001, CM-02-001). Ownership moves by ownership transfer (CM-21). The CASE_MANAGER role moves only by delegation (CM-02-014), never by a role Offer, because it carries ledger authority. The CASE_MANAGER takes no other role by Offer. The forward of CM-33-008 would go to itself (BT-17-008), and the answer of CM-33-004 would also go to itself. |
Constrains: CM-02-016 |
CM-33-012 |
MUST NOT | The CASE_MANAGER MUST NOT commit a ledger entry for a role Offer that it refuses under CM-33-003. The ledger records what the case admitted. An entry for a refused Offer would read as an open Offer that the target could answer. |
Extends: CM-33-003 |
CM-33-013 |
MUST NOT | The CASE_MANAGER MUST NOT forward a role Offer that it refuses under CM-33-003. A forward invites the target to answer. A forwarded refused Offer would ask the target about a grant the case will never make. |
Extends: CM-33-003 |
CM-33-014 |
MUST NOT | An actor handling a role Offer MUST NOT read a missing CVD role as any default role. If a missing role were read as a default, the case would grant a role that nobody offered. |
Extends: CM-33-003 |
CM-33-004 |
MUST | An actor named as the target of a role Offer MUST refuse it, sending no answer, when the CASE_MANAGER did not send it. A replica takes case changes from the CASE_MANAGER only (PCR-03-001). An Offer from any other actor was never recorded by the CASE_MANAGER, so an answer to it could not be ledgered. |
Refines: PCR-03-001 Refines: HP-01-006 |
CM-33-015 |
MUST | The target of a role Offer MUST address its Accept or Reject to the CASE_MANAGER only, never to the Case Owner that made the Offer.The answer is a case-scoped message (PCR-08-001). An answer that goes only to the Case Owner is never ledgered. |
Refines: PCR-08-001 Extends: CM-33-004 |
CM-33-005 |
MUST | The CASE_MANAGER MUST act on an answer to a role Offer only when its sender is the target of an open Offer it recorded. An Offer is open until the ledger holds an Accept or Reject entry for it (CLP-11-001). The answer decides if the role is granted. Thus only the actor that received the Offer can give the answer, and only one time. The check uses the Offer that the CASE_MANAGER recorded, never the copy in the answer. CM-11-017 and CM-21-011 do the same check. |
Refines: HP-01-006 Refines: CLP-11-001 |
CM-33-016 |
MUST | The CASE_MANAGER MUST refuse an answer that CM-33-005 does not let it act on, committing no ledger entry and changing no role. An entry or a role change made for a refused answer would grant, or record as decided, an Offer its target never answered. |
Extends: CM-33-005 |
CM-33-017 |
MUST | The CASE_MANAGER MUST resolve an answer that names its forward to the recorded role Offer through the forward's inReplyTo.The target answers the forward it received, which the CASE_MANAGER sent, not the Case Owner's Offer. Only the stored forward's inReplyTo links that answer to the recorded Offer. |
Extends: CM-33-005 |
CM-33-018 |
MUST | The CASE_MANAGER MUST report a redelivery of the answer that closed a role Offer as SKIPPED (HP-01-014).A redelivery is the same answer again, not a new one. Reporting it REFUSED would tell the target its answer was declined after it was admitted. |
Extends: CM-33-005 Refines: HP-01-014 |
CM-33-006 |
MUST | When the CASE_MANAGER admits an answer to a role Offer under CM-33-005, it MUST commit a CaseLedgerEntry for it (accept_case_participant_role or reject_case_participant_role).A participant's answer to an Offer is a case event (CLP-02-016), so it is ledgered as all other case events are. |
Uses definition from: CLP-02-012 Refines: PCR-08-003 Extends: CM-33-005 |
CM-33-019 |
MUST | When the CASE_MANAGER commits an answer to a role Offer under CM-33-006, it MUST broadcast Announce(CaseLedgerEntry) to the case's participants.Replicas learn of a granted role only when they replay the announced entry (CM-02-016, RSH-08-004). Thus if the answer is not announced, the roles in every replica are out of date. |
Extends: CM-33-006 |
CM-33-021 |
MUST NOT | The CASE_MANAGER MUST NOT change any role when it commits a Reject of a role Offer.A Reject declines the Offer, so the target's roles stay as they were. |
Extends: CM-33-006 |
Together these rules mean that an actor holds only a role it accepted, from an offer that the Case Owner made, or that a CASE_MANAGER made where its policy delegates role offers to it.
The role an Accept grants is the one the recorded offer names, not one the accepting actor's reply names.
Otherwise, an actor could widen its own grant on the way back.
An invitee's roles are those its stub Invite names, recorded when the CASE_MANAGER sends that Invite (§12.2 Invitation and Acceptance).
An implementation can check that an actor has the capability prerequisites for a role (§13.3.1 Process Roles) before completing the assignment.
Open question: acquiring a role after joining a case
This specification says how the Case Owner offers a role to a participant, and how the participant accepts or declines the offer. It does not say how a participant already in a case asks for an additional one.
A participant admitted as a Vendor that later also needs the Coordinator role has no protocol path to request it.
In practice the request is made out of band, or as an Add(Note) on the case, and the Case Owner then issues a role offer.
Neither is a specified mechanism.
Open: whether the protocol should define a role-request activity, whether a participant may give up a role it already holds, and how a role that is removed rather than added is represented in the case history.
12.2 Invitation and Acceptance [N]
Bringing a new actor into a case has a problem to solve. The actor cannot decide whether to join until it knows something about the case. However, until it is an active participant it receives no case content. Being in the case's participant list does not make it one (§9.7 Gating Full Case Delivery).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-10-004 |
MUST | The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(Actor)[target=VulnerabilityCaseStub])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122). |
Uses definition from: CM-14-001 Uses definition from: CM-18-001 Uses definition from: CM-31-001 |
CM-17-005 |
MUST NOT | Presence in the case participant list MUST NOT be treated as acceptance of the invitation or as entitlement to case content. An invitee is in the list from the stub Invite onward (CM-11-006); only an active participant (CM-10-004) is entitled to case content. The CASE_MANAGER tracks every invitee from the moment it is invited, including one that declines, so the participant list holds inert participants. Any consumer that reads membership as "accepted" would hand case content to an actor that has not consented. |
Uses definition from: CM-10-004 See also: CM-11-006 — context for the reader |
The protocol solves this with a case stub: a minimal stand-in for the case that carries enough for the invitee to decide, and no vulnerability detail.
The stub is its own object, of type VulnerabilityCaseStub, and is not the case.
A sender's stub carries exactly the required fields and, while an embargo is in force, the embargo fields.
Every stub carries these required fields:
id: the stub's own identifier, which is the case's identifier with/stubappended. A receiver never derives the case from it.type:VulnerabilityCaseStub. A receiver tells a stub from a case by itstypealone.caseId: the identifier of the case the stub stands for.summary: required human-readable context saying what the invitee is being asked to join. The sender chooses it. It may be the case name, or a deliberately less revealing string. The case name itself can be sensitive to share with an actor not yet bound by the embargo. A receiver refuses a stub without asummary(MV-10-001).
A stub carries these fields only while an embargo is in force:
activeEmbargoandcaseStatus: present whenever an embargo is in force, that is, while the embargo state isACTIVEorREVISE. They state the embargo terms the invitee would agree to by accepting: the embargo in force and the case's embargo state. ThecaseStatusalso carries itspublishedtime, as every case status does, and a receiver refuses one without it (CLP-15-010). During a revision the stub carries the embargo in force, never the open revision, which the invitee receives after joining. The stub may carry the embargo inline or name it by an identifier the invitee can ask the inviter to resolve. The reference implementation always carries the full embargo inline, because it does not build that lookup.
The sender sets no other field. The reference implementation's stub object does accept more on receipt, all optional:
publishedandupdated: the times the stub itself was created and last changed.- The generic ActivityStreams object fields it inherits, such as
nameandcontent.
The reference implementation sets none of these on a stub it sends.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-11-013 |
MUST | A case stub MUST carry its own wire type, VulnerabilityCaseStub, and its own ID, the case's ID with /stub appended.A receiver classifies an activity by its shape. Sharing the case's type and ID made the stub Invite and the full-case Invite indistinguishable (ADR-0114). |
|
CM-11-037 |
MUST | A case stub MUST name the case it stands for in a field of its own. A receiver must find the case without parsing the stub's ID (CM-11-003). Parsing one ID out of the other would couple every receiver to the ID scheme. |
Extends: CM-11-013 |
CM-11-038 |
MUST | A receiver MUST classify a case stub by its type, never by which fields it carries or by parsing its ID.A sparse case and an enriched stub can carry the same fields, so only the type tells them apart. A classifier that read the fields would take a sparse VulnerabilityCase for a stub (ADR-0114). |
Depends on: CM-11-013 |
CM-17-010 |
MUST | A sender's case stub MUST carry exactly id, type, caseId (CM-11-013), a non-empty summary (MV-10-001) and, with an embargo in force, the CM-17-002 embargo terms. The JSON-LD @context is not content.An invitee is not yet entitled to case content (CM-10-004, CM-17-005). For informed consent, the invitee needs the case's identity, a summary that a person can read of what it is asked to join, and the embargo terms (CM-17-002). |
Uses definition from: CM-11-013 Refines: MV-10-001 Uses definition from: CM-17-002 |
CM-17-020 |
MAY | The sender chooses the stub's summary, which MAY be the case name or a deliberately less revealing string.The case name can be an opsec risk. Thus the sender writes the summary for the invitee, and does not have to copy it from the case. |
Uses definition from: CM-17-010 |
CM-17-021 |
MUST NOT | The sender MUST NOT assume the case name is safe to share with an invitee not yet bound by the embargo. The case name can reveal what the embargo protects. An invitee that has not joined has not agreed to the embargo, so the sender decides what the stub's summary reveals to it. |
Extends: CM-17-020 |
CM-17-022 |
MUST NOT | A sender MUST NOT put any other case content in a case stub. An invitee is not yet entitled to case content (CM-10-004, CM-17-005). This constrains what is sent. |
Derives from: CM-17-010 |
CM-17-023 |
MUST NOT | A sender MUST NOT name the case's coordinator or Case Owner in a case stub. The Invite that carries the stub already identifies the inviter in its actor and attributedTo. If the stub named the coordinator or the Case Owner, it would repeat what the Invite states. |
Derives from: CM-17-010 |
CM-17-002 |
MUST | This rule covers a stub Invite sent while an embargo is in force. Then EM is ACTIVE or REVISE, and the case's embargo register holds an ACTIVE entry. Its case stub MUST carry the active embargo (activeEmbargo), inline or by an ID that the invitee can ask the inviter to resolve.The invite-accept cycle is the only consent signal for a late joiner. An Accept without the embargo terms is not informed consent (CM-11-001). The invitee has only the invitation, so the invitation must let it learn the terms before it accepts: inline in the stub, or by the ID that the stub names. CM-17-011 says which form this prototype sends. In EM REVISE, the prior embargo stays in force (EP-05-002), so the invitee needs its terms then too. |
Extends: CM-17-001 Derives from: CM-11-001 |
CM-17-013 |
MUST | When an embargo is in force as the CASE_MANAGER sends a stub Invite, the case stub MUST carry the case's EM state (caseStatus.emState).The EM state tells the invitee whether a revision of the embargo is open. In EM REVISE, the invitee learns from it that a proposal is pending, which it receives after it joins (EP-09-011). The caseStatus is a CaseStatus, so it also carries the published time every status carries (CLP-15-010). |
Extends: CM-17-002 |
CM-17-014 |
MUST NOT | A case stub MUST NOT carry an open embargo revision proposal. The invitee learns of the proposal from caseStatus.emState and receives it after joining (EP-09-011).The revision is not yet binding, and CM-17-022 keeps other case content out of the stub. When the joiner holds the case, EP-09-011 relays to it each open proposal that it has not answered. |
Extends: CM-17-002 See also: EP-09-011 — context for the reader |
EP-09-011 |
MUST | When the CASE_MANAGER admits a participant (Accept(Invite(Actor)[target=VulnerabilityCaseStub])) while an embargo proposal is open, it MUST relay an Invite(EmbargoEvent) for every open proposal to the joiner and commit each as a ledger entry, after the joiner holds the case and the prior ledger. Each Invite has actor set to the CASE_MANAGER's ID and attributedTo set to the proposal's original proposer (EP-09-002). A proposal whose consent row for the joiner has already left UNINVITED is not relayed again. Every participant holds a row for every register entry (CM-18-001). The row's state, not its presence, says whether the joiner was asked. The joiner's row for the active embargo is unchanged (EP-09-004), so a joiner that accepts the revision is a signatory of it at activation and one that does not lapses (ADR-0093, EP-05-001).A joiner is seated after the relay of a proposal (EP-09-002), so it was never on the roster when the Invite went out, and nothing else would ask it. A new participant becomes a signatory to the embargo in effect when it joins, and is asked about a revision on the table exactly like the participants who were present when it was proposed. |
Uses definition from: EP-09-002 Uses definition from: CM-18-001 See also: EP-05-001 — context for the reader See also: EP-09-004 — context for the reader |
MV-10-001 |
MUST | A stub object MUST carry at minimum an id field (full URI), a type field and a non-empty summary field that gives human-readable context.The stub form has one narrow purpose. It is not a replacement for a full object. An invitee must decide whether to join a case before it can receive the case (MV-10-005). The stub represents the case until the participant is active (CM-10-004). The summary tells the invitee which case it is asked to join. The sender decides what the summary says (CM-17-020). |
The stub does not name the case's coordinator or Case Owner.
The Invite that carries the stub already identifies who is asking: its actor is the CASE_MANAGER, and its attributedTo can name the Case Owner.
Full content follows only after the invitee accepts.
Two paths bring an actor into a case, and they differ in who initiates.
Direct invitation.
The CASE_MANAGER sends Invite(Actor)[target=VulnerabilityCaseStub] to the actor.
At the same time, it records the invitee in the case as an inert participant at RM Received.
The CASE_MANAGER commits the record's creation to the case ledger, and a replica applying that entry creates the same inert record.
The record is not yet an active participant: it does not receive case content and is not included in embargo fan-out.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-11-006 |
MUST | When the CASE_MANAGER sends a stub Invite (Invite(Actor)[target=VulnerabilityCaseStub]), it MUST create the invitee's CaseParticipant in the same step. The participant is inert (CM-10-004).The CASE_MANAGER needs to track every invitee from the moment it is invited — whether it has been told and how it answered — including the invitees that decline (ADR-0114). |
Uses definition from: CM-10-004 |
CM-11-026 |
MUST | The CaseParticipant a stub Invite creates MUST hold the Invite's roles, RM RECEIVED, VF v (VENDOR), and an INVITED row for an active embargo.The invitee has been told of the case and has decided nothing. RM RECEIVED and VF v record exactly that. The INVITED row records that it was asked about the embargo in force and has not answered (CM-18-001). |
Extends: CM-11-006 |
CM-11-023 |
MUST | When it sends a stub Invite, the CASE_MANAGER MUST commit its own create_case_participant (Create(CaseParticipant)) entry, 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 |
CM-11-024 |
MUST | The create_case_participant 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 create_case_participant entry carries it, and derive none of it from the Invite's entry.Replicas copy; they never mint ids, read clocks or run lifecycle logic (ADR-0124). A record a replica derived could differ from the CASE_MANAGER's in an id or a time, and the copies of the case would then disagree. |
Depends on: CM-11-024 |
The actor answers Accept(Invite) or Reject(Invite).
Accept(Invite) joins the actor to the case at RM Received and, where an embargo is in force, records its consent to those terms, unless it had already declined them.
A participant that has now agreed to the embargo in force, or joins a case with none, is active, and the CASE_MANAGER delivers the case (§11.1 Admitting a Participant).
A participant that had declined the embargo joins but stays inert until it agrees.
Reject(Invite) closes the inert record (RM Received → Closed) and keeps it as history, so the CASE_MANAGER can see that the invitation was extended and declined.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-11-001 |
MUST | When a participant accepts the stub Invite (Accept(Invite(Actor)[target=VulnerabilityCaseStub])), the CASE_MANAGER MUST leave the participant's RM state at RM.RECEIVED, set its VF state to V when it holds the VENDOR role, and, when an embargo is active, mark its consent row for that embargo AGREED, making it a signatory. A DECLINED row is the exception, and the CASE_MANAGER leaves it unchanged: an explicit refusal outranks the consent that joining implies. Accepting the stub is joining the case and, unless the row is DECLINED, consenting to the active embargo. It is not a judgement of the case.The invitee has seen only the stub. It judges the case later, in its replies to the full-case Invite (CM-11-010, CM-11-011), so the record of the CASE_MANAGER shows no decision that the invitee has not made. To join under an active embargo is to take part under it. Thus no participant becomes active without a recorded answer to the embargo, and the delivery gate of MV-10-005 relies on this. |
Uses definition from: CM-10-001 Extends: BT-10-005 |
CM-11-007 |
MUST | A stub Invite has exactly two valid replies, Accept (CM-11-001) and Reject. On Reject(Invite(Actor)[target=VulnerabilityCaseStub]), the CASE_MANAGER MUST close the participant and keep its record, which stays inert. Closing it moves its RM state to RM.CLOSED, sets VF V for a VENDOR, and records consent DECLINED when an embargo is active.A stub reject is a hard no to joining. Keeping the record keeps the history that the actor was told and declined, which is what the early record exists for. |
See also: CM-11-001 — context for the reader |
CM-11-027 |
MUST | A replica MUST apply a stub Reject from two entries: the invitee's reject_invite_actor_to_case, which carries the DECLINED row, and the CASE_MANAGER's add_participant_status_to_participant closing status.The invitee's Reject is a message, so it is its own ledger entry, and it is the entry for the DECLINED row. A replica applies that row through the same write the CASE_MANAGER uses. The closing status is the CASE_MANAGER's own act, with an entry of its own that a replica stores. Each replica then holds the record the CASE_MANAGER holds (ADR-0114, ADR-0124). |
Extends: CM-11-007 |
CM-11-028 |
MUST | The CASE_MANAGER MUST refuse TentativeReject(Invite(Actor)[target=VulnerabilityCaseStub]).Accepting the stub is not a judgement of the case, so there is nothing for a tentative reject to say. Only the full-case Invite asks for a judgement (CM-11-011). |
Derives from: CM-11-007 |
Every stub Invite carries a reply deadline.
When it passes unanswered, the Invite closes as expired and the record is left unchanged: still inert, at RM Received, with its embargo consent row still INVITED.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-11-014 |
MUST | A stub Invite MUST carry a reply deadline. An invitee that never answers must not hold the CASE_MANAGER in an open wait for ever. The deadline tells both sides when the ask ends (ADR-0114). |
|
CM-11-039 |
MUST | When a stub Invite's deadline passes unanswered, the CASE_MANAGER MUST close the Invite as an expired ask. An expired ask is over. Closing it ends the CASE_MANAGER's wait for an answer, so the case does not wait on an invitee that never replies (ADR-0114). |
Extends: CM-11-014 |
CM-11-040 |
MUST NOT | When a stub Invite expires unanswered, the CASE_MANAGER MUST NOT change the invitee's record, which stays inert at RM.RECEIVED with its consent row INVITED.RM is the participant's own judgement (ADR-0121), so a timeout cannot stand in for one. The CM-18-002 time-out to TIMED_OUT applies to an Invite(EmbargoEvent), not to the embargo terms a stub Invite carries, so the consent row stays INVITED. |
Extends: CM-11-039 |
CM-11-041 |
MUST | A case-wide closure check ("all participants closed") MUST count only joined participants: those seated by case initialization (CM-14-001) or that accepted their stub Invite. An invitee that never answered must not keep the case from closing (ADR-0114). An invitee that has not joined has made no judgement, so it has nothing to close. |
Uses definition from: CM-10-004 Uses definition from: CM-14-001 |
After joining, the participant judges the case by answering the full-case Invite, not the original report Offer.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-11-011 |
MUST | The CASE_MANAGER MUST record each full-case Invite reply as a move from RM.RECEIVED: RV Accept to RM.VALID, RI TentativeReject to RM.INVALID, RC Reject to RM.CLOSED.Each reply is the participant's own judgement of the case (ADR-0121). The three replies map to the three RM triage outcomes, so every replica records the judgement the participant made. |
|
CM-11-034 |
MUST | A reply to the full-case Invite MUST carry the replier's own ledger position: the log_index and entry_hash of its tail when it decided.The position is the reply's ledgerPosition, the property every case activity carries (VAM-04-012..014, SYNC-18-001, ADR-0156), so the CASE_MANAGER judges it against the Invite's floor (CM-11-012) from the one field it reads on every case activity. |
Extends: CM-11-011 |
CM-11-020 |
MUST NOT | A participant that joined a case through an Invite MUST NOT send Accept, TentativeReject or Reject of the original Offer(VulnerabilityReport).A reply must answer a message sent to the replier. A joined participant was never offered that report. |
|
CM-11-051 |
MUST NOT | A participant that joined a case through an Invite MUST NOT validate, invalidate or reject the case's report. It judges the case by replying to the full-case Invite (CM-11-011). A joined participant — a late joiner especially — judges the case as it stands, with its history, not the original submission, which may have been far sparser (ADR-0121). |
Extends: CM-11-020 See also: CM-11-011 — context for the reader |
Suggested actor.
An existing participant proposes a third party — "this vendor is also affected" — by sending Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER.
The CASE_MANAGER records the suggestion and passes it to the Case Owner as Offer(CaseParticipant)[target=VulnerabilityCase].
The suggestion is a recommendation, not an invitation: the Case Owner decides whether to act on it.
If the Case Owner accepts, the CASE_MANAGER then sends the stub Invite above.
The CASE_MANAGER takes the actor to invite and its roles from the offer it recorded, never from the Case Owner's reply.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-16-001 |
MUST | A participant wishing to suggest that another actor be invited to the case MUST send Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER's inbox, not directly to the Case Owner's inbox.All case-scoped protocol messages MUST route through the CASE_MANAGER so the event can be recorded in the canonical case ledger before any downstream action is taken (ADR-0021, PCR-08-001). |
Refines: PCR-08-001 |
CM-16-004 |
MUST | The CASE_MANAGER MUST transform the received Offer(Actor) into Offer(CaseParticipant)[target=VulnerabilityCase], whose CaseParticipant has attributed_to set to the actor and case_roles set to the roles, and send it to the Case Owner's inbox, with origin set to the ID of the original recommender's Offer activity.The Case Owner makes a membership decision about a CaseParticipant (actor + roles), not about a bare Actor identity. The origin field preserves the causal chain without a side-channel data store. |
|
CM-16-006 |
MUST | After it receives Accept(Offer(CaseParticipant)) from the Case Owner, the CASE_MANAGER MUST take four steps. (1) It commits a ledger entry for the Accept. (2) It fans out the ledger entry. (3) It sends the original recommender an Accept of its Offer(Actor)[target=VulnerabilityCase], with in_reply_to set to that Offer's ID. (4) It sends the suggested actor the stub Invite (Invite(Actor)[target=VulnerabilityCaseStub], CM-11-013) per CM-17.The ledger records the Case Owner's decision before any step acts on it (CLP-10-006). Thus every replica sees the cause before its effects. The recommender waits for an answer to its Offer, and in_reply_to tells it which suggestion the answer closes. |
Uses definition from: CM-17-001 See also: CM-11-013 — context for the reader |
CM-16-021 |
MUST | When the suggested actor has joined or is at RM.CLOSED, the CASE_MANAGER MUST refuse the Accept(Offer(CaseParticipant)) before committing or sending anything, with a reported reason.The CASE_MANAGER refuses an Accept for an actor that joined or is at RM.CLOSED. This keeps one participant record for each actor, and keeps RM.CLOSED terminal (CM-11-043). The refusal comes first, so nothing of the Accept is recorded or sent. |
Supersedes: CM-16-006 |
CM-16-018 |
MUST | When the CASE_MANAGER processes Accept(Offer(CaseParticipant)) from the Case Owner, the roles assigned to the new participant MUST be read from the stored outgoing Offer(CaseParticipant) that the CASE_MANAGER constructed and sent — not from the embedded CaseParticipant object inside the received Accept.The received Accept is untrusted: the accepting actor may have modified or omitted roles, or sent only a bare ID reference. Reading roles from the received Accept would allow a malicious or minimally-conformant acceptor to substitute unauthorized roles. The stored Offer is the CASE_MANAGER's own record of the intended participant roles and is the authoritative source of truth. |
Constrains: CM-16-006 |
CM-16-019 |
MUST | The CASE_MANAGER MUST refuse Accept(Offer(CaseParticipant)) or Reject(Offer(CaseParticipant)) from any sender but the case's Case Owner, and then invite no one and notify no recommender.The Case Owner decides about a recommendation (CM-16-006). If any sender could answer it, any actor that knows a recommendation id could accept it, and the CASE_MANAGER would invite whoever that actor chose (HP-01-006). |
Refines: HP-01-006 Constrains: CM-16-006 |
CM-16-023 |
MUST | The CASE_MANAGER MUST take the actor to invite from the Offer(CaseParticipant) it recorded, never from the Case Owner's reply.The reply carries a copy of the Offer, and the copy is the sender's claim. Assume that the CASE_MANAGER checked only that the recommendation is recorded, and read the invitee from the reply. Then the reply could choose the invitee. The recorded Offer is the CASE_MANAGER's own record (CM-16-018). |
Extends: CM-16-019 |
Both paths converge on Accept(Invite).
The suggested-actor path adds one round-trip, because the Case Owner's decision sits between the proposal and the invitation.
Recall: report management states
| State | Meaning |
|---|---|
| Start | No report has been received |
| Received | A report has arrived; triage is not yet complete |
| Invalid | This participant assessed the report as invalid |
| Valid | This participant assessed the report as valid |
| Deferred | This participant is deferring further action |
| Accepted | This participant accepted the report for active work |
| Closed | This participant closed the report |
Full definitions are in §6.1 States.
12.3 Case Ownership Transfer [N]
The Case Owner can transfer ownership to another participant through an
Offer(VulnerabilityCase) / Accept handshake routed through the CASE_MANAGER.
The Case Owner proposes the transfer to the CASE_MANAGER as Offer(Offer(VulnerabilityCase)), and the CASE_MANAGER makes the one Offer(VulnerabilityCase) the receiving actor answers.
The receiving actor is one already entitled to the case's content and holding the case, which the Offer names by reference: an active participant.
An owner that means to transfer a case to any other actor invites that actor first.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-21-005 |
MUST | A Case Owner MUST propose an ownership transfer by sending Offer(Offer(VulnerabilityCase)), with the case as context, to the CASE_MANAGER only, never to the transferee (PCR-08-001).Routing the transfer through the CASE_MANAGER lets it ledger the offer in flight and broadcast it to every active participant (CM-10-004), so no participant is unaware a transfer is being negotiated. The CASE_MANAGER cannot be the transferee: its Offer would have itself as its only recipient, which BT-17-008 forbids, the same ground on which CM-33-003 refuses a role offer to it. |
Refines: PCR-08-001 |
CM-21-025 |
MUST | The inner Offer of an ownership-transfer proposal MUST name the case as its object and the transferee as its target. It optionally carries the deadline to answer as its end_time (CM-21-016).The inner Offer says what the owner asks the CASE_MANAGER to offer and to whom. Without the case and the transferee in it, the CASE_MANAGER cannot make the Offer the owner asked for (CM-21-028). |
Extends: CM-21-005 Uses definition from: CM-21-016 |
CM-21-026 |
MUST | The CASE_MANAGER MUST refuse an ownership-transfer proposal, with no ledger commit and no outbound Offer, unless its inner Offer passes two checks. The inner Offer's object is the proposal's case. Its target is an actor the CASE_MANAGER can address (present, neither itself nor the proposer) and an active participant of the case (CM-21-021).A proposal is a request the CASE_MANAGER acts on. An inner Offer that names another case, or a transferee the CASE_MANAGER cannot address, would make an Offer nobody can answer, or one about a case the proposal did not concern. |
Extends: CM-21-005 Uses definition from: CM-21-021 |
CM-21-027 |
MUST | When it admits an ownership-transfer proposal, the CASE_MANAGER MUST ignore any id, actor or to inside the inner Offer.The CASE_MANAGER makes the Offer itself (CM-21-028). An id, actor or recipient list that the owner wrote into the inner Offer would let the owner choose fields that only the CASE_MANAGER sets, such as an id that collides with a stored object. |
Extends: CM-21-005 |
CM-21-028 |
MUST | On admitting a proposal, the CASE_MANAGER MUST make the single ownership-transfer Offer(VulnerabilityCase) itself, under an id it derives from the proposal, addressed to the transferee. The Offer's actor is the CASE_MANAGER and its attributed_to the owner (CM-24-001, CM-24-002).Making the Offer itself rather than forwarding the owner's gives a transfer one Offer, under an id no other party chose, told apart from the proposal by its shape (ADR-0148, DL-06-006). |
Extends: CM-21-005 Refines: CM-24-001 Refines: CM-24-002 |
CM-21-029 |
MUST | The CASE_MANAGER MUST ledger the Offer it made from a proposal once that Offer is in its outbox (SYNC-09-002). That Offer is the one that is ledgered, answered, closed and expired. Ledgering the Offer after it is queued keeps the ledger from recording an Offer that was never sent. One ledgered Offer gives every reader one transfer to answer, close or expire (CM-21-014). |
Extends: CM-21-028 Refines: SYNC-09-002 |
CM-21-021 |
MUST | The CASE_MANAGER MUST refuse an ownership-transfer proposal (CM-21-005) whose transferee may not act on the case, with no ledger commit and no Offer made. A transferee may act when it is an active participant (CM-10-004) whose closure the case's ledger does not record (CM-23-018). An owner that means to transfer a case to an actor not active in it invites that actor first. The new owner administers the case, its active embargo included, so it must first have agreed to that embargo and be entitled to the case content, as joining requires. An active participant holds the case, which is also what lets the Offer name the case by reference rather than carry it (ADR-0165). CASE_OWNER is held on a participant record (CM-21-002), so only a transferee with one can end the transfer as the single owner CM-21-001 requires. A closed participant stays active by CM-10-004, but it receives no further case content (CM-23-004) and may not act on the case (CM-23-018), so it cannot take the case on. The test is the one every sender guard and case-content selection uses, may_act_on_case in vultron/core/participants/recipients/sender_standing.py. |
Extends: CM-21-005 Uses definition from: CM-10-004 Uses definition from: CM-23-018 |
CM-21-022 |
MUST | The CASE_MANAGER MUST refuse, with ownership unchanged, the transferee's Accept(Offer(VulnerabilityCase)) (CM-21-011) when the transferee may no longer act on the case (CM-21-021) as the Accept is processed. Ownership unchanged means the case's attributed_to and every participant's CASE_OWNER role stay as they were.The proposal check (CM-21-021) runs when the Offer is made. A participant can be removed, lapse by an embargo revision, or close between the Offer and its answer, so the Accept is checked again with the same test, may_act_on_case. A closed transferee's Accept is also refused by its sender check (CM-23-018). |
Extends: CM-21-011 Uses definition from: CM-21-021 |
On acceptance, the receiving actor acquires Case Owner authority and the associated protocol responsibilities. The previous owner loses the Case Owner role, and keeps its other roles and its place in the case.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-21-011 |
MUST | The CASE_MANAGER MUST refuse an Accept(Offer(VulnerabilityCase)), leaving the owner unchanged, unless its sender is the transferee of an unanswered Offer it recorded for the case. The owner is the case's attributed_to and every participant's CASE_OWNER role.Without the match to a recorded, unanswered Offer, a receiver takes the sender of the Accept to be the new owner. Then any actor that knows a case id can claim ownership at every receiver that holds the case. |
Refines: HP-01-006 Supersedes: CM-21-002 |
CM-21-031 |
MUST | A participant replica MUST apply an ownership change only when it comes from the CASE_MANAGER (PCR-03-001). A replica that takes the change only from the CASE_MANAGER keeps one authority for the owner of the case (PCR-03-001). A transferee's Accept sent to a replica would otherwise move ownership there without the CASE_MANAGER. |
Refines: PCR-03-001 |
CM-21-002 |
MUST | When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST add CASE_OWNER to the accepting actor's case_roles.Role-gated nodes such as CheckIsCaseOwnerNode read Case Owner authority from CaseParticipant.case_roles. A transfer that did not grant the role would leave a new owner whose CASE_OWNER-gated acts are refused, such as embargo teardown and case closure. |
|
CM-21-024 |
MUST | When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST update the case's attributed_to to the accepting actor's ID.attributed_to is the owner that the case names to every reader (MSM-07-027). A transfer that grants the role (CM-21-002) but leaves attributed_to alone makes the case name an owner that no longer holds the role. Thus a transfer writes both. |
Extends: CM-21-002 |
CM-21-003 |
MUST | When an Accept(Offer(VulnerabilityCase)) ownership-transfer activity is processed, the system MUST remove CASE_OWNER from the previous owner's case_roles.Transferring ownership does not evict the previous owner from the case; they continue to participate but no longer hold administrative authority. Stripping only CASE_OWNER (and not other roles) preserves their standing as a Coordinator, Vendor, or other role while satisfying the at-most-one invariant (CM-21-001). |
Implements: CM-21-001 |
CM-21-008 |
MUST | When an ownership transfer is processed, the previous owner MUST retain any other roles they held (e.g., COORDINATOR, VENDOR) in their case_roles.Stripping only CASE_OWNER (and not other roles) preserves the previous owner's standing as a Coordinator, Vendor, or other role while satisfying the at-most-one CASE_OWNER invariant (CM-21-001). |
Extends: CM-21-003 |
CM-21-009 |
MUST | When an ownership transfer is processed, the previous owner MUST remain a participant in the case. Ownership transfer is not case departure. The previous owner has institutional knowledge of the case and continues to participate; only their administrative authority is transferred. |
Extends: CM-21-003 |
Open: cryptographic identity across a change of CASE_MANAGER
Authority over the canonical ledger follows the CASE_MANAGER role, not any
actor's name or Uniform Resource Identifier (URI). Transferring case ownership, or moving the
CASE_MANAGER role to a different actor, therefore does not by itself
re-key the ledger.
What remains open is key handover. A future case-encryption design needs to define how the keys protecting existing case content pass to the new role holder. It also needs to define what a participant does with ledger entries it can no longer decrypt. This specification states no rule for either.
12.4 Participant Removal [N]
Removing a participant withdraws its entitlement to case content. It does not delete the participant from the case. The participant's record, its status history, and the ledger entries it authored stay in the case, and the record carries a removal fact. A removed participant is inert: it receives no case content, and it has no authority to act on the case.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-001 |
MUST | An actor that applies a participant's removal MUST record a removal fact on the participant's CaseParticipant.Removal is a decision about entitlement to case content, not about membership. Thus it is a fact on the record that the active check reads (ADR-0116). |
|
CM-31-015 |
MUST NOT | An actor that applies a participant's removal MUST NOT delete the participant's record from case_participants.If the record is deleted, the case loses the history of who took part. Ledger entries then name an actor that is not on the roster (ADR-0116). |
Extends: CM-31-001 |
CM-31-016 |
MUST | An actor that applies a participant's removal MUST keep the participant's status history and the ledger entries it authored. The status history and the authored entries are the record of what the participant did in the case. Removal withdraws entitlement from now on; it does not rewrite the past (ADR-0116). |
Extends: CM-31-001 |
CM-31-017 |
MUST | Every actor MUST treat a removed participant as inert (CM-10-004). A removed participant has lost its entitlement to case content. If any actor still treated it as active, it would keep receiving embargoed content. |
Extends: CM-31-001 Uses definition from: CM-10-004 |
Only the Case Owner requests a removal.
It sends Remove(CaseParticipant)[target=VulnerabilityCase] to the CASE_MANAGER, which applies it.
The CASE_MANAGER refuses the request in each of these cases:
- the sender does not hold the Case Owner role;
- the request names the CASE_MANAGER's or the Case Owner's participant;
- the request names no participant of the case.
A second removal of an already-removed participant is a no-op, and the CASE_MANAGER reports it as skipped.
The CASE_MANAGER never removes a participant on its own initiative.
A participant that wants to stop taking part leaves the case with Leave(VulnerabilityCase); that is not removal.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-004 |
MUST | Remove(CaseParticipant)[target=VulnerabilityCase] is the Case Owner's request to the CASE_MANAGER to remove a participant from active participation. The CASE_MANAGER MUST refuse such a request in three cases. The sender does not hold CASE_OWNER, the named participant holds CASE_MANAGER or CASE_OWNER, or the request names no participant of the case.The Case Owner decides who takes part in the case; the CASE_MANAGER applies case changes and decides none (ADR-0108). The CASE_MANAGER role is never unfilled (CM-02-014), and the Case Owner leaves only by transferring ownership (CM-21). A participant that wants to stop taking part sends Leave(VulnerabilityCase) (CM-23), not Remove. |
|
CM-31-022 |
MUST | The CASE_MANAGER MUST report a removal of an already-removed participant as skipped. A repeated removal changes nothing, so it is neither applied nor refused. A skipped result tells the Case Owner that the participant is already removed, and the CASE_MANAGER commits no second entry and sends no second notice. |
Extends: CM-31-004 |
CM-31-023 |
MUST NOT | The CASE_MANAGER MUST NOT remove a participant on its own initiative. The Case Owner decides who takes part in the case; the CASE_MANAGER applies case changes and decides none (ADR-0108). |
Extends: CM-31-004 |
An accepted removal is one ledger entry: the Case Owner's received Remove(CaseParticipant), committed by the CASE_MANAGER as received.
The CASE_MANAGER commits no second entry of its own for the same removal.
After the commit, the CASE_MANAGER sends the removed participant a direct Remove(CaseParticipant) that names it.
The notice has actor set to the CASE_MANAGER and attributedTo set to the Case Owner.
This notice is delivery, not a record, and is not ledgered.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-005 |
MUST | The CASE_MANAGER MUST record an accepted removal by committing the Case Owner's received Remove(CaseParticipant) as its entry, on receipt (CLP-10-006).The Remove states the change, so it is the change's entry (CLP-07-013), authored by the actor that made it. The ledger therefore shows the removal as the Case Owner's decision rather than the CASE_MANAGER acting alone (ADR-0108). |
See also: CLP-10-006 — a pointer for "on receipt"; committing the received Remove does not need the receive-tree commit ordering |
CM-31-024 |
MUST | Remove(CaseParticipant) MUST be a ledgered activity, with a canonical ledger signature.Without the canonical signature a removal cannot be committed, so it never reaches a replica. |
Extends: CM-31-005 |
CM-31-025 |
MUST NOT | The CASE_MANAGER MUST NOT commit a second entry of its own for a removal that it records under CM-31-005. The Case Owner's Remove is already the change's entry. A second entry would record the same move twice and show it as the CASE_MANAGER's own act. |
Extends: CM-31-005 |
CM-31-006 |
MUST | After a removal commits, the CASE_MANAGER MUST send the removed participant a direct Remove(CaseParticipant) naming it. The notice's actor is the CASE_MANAGER and its attributedTo the Case Owner (CM-24).Learning of removal only from silence is indistinguishable from a network fault, and the removed party needs to know it is still bound and how it will hear of the embargo's end. |
Extends: CM-31-005 |
CM-31-026 |
MUST NOT | The CASE_MANAGER MUST NOT ledger its CM-31-006 removal notice. The notice is delivery, not a second record of the move. The Case Owner's Remove is already the move's entry (CM-31-005). |
Extends: CM-31-006 |
CM-31-027 |
MUST | The CASE_MANAGER MUST include the removed participant in the removal entry's fan-out. The ledger entry keeps the removed party's replica continuous up to the removal, so that replica records its own removal like every other replica. |
Extends: CM-31-005 |
CM-31-028 |
MUST | The removal entry MUST be the last canonical entry that the CASE_MANAGER sends the removed participant, by fan-out or by replay, until it is reinstated. A removed participant has lost its entitlement to case content. An entry sent after the removal would leak case content to it. |
Extends: CM-31-005 |
The removal entry's fan-out selects its recipients before the removal is applied, so the removed participant receives that entry too.
It is the last ledger entry the removed participant receives, by fan-out or by replay, until it is reinstated.
Every replica, the removed participant's own included, applies the removal from that ledger entry.
A replica never applies a removal from a directly received Remove(CaseParticipant): it stores the notice and takes the removal from the ledger.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-007 |
MUST | A replica MUST apply a removal from its ledger entry, recording the same removal fact the CASE_MANAGER recorded. Replicas take case state from the ledger. The entry is what changes every replica, the removed party's included. |
|
CM-31-029 |
MUST NOT | A replica MUST NOT apply a removal from a directly received Remove(CaseParticipant) (RSH-08-003).The direct notice tells the removed party what happened; it is not the change. A replica that applied it would take case state from outside the ledger. |
Extends: CM-31-007 Refines: RSH-08-003 |
Removal does not change the participant's embargo consent. A removed signatory stays bound by the embargo it accepted. A removed participant receives no Invite of any kind: not a stub Invite, not a full-case Invite, and not an embargo Invite.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-008 |
MUST | Removal MUST NOT change the participant's embargo consent rows. A removed signatory remains bound by the embargo it accepted. Releasing a removed participant from the embargo would reward the conduct that got it removed. Consent is the participant's own statement (CM-18-005); removal is a separate fact. |
Extends: CM-31-001 |
CM-31-013 |
MUST NOT | The CASE_MANAGER MUST NOT send a removed participant a stub Invite, a full-case Invite or an embargo Invite. The CM-31-009 and CM-31-030 notices are its only exception. Invites reach inert participants because they ask them to join or consent (CM-10-007). A removed participant was taken out by the Case Owner's decision; inviting it to vote on embargo revisions would undo that decision. |
See also: CM-31-009 — context for the reader See also: CM-31-030 — context for the reader |
CM-31-040 |
MUST | When the Case Owner reinstates a participant that has not accepted the case's active embargo, the CASE_MANAGER MUST send it that embargo's Invite. A reinstated participant that is not a signatory stays inert until it consents, so it must be asked. |
Extends: CM-31-011 |
Removal is reversible.
The Case Owner reinstates a removed participant by sending Add(CaseParticipant)[target=VulnerabilityCase] to the CASE_MANAGER.
The request follows the removal pipeline:
- only the Case Owner may send it;
- the received
Addis the one ledger entry; - the CASE_MANAGER sends the participant a direct
Add(CaseParticipant)notice that names it; - every replica applies the reinstatement from the ledger entry.
Reinstatement clears the removal fact. The participant does not accept again, because it never withdrew.
The CASE_MANAGER refuses an Add that names a participant that is not removed or that never joined the case.
Add does not seat a new member, and an actor joins only by accepting its stub Invite.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-011 |
MUST | Add(CaseParticipant)[target=VulnerabilityCase] is the Case Owner's request to the CASE_MANAGER to reinstate a removed participant. The CASE_MANAGER MUST handle it through the CM-31-004 to CM-31-007 pipeline. That is Case Owner only, one ledger entry, a direct notice, and replicas applying it from the entry.Owners make mistakes and disputes resolve, so removal is reversible. Reinstatement reuses the removal pipeline, so it is the Case Owner's decision, recorded once and reaching every replica the same way. |
Uses definition from: CM-31-004 Uses definition from: CM-31-007 |
CM-31-034 |
MUST | A reinstatement MUST clear the participant's removal fact. The removal fact is what makes the participant inert (CM-31-017). Clearing it lets the active check count the participant again. |
Extends: CM-31-011 |
CM-31-035 |
MUST NOT | A reinstatement MUST NOT require the participant to accept again. The participant never withdrew, so it does not rejoin; Leave remains open to it. A participant reinstated into a case whose embargo it has not accepted stays inert, and its CM-10-006 backfill waits for its consent. |
Extends: CM-31-011 |
CM-31-036 |
MUST | The CASE_MANAGER MUST refuse an Add(CaseParticipant)[target=VulnerabilityCase] naming a participant that is not removed or that never joined.Joining requires accepting a stub Invite (ADR-0114), and Add must not become a way around that. Add means reinstatement only, so a participant that is not removed has nothing to reinstate. |
Extends: CM-31-011 |
For the same reason, the CASE_MANAGER does not send Add(CaseParticipant) when an invitee accepts its stub Invite.
The ledger holds the messages exchanged: the Invite, the CASE_MANAGER's creation of the inert record, then the invitee's Accept.
That Accept is the entry for the invitee's consent and joined mark.
Every replica applies what the entries carry.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-31-012 |
MUST NOT | The CASE_MANAGER MUST NOT emit Add(CaseParticipant), or commit an add_case_participant ledger entry, when an invitee accepts the stub Invite. The invitee's Accept (accept_invite_actor_to_case) is already the ledger entry for the consent row it signs and the joined mark.CM-17-004 does not call for it, the Accept message is already the entry for its effects, and a replica usually refuses the direct message for want of the participant record it names. It also records one move twice, and Add(CaseParticipant) now means reinstatement only (CM-31-011). |
Constrains: CM-17-004 |
CM-31-037 |
MUST | A replica MUST apply the stub-Invite Accept entry's consent-row and joined writes as the CASE_MANAGER does, setting updated to the Accept's published as received.The Accept is the one entry for both writes (CM-31-012), so a replica that applied them differently would hold a participant record that differs from the CASE_MANAGER's. Taking updated from the Accept as received keeps the record equal on every replica (ADR-0103, ADR-0124). |
Uses definition from: CM-31-012 |
CM-31-038 |
MUST NOT | A replica seeded with the case MUST NOT move a record it holds backwards when it replays an older entry over the seed (ADR-0124). Moving backwards means clearing joined, or changing a consent row by a move that CM-18-003 does not allow.A replica seeded with the case already holds a later state than an older entry describes. Replaying that entry must not undo what the seed holds, or the replica would fall behind the CASE_MANAGER. |
Uses definition from: CM-18-003 |
CM-31-039 |
MUST | When a replica holds no record for the invitee, its apply of the stub-Invite Accept entry MUST fail. The Accept entry changes an existing record; it does not create one. A replica that created a record from the Accept would hold a participant the CASE_MANAGER never seated. |
Extends: CM-31-037 |
CM-31-041 |
MUST | This rule covers a VENDOR-only invitee that accepts the stub Invite. The CASE_MANAGER MUST commit its VF Vf status entry (CM-11-009) after it announces the case to the invitee and backfills the prior ledger (#2898).The Accept is not the entry for the VF move, so the CASE_MANAGER records it as its own add_participant_status_to_participant entry. Committing it after the announce and the backfill lets the invitee's replica apply it on top of the case it already holds. |
Extends: CM-17-004 Refines: CM-11-009 |
When the reinstated participant is active again, the CASE_MANAGER sends it every ledger entry committed after its removal entry, in log order. Its copy of the ledger then joins the chain with no gap. A participant reinstated into a case whose active embargo it has not accepted stays inert. The CASE_MANAGER sends it that embargo's Invite, and its catch-up waits until it accepts.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-10-006 |
MUST | When the CM-10-004 content gate admits a participant whose ledger stream it had paused (CM-10-005) — whenever the active check turns from false to true for that participant, whether because it accepts the active embargo, the embargo ends, or it is reinstated (CM-31-011) — the CASE_MANAGER MUST send that participant every canonical entry it was not sent, in log order starting with the first entry withheld from it, before or together with the entry that records the change admitting it. A paused participant's replica is a contiguous prefix of the ledger; backfilling the withheld suffix in order restores it to the leader's tip without a gap the catch-up gate (SYNC-10-004) would block on. Ending the embargo lifts the gate for everyone, so a participant that never accepted it is caught up at that point too. The trigger is the active check itself, not any one message (ADR-0116). |
Extends: CM-10-005 Uses definition from: CM-10-004 See also: CM-31-011 — context for the reader |
See also