Notices

A notice is an event the engine leaves on a conversation when something happened that you, the implementer, need to know about: a node that failed, a message WhatsApp rejected, a variable nobody wrote, a flow that stopped without a next step. Notices are written by the engine only; nobody types them by hand, and a node that works almost never leaves one.

You read them in two places: the notices panel of a conversation in Chat, and the tenant-wide Flow Notices screen that groups them by flow and node. The codes page lists every code and the most common notices with their cause and action.

What a notice is

One event, one entry. The engine writes a notice when a step produced an outcome you must know about, when the flow content is wrong, or when the service itself failed. It does not write one for a node that ran correctly, with two exceptions: three nodes record an info notice when they finish well (Extract Information, Packages and Read Incoming), and a Goal node with a goal records goal_reached every time a conversation reaches it. Outside those, the list is signal, not a log.
It belongs to the conversation. Notices are stored on the conversation, not on the flow. Deleting or unpublishing a flow does not remove them.
The last 200 are kept. Each conversation holds its most recent 200 notices; older ones fall off the end. A conversation that loops does not flood this cap, because repeats fold into a counter (see below). The exception is a node that leaves two different notices on the same pass, such as a Goal node that records its goal and also leaves a warning: the two alternate and never fold, so a long loop through it pushes the older notices out.

What a notice carries

Field	What it is
Message	The headline. Free text, and the engine may reword it over time; group and filter by the code, not by the message.
Level	`info`, `warning` or `error`. Anything else stored is read as one of these three.
Code	A stable snake_case identifier such as `node_failed` or `delivery_failed`. The Chat panel shows a translated label for it. Some older notices carry no code and show only their message.
Node	The node identifier, its type and its description. The identifier is what Open in editor uses to land on the node.
Flow	The flow identifier and name the conversation was running.
Reason	The detail: why it happened and, for most notices, what to check or fix. This is the field to read first.
Traceback	Present only when a real exception occurred. A notice about flow content or a customer's answer has none.
Details	Structured data when there is a provider verdict behind the notice: Meta's error code for `delivery_failed`, the failing stage for `stage_failed`, the declared and received types for `variable_type_mismatch`.
Count and Last seen	How many consecutive times the same event repeated and when it last did. Shown as ×N in the panel.
Created at	When the notice was first written.

Levels

Level	Meaning	Examples
Info	Something normal was recorded. Nothing to fix; it explains what happened to the conversation. Does not refresh the open conversation in Chat.	The flow reached its end node. A Goal node recorded a goal (`goal_reached`). The conversation had no active flow and restarted in the connector's default bot. The conversation expired for inactivity and was redirected to the default bot.
Warning (Warning in the panel)	The step produced an outcome, or the flow content is wrong. Someone who builds flows should look; nobody at AltScore needs to.	The customer mistyped the OTP or let it expire. WhatsApp rejected a message because the 24-hour window is closed. A node failed and had no Error handle connected. A message uses a variable no node ever wrote. A variable received a value of the wrong type (`variable_type_mismatch`). The flow loops (`flow_cycle`).
Error	The service failed or the conversation is stuck with nobody answering. It carries a traceback when there was an exception and it raises an internal alert.	`unhandled_error`, `stage_failed`, `jump_to_without_destination`, a customer who writes and nobody answers because the flow is gone and the connector has no default bot.

Taking the error branch is not an error. When a node fails and the flow continues through its Error handle, that is the flow working as designed: the notice records the failure and where the flow went, but it is not an alert. In the same spirit, reaching a jump-to, a human-takeover or an end node is never a failure; they end or hand over the flow on purpose, and the engine only records that it happened.

The engine does not modify your flow while executing it. A notice tells you what the flow did with a given conversation; the flow itself is exactly what you published.

Repeats fold into a counter

When the engine is about to write a notice identical to the last one on the conversation, it does not append a new entry: it increments the counter and refreshes Last seen on the existing one. Two notices are the same event when they share code, node identifier and message; notices without a code are compared by message and node type.

A flow that loops through one node 157 times leaves one card with ×157, not 157 cards. The panel reads it as Repeated 157 times, last: date. On the Flow Notices screen the Times column adds these repeats up, while Conversations counts distinct conversations.

Only consecutive repeats fold. If a different notice lands in between, the next occurrence starts a new card.

Real time

Most warnings and errors refresh the conversation you have open in Chat, so the notice shows up as soon as the engine writes it: node failures and warnings, variable type, cycles, jumps without destination, Ask File destinations, Meta rejections and service errors. The rest, and every info notice, do not trigger a refresh; you see them the next time the conversation loads. If the panel ever looks behind, reopen the conversation.

Where you see them

In Chat, per conversation

Every conversation in Chat has a Notices panel, opened from the header. The header shows a badge with the number of notices at warning and error level for that conversation (one per card, regardless of how many times it repeated).

In the panel:

Filter by level — All, Info, Warning, Error — and search by message, reason, node type or flow name.
Each card shows the level, the translated label of its code, the message, the node type, the reason (truncated), the flow name, the date and the ×N counter when it repeated.
Open in editor appears when the notice carries a node and a flow: it opens the flow in the Bot Builder centered on that node with its configuration panel selected.
View traceback appears only on notices that carry one.
Clear notices empties the list for that conversation after a confirmation. Use it once you have acted on them, so the next look shows only what is still failing.

Across the tenant

The Flow Notices screen, under Conversational in the sidebar, groups the notices of every conversation by flow, node and code, with filters by range, level and flow. From a row you open the affected conversations and jump to the node in the editor.

Closing the loop with the publish gate

The publish gate checks the flow before it goes live, and several of its rules exist precisely because of a notice seen in production:

An Error handle left unconnected is a warning at publish time. In production, a failure on that node lands as node_failed_no_error_handle, and the outcome depends on the channel: on WhatsApp the conversation is closed and handed to a human agent; on web and email it goes back to the connector's default bot or, without one, is left with no active flow.
A message that reads a variable nobody writes is flagged at publish time. In production it becomes a node_warning and the customer receives the literal {{name}}.
An ask-file with no destination, or a file consumer that reads a list, is flagged at publish time. In production they become answer_without_destination and a first file taken warning on the consumer.

The gate catches what can be known from the graph. Notices catch what only shows up with real customers: Meta rejections, expired codes, files that never arrived. Read both.