Skip to content
Reference

RCVCV Scenario: Reporter + C1 + V1 + C2 + V2

Overview

The RCVCV scenario exercises the actor-suggestion flow (ADR-0026). A Reporter reports to Coordinator 1 (C1), who creates the case and directly invites Vendor 1 (V1) and Coordinator 2 (C2). After C2 joins, C2 suggests Vendor 2 (V2), the party its participant suggester names, to the case. C1, as the Case Owner, approves the recommendation, and the Case Actor sends V2 a formal invitation.

This five-actor scenario validates the indirect participant onboarding path where C2 acts as a broker for V2 rather than C1 inviting V2 directly.

Participants:

  • Reporter — discovers the vulnerability and submits the report; in the case it holds the Reporter role; the protocol has no separate Finder role (ADR-0078).
  • C1 (Coordinator 1) — receives the report; validates, engages, and owns the case; invites V1 and C2.
  • V1 (Vendor 1) — receives a direct invite from C1; develops a fix (reaches VFd, not VFD).
  • C2 (Coordinator 2) — receives a direct invite from C1; suggests V2, the party its participant suggester names, to the case.
  • V2 (Vendor 2 / Deployer) — joins via the actor-suggestion path; develops and deploys a fix (VFD).
  • Case Actor — the actor that holds the CASE_MANAGER role for this case; it writes every canonical ledger entry and fans it out to the participants. In the demo it runs on the dedicated case-actor container, but its authority comes from the role, not from where it runs.

Protocol narrative

1. Reporter submits a vulnerability report to C1

The Reporter reports to C1's endpoint. This is an out-of-band API call; no ledger entry is created.

Antecedent: Reporter has knowledge of the vulnerability.

2. C1 validates and engages the case

C1 reviews the report and accepts it. validate_report and engage_case entries appear in the ledger.

Antecedent: Report received from Reporter.

3. Participant status records are created

The Case Actor records the engagement's status as an add_participant_status_to_participant entry; each record seated at case creation was ledgered as a create_case_participant entry.

Antecedent: engage_case is in the ledger.

4. C1 invites V1

C1 sends V1 an invite_actor_to_case entry.

Antecedent: engage_case is in the ledger.

5. V1 accepts its invitation

V1 accepts, and an accept_invite_actor_to_case entry appears.

Antecedent: V1's invite_actor_to_case entry is in the ledger.

6. The Reporter asks; V1 and C1 answer

The Reporter asks V1 a question in a case note, V1 answers it, and C1 sums up. This is the same note exchange as in rcv, because the two scenarios make the same choices up to this point. Each note is sent as one Add(Note) carrying the note inline, and recorded as an add_note_to_case entry, which attaches it to the case. C1 decides to invite a second Coordinator only after these notes.

Antecedent: V1's accept_invite_actor_to_case entry is in the ledger.

7. C1 invites C2

C1 sends C2 an invite_actor_to_case entry.

Antecedent: engage_case is in the ledger.

8. C2 accepts its invitation

C2 accepts, and an accept_invite_actor_to_case entry appears.

Antecedent: C2's invite_actor_to_case entry is in the ledger.

9. C2 suggests V2 via the actor-suggestion flow

C2 learns that V2 is also affected by asking its participant suggester who else belongs in the case. In the demo, that suggester is a static adapter that answers from a candidate table the scenario declares: V2, once as a Vendor and once as a Deployer. The question goes through the core participant-suggestion service, which hands the adapter a profile of C2's own replica of the case, not the case itself (ADR-0186). The ask runs in the demo runner rather than in C2's container, so no actor is configured with the table, and it writes nothing to the ledger. C2 then suggests the actor the answer names, in both of its roles, and an offer_case_participant entry proposes V2 for case membership (ADR-0026).

Antecedent: C2's accept_invite_actor_to_case entry is in the ledger.

10. C1 approves C2's recommendation

C1, as Case Owner, reviews the suggestion and approves it. An accept_actor_recommendation entry is recorded.

Antecedent: offer_case_participant is in the ledger.

11. Case Actor sends V2 a formal invitation

The Case Actor, acting on C1's approval, sends V2 an invite_actor_to_case entry. This follows the ADR-0026 suggest-actor path.

Antecedent: accept_actor_recommendation is in the ledger.

12. V2 accepts the Case Actor invitation

V2 reviews and accepts the invitation. An accept_invite_actor_to_case entry is recorded for V2.

Antecedent: The Case Actor's invite_actor_to_case entry is in the ledger.

13. C2 and V2 add notes

C2 and V2, now participants, reply in the same thread. Each note is recorded as one more add_note_to_case entry.

Antecedent: V2's accept_invite_actor_to_case entry is in the ledger.

14. V1 reaches fix-ready; V2 reaches fix-deployed

V1 advances to VFd (fix-ready) but stops there. V2 advances all the way to VFD (fix-deployed). Participant status updates reflect each state change.

Antecedent: engage_case is in the ledger.

15. Participants publish; embargo terminates

All participants publish. The embargo exits ACTIVE.

Antecedent: At least one vendor has reached fix-ready.

16. All participants close the case

All five participants close the case. close_case entries appear for each. V1, V2, C2, and the Reporter leave first; C1, the Case Owner, leaves last. A departure sent after the owner's is not recorded, so every other participant's departure is recorded first.

Antecedent: validate_report and engage_case are in the ledger.

Unobservable edges

Unobservable step Why not in ledger
Reporter submits report to C1 Report submission precedes the case.
C2 asks its participant suggester who else belongs The ask is C2's own question; only the suggestion it leads to is a case event.

The story as the code tells it

This is the plot of the scenario as the demo code composes it, generated from that code. It is here so a reader can check the narrative above against what the demo actually runs; where the two disagree, the narrative is the one written independently, so read it as the claim and this as the evidence.

  1. Reporter decides: Report it to a Coordinator
  2. The Reporter submits its report; the Coordinator engages the case.
  3. Coordinator decides: Invite the Vendor
  4. The Coordinator invites the Vendor, and the Invite is delivered.
  5. Vendor decides: Accept the invite
  6. The Vendor accepts the Invite, takes its replica and triages the report.
  7. The Reporter's and the Vendor's replicas catch up with the case.
  8. Reporter decides: Ask the Vendor a question
  9. The Reporter asks the Vendor's timeline; both others answer.
  10. Coordinator decides: Invite a second Coordinator
  11. Everything the opening recorded has reached every replica of the case.
  12. C2 and V2 are ready to be invited to the case.
  13. C1 invites C2 to coordinate too; C2 accepts and joins.
  14. The case holds every participant invited so far, and is still embargoed.
  15. C2 asks its participant suggester who else belongs in the case.
  16. C2 suggests the actor its suggester named; C1 approves; it joins (DEMOMA-19-009).
  17. Ledger Fanout reaches every participant's replica of the case.
  18. C2 and V2, once joined, add to the note thread the opening posted.
  19. Vendor1 reports its fix ready and Vendor2 reports it deployed (DEMOMA-19-004, DEMOMA-19-026).
  20. V1 publishes first, triggering the embargo teardown.
  21. All five participants leave the case, and it reaches its terminal state.