> For the complete documentation index, see [llms.txt](https://api-reference.usecommune.dev/llms.txt)

# Removals

Narrowing an enum, dropping a field from `required`, and adding a property
to a response schema that is `additionalProperties: false` are all breaking
changes, and this version has had each of them without a new release date,
because the API is pre-release. The third one is the surprising one: a
closed schema refuses a body carrying a property it has not heard of, so a
client validating responses against the document it generated from rejects
a response that gained a field. Said here rather than left for a client to
discover:

* **`2026-10-10`: `paid` removed from `ThreadVisibility`.** A thread's
  `visibility` is now `public` or `subscribers` and nothing else. The value
  was a placeholder for a feature that was never built: no operation
  accepted it, no thread was ever stored with it, and no event ever carried
  it, so nothing a client has read or sent changes. `?visibility=paid` on
  `GET /newsletters/{newsletter}/threads` now answers `400` for an unknown
  parameter value instead of an empty page. `previous_visibility` on
  `thread.published` narrows to `subscribers` or null for the same reason.

* **`2026-10-13`: `article_id` and `send_id` no longer required on the
  `delivery.*` payload.** Both are nullable now, and a new required
  `source` says what caused the email: `article_send` carries the pair a
  client already reads, `automation` carries `run_id` and `step_id`
  instead. An article send was the only thing Commune could email when
  those topics were written. Automations email too, and an automation
  delivery has neither id. A client that dereferences `article_id`
  unconditionally has to branch on `source` first. The reasoning, and
  what was rejected, is on `DeliveryEventData`.

* **`2026-10-13`: `Thread` gained `audience_scoped` and
  `audience_tag_ids`, and `Tag` gained `is_room`.** Both schemas are
  `additionalProperties: false`, so a client validating responses against
  the previous document rejects a thread or a tag it reads now even though
  nothing it was already reading changed. `audience_scoped` and `is_room`
  are also `required`, so a client that generated types will see two
  non-optional fields appear. Nothing was removed and nothing moved. The
  fields are private chat rooms: a thread can be scoped to subscriber
  segments and is then readable only in them, `is_room` says which segments
  may be scoped to, and `audience_scoped` is how a credential that may read
  the conversation but not the segmentation can still tell a private thread
  from an open one. `thread.created` gained `audience_scoped` too, which is
  additive, because an event payload is not a closed schema.

* **`2026-10-14`: `Room` gained `slug`.** `Room` is
  `additionalProperties: false`, so a client validating responses against
  the previous document rejects a room it reads now even though nothing it
  was already reading changed, and `slug` is `required`, so a client that
  generated types will see a new non-optional field. Nothing was removed
  and nothing moved. The slug is the room's name as a URL carries it
  (`founding-members`), which is what `?room=` holds in Commune's chat: it
  is derived from the name when the room is created and never derived
  again, so it survives a rename and can disagree with the current `name`.
  It is unique among one newsletter's live tags and is for building a link
  a person will read; every operation here still addresses a room by `id`.
  Deliberately NOT added to `Tag`, for the reason `hidden` was not: a
  segment has no URL of its own, so putting it there would break a second
  strict client to say something in the wrong place.

* **`2026-10-14`: `Room` gained `description`.** The same mechanism as
  `slug` above, on the same closed schema: a client validating responses
  against the previous document rejects a room it reads now, and `slug`
  and `description` were released on one day. `description` is `required`
  and nullable, which is the pair that matters: every room answers the
  question, and `null` means the creator has not written one. Optional and
  absent would have made "no description" and "this document predates the
  field" the same bytes. It is what the room is for, in the creator's own
  words, capped at 280 characters, read by the room's members in its
  header in Commune's chat. Read only here; it is written in Commune, and
  it is a label rather than a permission, published to exactly the people
  the room's `name` is published to. Deliberately NOT added to `Tag` for
  the third time, and for a sharper version of the same reason: the column
  is on `subscriber_tags`, so a segment could hold one, but nothing writes
  or reads a description for a segment, so `Tag` would gain an
  always-null property and a strict client would break for it.

* **`2026-10-14`: an automation step's `next` no longer defaults to the
  following step.** The only entry here that breaks BEHAVIOUR rather than
  shape, and the only one a client cannot find by validating: a document
  that was valid is still valid, every field means what it meant, and a
  request that was accepted is still accepted. It runs differently. `next`
  used to be nullable with a default, where null meant "the step at the
  next position in the array", so a linear sequence could be sent with no
  edges at all and a condition arm left null carried on into whatever came
  after it. Null now means there is no edge: the run ends there. The same
  is true of `then` and `else`.

  A graph relying on the default therefore gets SHORTER rather than
  wrong-shaped, which is why this is said here instead of being left for a
  client to notice. A three-step welcome sequence that wired nothing now
  sends the first email and stops; the fix is to set `next` on each step,
  which is a field that already existed and already meant this. It cuts the
  other way too, and that was the reason for the change: a condition whose
  `else` was left null used to fall into the `then` arm's own steps, so the
  fork decided nothing and a reader could receive both arms' email. That
  shape is now the fork it reads as.

  There is no new `Commune-Version` and no compatibility mode. An execution
  rule that reads a graph's LAYOUT to answer "what runs next" is not worth
  a shim: a directed graph has no next except the edge somebody drew, and
  the position a step sits at is not exposed here at all, so a client had to
  count array indices to predict what Commune would do.

* **`2026-10-15`: `stop` removed from `AutomationStepType`.** A step's
  `type` is now `send_email`, `wait`, `add_tag`, `remove_tag` or
  `condition`. A body sending `stop` is a `400` naming the field, and no
  automation reads back with one, because none was ever stored with one.

  It was graph punctuation rather than an action: a step whose whole
  behaviour was that nothing came after it. It existed because `next` used
  to default to the following entry in the array, so without one the `then`
  arm of a condition fell through into the `else` arm's steps and the
  subscriber received both emails. The entry above removed that defaulting
  on `2026-10-14` and kept `stop` on the argument that an explicit
  terminator still SAYS an ending was meant, where an unwired `next` can
  only say nothing is there yet.

  That argument did not survive the creator-facing builder, which is the
  other client of this grammar. Every port with no edge on it is already
  drawn as a cap reading "The run ends here", so a `stop` and an unwired
  `next` rendered the same sentence twice, and the `stop` had no outgoing
  port of its own: a box with nothing leaving it, sat beside a cap already
  saying so. One statement with two spellings is a vocabulary a creator has
  to choose inside for nothing.

  **Ending a path is unchanged and always was a field you already send.**
  Leave `next` out, or set it to null, and the run ends at that step; the
  same goes for a condition's `then` and `else`. A graph that used a `stop`
  drops the step and nulls the edges that pointed at it, which is the same
  graph with one fewer node. Nothing else moves: `next` is still refused on
  nothing, since the rule that refused it on a `stop` went with the type.

