WebSocket API
TruePPM pushes real-time collaboration events over WebSocket. OpenAPI 3.0 cannot
describe WebSocket channels, so this page is the reference for the WS surface that
docs/api/openapi.json does not cover.
There is one endpoint, scoped to a single project by its UUID.
| Endpoint | Consumer | Purpose |
|---|---|---|
ws/v1/projects/{project_id}/ | ProjectConsumer | Board/schedule events + presence |
{project_id} is the project’s UUID. Use wss:// against a TLS deployment and
ws:// only for local development.
Authentication
Section titled “Authentication”WebSocket handshakes cannot carry an Authorization header, so the credential
must travel in the URL. To keep the long-lived JWT out of access logs, load
balancer logs, and browser history, the handshake uses a short-lived,
single-use ticket (RFC 6750 §2.3) rather than the access token itself.
First mint a ticket with an authenticated REST call:
POST /api/v1/ws/ticket/Authorization: Bearer <access_token>
→ 200 { "ticket": "<opaque>", "expires_in": 30 }The mint requires a JWT access token or the session cookie. A personal access
token is refused with 403, because a ticket would let a long-lived token open
live sockets.
Then open the socket with the ticket as the ticket query parameter:
wss://trueppm.example.com/ws/v1/projects/3f9a…/?ticket=<ticket>The ticket is valid for 30 seconds and is consumed on first use — request a fresh one before every connection, including each reconnect. It carries authentication only; the server still enforces project membership and role before accepting.
Close codes
Section titled “Close codes”A refused connection is accepted and then immediately closed with an
application close code. The order matters: a server that closes before accepting
rejects the HTTP upgrade with a 403, and a browser then reports close code 1006
with no application code at all — indistinguishable from a network drop. Accepting
first is what lets CloseEvent.code carry the reason.
| Code | When | Sent | Reaches a browser? |
|---|---|---|---|
4001 | Missing, invalid, expired, or already-consumed ticket; a ticket (or, on the deprecated path, a token) issued before the account’s credential cutoff, such as one minted just before a password reset (0.5 and later); or, on the deprecated path, an invalid token | after accept | yes |
4003 | Authenticated, but not a member of the project, or a role below Team Member — also sent to a live socket when the user is demoted or removed | after accept | yes |
4029 | This user sent more than TRUEPPM_WS_RATE_LIMIT_FRAMES frames across their sockets on this project in the window, counted per API worker (default 30 per 10 s). Clients are not expected to send any frame (0.5 and later) | closes the open socket | yes |
1009 | A client frame larger than TRUEPPM_WS_MAX_FRAME_BYTES (default 8192) (0.5 and later) | closes the open socket | yes |
4404 | The path matched no WebSocket route | before accept | no — the browser sees 1006 |
From 0.5, a handshake whose Origin header is not in ALLOWED_HOSTS or
TRUEPPM_WS_ALLOWED_ORIGINS is rejected at the upgrade (HTTP 403, browser close
code 1006, so a client retries rather than seeing a code). A handshake with no Origin header, which is what a non-browser client
sends, is allowed unless TRUEPPM_WS_REQUIRE_ORIGIN=true. See
Rate limits.
4003 is the same for a project that does not exist and one the caller is not a
member of, so the code does not reveal whether a project exists. 4404 stays a
pre-accept rejection on purpose: no client should dial an unrouted path, so there is
nothing for one to act on.
How a client should react:
4003is terminal. Retrying can only be refused again. Stop reconnecting, refresh from the REST API instead, and tell the user live updates are not available for their role. Better still, do not connect at all whencan_subscribe_liveisfalse— on the project (GET /projects/{id}/) or on a lane of the program schedule (GET /programs/{id}/schedule/). Both are computed from the same rule the socket enforces.4001: mint a fresh ticket (refreshing the access token first if needed) and reconnect once; a second consecutive4001means the session has expired and the user must re-authenticate.- Retryable transport drops (network loss, server restart) use the standard
1006/1001codes and should be reconnected with backoff.
Board channel — server → client
Section titled “Board channel — server → client”Every board/schedule event on ws/v1/projects/{project_id}/ arrives as a JSON
envelope:
{ "protocol_version": 1, "event_type": "<name>", "payload": { ... }, "seq": 1234 }event_type is a snake_case name. Clients dispatch on it and typically
invalidate the corresponding cache (the web client maps these to TanStack Query
keys). protocol_version is a bare integer identifying the envelope wire
version (currently 1); it is reserved so a future backward-incompatible
envelope change can be negotiated without breaking clients that ignore it today.
The set is open-ended and grows as features land; current event types include:
- Tasks:
task_created,task_updated,task_deleted,task_duration_changed,task_dates_updated,task_restored,tasks_reordered,tasks_restructured,tasks_bulk_mutated. Notask_dates_updatedframe is sent when a CPM pass moves no tasks;cpm_completealways fires. - Dependencies:
dependency_created,dependency_updated,dependency_deleted,dependency_accepted,dependency_rejected,dependencies_bulk_created(one aggregated event perPOST /tasks/bulk/batch, carrying every applied edge’s id asdependency_ids— not onedependency_createdper edge, #3770). A cross-project edge fansdependency_created,dependency_updatedanddependency_deletedto both endpoint projects, pending proposals included. So does a task or project delete (bulk, offline sync and permanent delete included) or restore that cascades to such an edge: the project on the far side receives the edge event and a schedule recompute. - Task relations:
task_relation_created,task_relation_updated,task_relation_deleted(informational relates-to / blocks / duplicates links; payload carries the relationid). A cross-project relation fans to both endpoint projects. Inert — no schedule recompute follows. - Task links — a separate family from Task relations above, despite the
similar name:
task_link_created,task_link_updated,task_link_deletedcover an external Git/Jira/GitHub/GitLab reference attached to a task (payload carries the linkidandtask_id), not an internal task-to-task cross-reference. If you are grepping for “link” events looking for the relates-to/blocks/duplicates feature, that is Task relations above, not this family. - Scheduling:
cpm_complete,cpm_error,task_run_started,task_run_progress,task_run_completed,task_run_failed,task_run_cancelled.cpm_complete’s payload is{"project_finish": <ISO date or null>, "critical_path": [<task id>, ...], "status_date": <ISO date or null>}—status_dateis the CPM data date this run resolved (Project.status_dateif set, otherwise today; ADR-0752 §4), echoed so a consumer knows which “today” produced the dates. On the program-scoped pass (ADR-0120 D3, escalated when the project’s program holds an accepted cross-project edge)status_dateis alwaysnull: member projects can carry differentstatus_datevalues and the merged run floors none of them, so no single value would honestly describe what was computed. Both dispatch paths build this payload through one shared helper so the key set cannot drift between them (#3776). One run adds a fourth key (ships in 0.5): the first recalculation that resolves a project’s emptystatus_dateto today on an established schedule (the data-date “arming” run, ADR-0752 §7) withholds the per-tasktask_dates_updateddelta, and if it moved any task itscpm_completecarries"dates_changed": true. Treat it as “re-read the task list”: it names no task and no date, so it carries no movement — the confidentiality goal of ADR-0752 §7 — and a re-read goes through REST, which applies the reader’s field gating. The key is absent on every other run, whose movement arrives astask_dates_updated. It is also set when the recompute rolled a phase’sstatusup from its leaves (ships in 0.5): no per-task delta carries status, so re-read the task list to see it. - Baselines:
baseline_created,baseline_activated,baseline_deleted - Risks:
risk_created,risk_updated,risk_deleted,risks_imported - Labels:
label_created,label_updated,label_deleted(catalog changes; payload carries the labelid). Assigning or removing a label from a task emitstask_updatedwithchanged_fields: ["labels"], not a distinct event. - Sprints:
sprint_created,sprint_updated,sprint_deleted,sprint_activated,sprint_cancelled,sprint_closed,sprint_close_failed,sprint_reranked,sprint_retro_updated,milestone_rollup_updated,milestone_forecast_updated,poker_session_updated,demo_toggled. Thesprint_*events anddemo_reorderedname the sprint asid.sprint_reranked,sprint_retro_updated,sprint_scope_changedanddemo_reorderedalso keep their oldersprint_idkey with the same value; theidkey on those four ships in 0.5.sprint_close_failedis the negative counterpart ofsprint_closed: closing a sprint is asynchronous (the endpoint returns202with arequest_id), and this event fires when that request is abandoned and the sprint will stay open. It is emitted only for a terminal outcome — a failure the server still intends to retry emits nothing, so receiving it always means the close is dead. Payload:{"id": <sprint_id>, "request_id": <uuid>, "failure_reason": <cancelled|not_closable|stalled|error>, "attempt_count": <int>, "terminal": true}. It deliberately carries no error text — that field is role-gated and is read fromGET /api/v1/sprints/{id}/close-request/, which returns the detail the calling identity is entitled to. - Retro board:
retro_item_created,retro_item_updated,retro_item_moved,retro_item_deleted - Comments / attachments:
task_comment_created,task_comment_updated,task_comment_deleted,task_comment_ack_changed,task_comment_reaction_added,task_comment_reaction_removed,task_attachment_created,task_attachment_deleted,comment_created - Notes log:
task_note_created,task_note_updated,task_note_deleted,task_note_pinned,task_note_decision_toggled - Decisions visibility (ADR-0167):
decisions_policy_changed— a project Admin flipped the team’s oversight-visibility consent switch for the project Decisions view. Payload is{"id": <project id>, "oversight_visible": <bool>}; a client re-readsGET /api/v1/projects/{id}/decisions-policy/to re-apply the gate for the reading identity. This reaches a Member-or-above peer’s open oversight-visibility control live. It does not reach an oversight reader (below Member — the only role the switch actually gates): the WebSocket connection itself requires at least Member (close code4003otherwise, see Close codes), so that role sees the new posture on their next page load rather than live - Roster / assignments:
roster_changed,assignment_created,assignment_updated,assignment_deleted - Board config:
board_config_updated,board_view_created,board_view_updated,board_view_deleted,project_custom_fields_updated - Guardrails (ADR-0101):
guardrail_policy_updated— a sprint-composition guardrail level changed, or an external policy was acknowledged by the team. Payload is{"id": <policy id>}only — never the levels map — so a client re-readsGET /api/v1/projects/{id}/guardrail-policy/, which re-applies the sovereignty gate for the reading identity - Mention groups:
mention_group_changed— one event for every mutation of a user-defined @mention group (ADR-0212, ADR-0248). The payload is{"id": <group id>, "group_id": <same>, "change": <string>}, plusscope: "program"andprogram_idwhen the group is program-scoped (such a group fans out on every live project channel in the program).changeis a closed enum and part of the stable contract:created,updated,deleted,member_added,member_removed. A new value is an additive change announced in the changelog; treat an unrecognized value as “refetch the group list”. There is no per-verb event family for groups, unliketask_created/task_updated/task_deleted. - Membership / project:
member_added,member_role_changed,member_removed,project_updated,project_archived,project_unarchived,project_transferred,project_deleted,project_hard_deleted.project_restoredis emitted but not deliverable: the channel refuses a trashed project, so no client is subscribed when a restore broadcasts (#2847) - Programs — ⚠️ not deliverable until the program channel ships in 0.8 (#836);
emitted by the server but no client can subscribe, see the caution above:
program_closed,program_reopened,program_deleted,program_split,program_sponsorship_transferred - Task suggestions:
suggestion_created,suggestion_declined,suggestion_revoked. All three carry the suggestion asidand the task astask_id;suggestion_createdalso keepssuggestion_id(same value) and addssuggested_user_id(itsidkey ships in 0.5). Decline/revoke carry only the suggestion + task id — never the actor — a silent state reconciliation, not a callout - API tokens:
api_token_minted,api_token_revoked(project-scoped tokens only — payload is{"id": "<token uuid>"}; the name, secret prefix, raw token and hash are never sent, so refetch the token list for details; program-scoped and personal access tokens broadcast nothing, see API reference) - Cross-project (ADR-0120):
slip_conflict_acknowledged,slip_conflicts_updated - Velocity suggestions:
velocity_suggestion_accepted,velocity_suggestion_dismissed— the suggestion settling. An accept also emits a normaltask_updatedcarryingchanged_fields: ["most_likely_duration"], because the task’s own field changed and that field is a Monte Carlo input the CPM delta does not carry - Signal privacy (ADR-0104):
signal_privacy_changed(an audience or ceiling moved),signal_ceiling_proposal_changed(a raise proposal opened, ratified, was rejected, expired, was superseded, or withdrawn),signal_ceiling_vote_cast(a vote that left the proposal open — the running tally). Payloads are ID-only: no vote values and no voter identities cross the wire, so a client re-reads through REST, which re-applies the privacy gate - Working-time calendar:
project_calendar_changed— the project’s effective calendar changed. Fired on the affected projects for a Calendar edit, a calendar-exception edit, a program/workspace calendar reassignment, or a replacement of the project’s applied calendars (PUT /projects/{id}/calendars/— this trigger ships in 0.5); Calendar itself is a shared org-level resource with no channel of its own. The payload carriesactor, the display name of whoever made the edit (empty for a system or unauthenticated write), andactor_id, the same user’s id as a string (nullfor a system write; ships in 0.5) — a calendar edit can move finish dates on a project whose own members did nothing, so the event names who did it - Presence:
presence_join,presence_leave
Event-name convention. WebSocket
event_typevalues aresnake_caseacross the board — including presence, which previously used a dot-namespacedpresence.join/presence.leave(aligned to snake_case in 0.2, #828).Webhook event names are deliberately dot-namespaced (
task.created,task.updated, …) — a different transport with a different audience (external integrations expect dotted topic-style names). So the same domain event istask_createdover the WebSocket andtask.createdin a webhook payload. This is an intentional per-transport distinction, not drift.The naming pattern new events must follow (
<resource>_<past-tense-verb>), the frozen-contract guarantee, and the steps to register a new event are documented in WebSocket event conventions.
Live delivery is best-effort: a frame sent while your socket is down never
reaches it. Do not refetch everything on every reconnect, though. Reconnect with
?since=<cursor>, as described below. The server either replays exactly the events
you missed or tells you, with resync_required, that it cannot. Refetch only in
that case. Event payloads are intentionally minimal (usually { "id": "<uuid>" }
or a small id set): fetch the resource for its full state.
Identity keys. An event whose subject is a row — every *_created, *_updated
and *_deleted event, the sprint-family events above, member_added,
member_role_changed, member_removed (the membership), mention_group_changed
(the group) and task_comment_ack_changed (the comment) — names that row as
payload.id. Key on id; a more specific key such as sprint_id or
suggestion_id may appear beside it with the same value, kept for older consumers.
An actor is named as actor_id, never by display label alone. The exceptions have
no single subject row: board_config_updated (the project’s board configuration),
dependencies_bulk_created (a batch, named by dependency_ids),
milestone_forecast_updated (a computed forecast, named by milestone_id) and
roster_changed (named by resource_id; it covers both allocation-row and
resource-level writes). The API test suite enforces this rule over every broadcast
call site, with those four as its only waivers (ships in 0.5).
Sequence numbers and reconnect replay
Section titled “Sequence numbers and reconnect replay”The replay contract below (seq, ?since= and resync_required) is a supported
part of the WebSocket API, not an internal detail of the web client.
A replayable event also carries a seq field; an ephemeral one (presence_*,
task_run_*) carries "seq": null. seq is per project, dense and
commit-ordered: a project’s events are numbered 1, 2, 3, … with no holes, in
the order they committed. It is not a global counter, and two projects’ values are
unrelated.
Dense numbering does not make delivery ordered. Two server workers can commit
events 10 and 11 in that order and still deliver 11 first. A client should
therefore keep the highest seq it has applied with nothing missing below it, and
then handle each frame like this:
seq≤ that cursor: drop it. Normally the event was already applied. It can also be an event that arrived after you stopped waiting for it (next bullet).seq= cursor + 1: apply it, then apply any held frames that are now contiguous.seq> cursor + 1: an earlier event is still in flight or was lost. Hold the frame briefly (the web client waits 750 ms). If the missing event arrives, apply the run in order. If it does not, apply what you hold in order and move on. Do not drop a frame because it arrived early.
The wait is a bound, not a guarantee. An event that arrives later than the wait is
lost. Your cursor has already moved past it, so it falls under the first rule. A
reconnect does not recover it either, because ?since= starts above the hole. The
web client currently recovers such an event only through a later refetch of the
data it affects. A gap signal that triggers a resync is planned
(#2848).
To resume after a disconnect, reconnect with ?since=<cursor>. The server sends
the events you are owed (seq > since, in order, each with "replayed": true)
before the live stream resumes. It sends a single resync_required frame
instead, carrying { "latest_seq": <n> }, when:
- part of the gap has been purged (the buffer keeps
TRUEPPM_BOARD_EVENT_RETENTION_HOURS, 24 h by default); - you are more than 1,000 events behind; or
sinceis above the project’s current head.
After a resync_required, refetch your project-scoped state and set your
cursor to latest_seq.
An event’s payload may be richer at some emitting sites than others, but all
sites emitting a given event_type share at least one key, so one handler can
always read every emission of an event it subscribes to. For the task events
(task_created, task_updated) that key is always id. This is enforced by a
conformance test over every literal broadcast call site, plus the workspace-group cascade events (member_added, member_removed, member_role_changed), which are built dynamically and asserted by test_groups_cascade, not by convention.
The task_updated event carries a richer field-level delta (ADR-0152):
{ "id": "<task uuid>", "changed_fields": ["status", "assignee"], "version": 42, "actor_id": "<user uuid or null>", "ts": "2026-06-20T16:00:00Z"}changed_fields lists the names of the fields that changed — never their
values, because task fields are role-gated (e.g. story_points is nulled below
the velocity audience); a client that needs the new values re-reads the task
through the serializer, which re-applies per-user gating. version is the
post-commit server_version (clients ignore an event whose version they have
already applied), and actor_id lets the originating client suppress its own echo
rather than re-fetching over its optimistic update. The id key is retained for
backward compatibility.
version is null when the write changed a row that belongs to the task but not
the task row itself — an acceptance criterion, a suggested-assignee accept that
found the task already assigned, or a recurrence-rule create or delete that did not
flip the task’s is_recurring flag. Treat a null version as unversioned: skip the
replay check and refetch. actor_id is likewise null for writes that are not
interactive (a CI acceptance-result ingest) and for writes whose originating client
does not update its own task list, so that client still refetches.
changed_fields may be empty, meaning “the task changed in a way the server does not
name — refetch it”. It may also contain the pseudo-field acceptance_criteria, which
is not a stored task field: it says the task’s acceptance criteria (and so its
Definition-of-Ready meter) changed.
Two producers emit a leaner or wider frame than the shape above. Inbound task-sync
frames (Jira and Linear) carry only id and source. The retro carryover frame
also carries task_id, sprint_id and source. Treat any task_updated frame
without changed_fields as “refetch the task”.
For a task edit, changed_fields lists every stored task field the write changed, including fields
the server derives from the submitted ones (for example status and actual_start
when a past planned_start starts a task). A PATCH emits no task_updated, triggers
no recalculation, and dispatches no task.updated webhook only when no stored field
changes at all, derived fields included. Re-sending a value the task already holds
can still change a derived field, and that write is announced as a change.
WebSocket ↔ webhook event taxonomy
Section titled “WebSocket ↔ webhook event taxonomy”The same domain event uses two different naming conventions depending on the
transport: WebSocket event_type values are snake_case (task_created),
while webhook events are dot-namespaced noun.verb (task.created). This is
an intentional per-transport distinction, not drift — see the convention note
above. The two event sets also do not fully overlap: some WS events have no
webhook counterpart (and vice-versa).
Board events broadcast over WebSocket
Section titled “Board events broadcast over WebSocket”These are emitted via broadcast_board_event(). The table below highlights the
events with a webhook equivalent plus a representative selection of the
WS-only events. It is illustrative, not exhaustive — the complete,
authoritative set of WebSocket event types is frozen in the API test suite
(packages/api/tests/apps/sync/test_broadcast.py, FROZEN_WS_EVENT_TYPES), which
fails CI if a new broadcast_board_event() call introduces an event type without
adding it to that frozen set. Events with no webhook counterpart are marked
WS-only.
WebSocket event (snake_case) | Webhook event (noun.verb) |
|---|---|
task_created | task.created |
task_updated | task.updated |
task_deleted | task.deleted |
task_duration_changed | WS-only |
task_dates_updated | WS-only |
task_restored | WS-only |
dependency_created | dependency.created |
dependency_deleted | dependency.deleted |
dependency_updated | WS-only |
dependency_accepted | WS-only |
dependency_rejected | WS-only |
dependencies_bulk_created | WS-only |
task_relation_created | WS-only |
task_relation_updated | WS-only |
task_relation_deleted | WS-only |
task_link_created | WS-only — distinct family from task_relation_* above, see the note above |
task_link_updated | WS-only |
task_link_deleted | WS-only |
task_comment_ack_changed | WS-only |
task_comment_reaction_added | WS-only |
task_comment_reaction_removed | WS-only |
project_created | project.created |
project_updated | WS-only |
project_archived | WS-only |
project_unarchived | WS-only |
project_restored | WS-only — not deliverable (the channel refuses trashed projects) |
project_deleted | WS-only |
project_custom_fields_updated | WS-only |
guardrail_policy_updated | WS-only |
api_token_minted | WS-only |
api_token_revoked | WS-only |
demo_toggled | WS-only |
milestone_forecast_updated | WS-only |
sprint_close_failed | WS-only |
program_sponsorship_transferred | WS-only — ⚠️ not deliverable until 0.8 (#836) |
backlog_reranked | WS-only |
sprint_reranked | WS-only |
baseline_activated | WS-only |
baseline_deleted | WS-only |
board_view_created | WS-only |
board_view_updated | WS-only |
board_view_deleted | WS-only |
milestone_rollup_updated | WS-only |
phases_reordered | WS-only |
queue_reordered | WS-only |
program_closed | WS-only — ⚠️ not deliverable until 0.8 (#836) |
program_reopened | WS-only — ⚠️ not deliverable until 0.8 (#836) |
program_deleted | WS-only — ⚠️ not deliverable until 0.8 (#836) |
program_split | WS-only — ⚠️ not deliverable until 0.8 (#836) |
risk_created | WS-only |
risk_updated | WS-only |
risk_deleted | WS-only |
risks_imported | WS-only |
sprint_created | WS-only |
sprint_updated | WS-only |
sprint_deleted | WS-only |
sprint_scope_changed | WS-only |
sprint_retro_updated | WS-only |
retro_item_created | WS-only |
retro_item_updated | WS-only |
retro_item_moved | WS-only |
retro_item_deleted | WS-only |
demo_reordered | WS-only |
demo_presenter_set | WS-only |
review_note_set | WS-only |
flagged_for_backlog | WS-only |
tasks_bulk_mutated | WS-only |
tasks_reordered | WS-only |
tasks_restructured | WS-only |
team_member_changed | WS-only |
suggestion_created | WS-only |
suggestion_declined | WS-only |
suggestion_revoked | WS-only |
slip_conflict_acknowledged | WS-only |
slip_conflicts_updated | WS-only |
velocity_suggestion_accepted | WS-only |
velocity_suggestion_dismissed | WS-only |
signal_privacy_changed | WS-only |
signal_ceiling_proposal_changed | WS-only |
signal_ceiling_vote_cast | WS-only |
project_calendar_changed | WS-only |
decisions_policy_changed | WS-only |
WS-only events on other channels
Section titled “WS-only events on other channels”Presence and scheduling-progress events are broadcast over channels other than the board channel and have no webhook counterpart:
| WebSocket event | Channel / purpose |
|---|---|
presence_join | Presence (a user connected) — WS-only |
presence_leave | Presence (a user disconnected) — WS-only |
cpm_complete | Scheduling progress (CPM run finished) — WS-only¹ |
cpm_error | Scheduling progress (CPM run failed) — WS-only¹ |
¹ The cpm_* scheduling-progress events relate approximately to the webhook
schedule.recalculated event — both signal that a schedule recalculation
occurred — but they are not a one-to-one mapping (the webhook fires once per
recalculation; the WS events stream the lifecycle of a run). Treat the
correspondence as loose.
Webhook-only events
Section titled “Webhook-only events”These webhook events have no WebSocket broadcast — they are delivered only to configured webhook endpoints:
| Webhook event | Notes |
|---|---|
schedule.recalculated | Loosely relates to the cpm_* WS events (see above). |
task.assigned | No WS broadcast. |
task.assignee_changed | No WS broadcast. |
task.mentioned | No WS broadcast. |
task.due_date_changed | No WS broadcast. |
sprint.activated | No WS broadcast. First-party agile domain event (ADR-0147). |
sprint.closed | No WS broadcast. Completion snapshot (velocity) is privacy-gated in its payload per ADR-0104. |
sprint.scope_changed | No WS broadcast. Fires on post-activation scope injection (ADR-0102). |
risk.opened | No WS broadcast under this name (a generic risk_created WS event exists). First-party domain event (ADR-0206). |
risk.escalated | No WS broadcast under this name. Fires when computed severity (probability × impact) increases (ADR-0206). |
risk.closed | No WS broadcast under this name. Fires on the transition into CLOSED (ADR-0206). |
baseline.captured | No WS broadcast under this name (a generic baseline_created WS event exists). First-party domain event (ADR-0206). |
comment.created | No WS broadcast under this name (a generic task_comment_created WS event exists). Carries no comment body (ADR-0206). |
The OSS webhook event set is capped at 19 events: task.created,
task.updated, task.deleted, dependency.created, dependency.deleted,
schedule.recalculated, project.created, task.assigned,
task.assignee_changed, task.mentioned, task.due_date_changed,
sprint.activated, sprint.closed, sprint.scope_changed, risk.opened,
risk.escalated, risk.closed, baseline.captured, and comment.created. The
agile trio (sprint.*) was added in ADR-0147, raising the cap from 11 to 14; the
risk/baseline/comment domain events were added in ADR-0206, raising it from 14 to
19. Adding a 20th event requires its own ADR — the cap is the gate against
per-customer event proliferation.