@thehammer/danx-dashboard-mcp 0.1.88 → 0.1.89

package/dist/listen.js

@@ -11,10 +11,31 @@
  *   - `{type:"event", id, text}` — exactly one per event, the moment it arrives.
  *     `text` is what the session reads; an event it cannot read still produces one
  *     (`could not read event …`), never silence. `id` is `null` only for a frame
- *     that carried no usable id.
- *   - `{type:"stopped", reason, detail}` — once, last. `reason` is the dashboard's
- *     own end reason (`superseded`, `replaced`, `revoked`), `refused` (the ticket
- *     was not admitted), or `lease_expired` (no healthy connection for the lease).
+ *     that carried no usable id — which includes DX-2885's `nudge` frame
+ *     (`formatNudgeLine`): it is advisory, re-derived fresh every tick by the
+ *     dashboard's own keep-alive tick, and never replayed, so it rides this
+ *     same shape with `id: null` rather than growing a THIRD output variant.
+ *   - `{type:"stopped", reason, detail, refusal?, boards?}` — once, last. `reason`
+ *     is the dashboard's own end reason (`superseded`, `replaced`, `revoked`,
+ *     `scope_narrowed`, `not_connected`), `refused` (the ticket was not
+ *     admitted), `bad_end_payload` (a `scope_narrowed` end whose `boards` array
+ *     was missing/invalid — a protocol error, never silently downgraded), or
+ *     `lease_expired` (no healthy connection for the lease). DX-2920 —
+ *     `refusal` is populated ONLY for `reason === "refused"`: `{status,
+ *     errorCode, body}`, the admission response parsed ONCE here, so a
+ *     consumer can recognize a SPECIFIC refusal (the dashboard's own
+ *     `409 session_not_connected`, the same shape the mint route uses) by
+ *     status + error code rather than re-deriving it from the flattened
+ *     `detail` string. `boards` is REQUIRED (round 4 — a discriminated union,
+ *     not an optional field: see `ListenStopped` / `ListenStopReason`) for
+ *     `reason === "scope_narrowed"` and absent for every other reason, parsed
+ *     from the dashboard's `end` payload the SAME way `reason` itself is
+ *     parsed — never re-derived from `detail`. A wire `reason` value this
+ *     build does not recognize (a newer dashboard's reason an older bridge
+ *     hasn't shipped yet) normalizes to `"unknown"` rather than passing the
+ *     raw string through, so the closed set stays closed — `fixForStop`'s
+ *     generic `DEFAULT_STOP_FIX` handles it exactly as it already handled a
+ *     verbatim unrecognized string.
  *   - nothing for keep-alives, the connect marker, or a successful reconnect.
  *
  * RECONNECT AND RESUME. The stream drops whenever the dashboard restarts, and can
@@ -32,6 +53,7 @@
  * (`src/issues/db/issue-activity.ts`); this published package cannot import
  * danxbot source.
  */
+import { errorCodeOf } from "./json-body.js";
 import { oneLine } from "./one-line.js";
 export const INITIAL_BACKOFF_MS = 1_000;
 export const MAX_BACKOFF_MS = 30_000;
@@ -41,7 +63,18 @@ export const READ_IDLE_TIMEOUT_MS = 45_000;
 export const HEALTHY_CONNECTION_MS = 20_000;
 /** How many delivered event ids the duplicate guard remembers — well past the replay overlap. */
 export const DELIVERED_ID_MEMORY = 1_000;
-const LINE_PREFIX = "[danx-dashboard listen]";
+/**
+ * DX-2829 — the ONE place that caps a resume-id list to the last
+ * `DELIVERED_ID_MEMORY` entries. Both `runListener` (seeding its own
+ * duplicate-detection `Set` below) and `bridge.ts`'s `runBridge` (seeding its
+ * own delivered-id array) used to each carry their own `slice(-DELIVERED_ID_MEMORY)`
+ * — the same cap, on the same kind of input, computed twice.
+ */
+export function capResumeIds(ids) {
+    return ids.slice(-DELIVERED_ID_MEMORY);
+}
+const LINE_PREFIX = "[danx-dashboard stream]";
+const ACTIVITY_ORIGINS = new Set(["operator", "agent", "machine"]);
 function quoted(value) {
     return `"${value.text}${value.truncated ? "…" : ""}"`;
 }
@@ -69,12 +102,27 @@ export function invalidEventReason(value) {
         if (typeof value[field] !== "string")
             return `${field} is not a string`;
     }
+    // DX-2730 D4 — checked with the rest of the envelope, before any kind-specific
+    // detail check, exactly like every other envelope field above.
+    if (typeof value.origin !== "string" || !ACTIVITY_ORIGINS.has(value.origin)) {
+        return "origin is not one of operator, agent, machine";
+    }
     const d = value.detail;
     if (!isRecord(d))
         return "detail is not an object";
     switch (value.kind) {
-        case "comment_added":
-            return isCappedText(d.excerpt) ? null : "detail.excerpt is not capped text";
+        case "comment_added": {
+            if (!isCappedText(d.excerpt))
+                return "detail.excerpt is not capped text";
+            // DX-2906 — `problem` is OPTIONAL (only present when the comment named
+            // one); absent is valid, but a present-and-malformed one is not.
+            if (d.problem === undefined)
+                return null;
+            const problem = d.problem;
+            return isRecord(problem) && typeof problem.id === "number" && isCappedText(problem.statement)
+                ? null
+                : "detail.problem is not {id, statement}";
+        }
         case "solution_answered": {
             const problem = d.problem;
             if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
@@ -93,24 +141,68 @@ export function invalidEventReason(value) {
             }
             return null;
         }
+        // DX-2935 — the operator retracted a problem's answer with no new one yet.
+        case "problem_unanswered": {
+            const problem = d.problem;
+            if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
+                return "detail.problem is not {id, statement}";
+            }
+            return typeof d.decision_id === "number" ? null : "detail.decision_id is not a number";
+        }
+        // DX-2935 — the operator retracted a problem's answer AND recorded a new
+        // one, in one transaction — same either/or solution/freeform shape
+        // `solution_answered` carries, plus which decision was retracted.
+        case "problem_answer_changed": {
+            const problem = d.problem;
+            if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
+                return "detail.problem is not {id, statement}";
+            }
+            if (typeof d.retracted_decision_id !== "number")
+                return "detail.retracted_decision_id is not a number";
+            if (typeof d.decision_id !== "number")
+                return "detail.decision_id is not a number";
+            if (d.solution === null)
+                return isCappedText(d.freeform) ? null : "detail.freeform is not capped text";
+            if (!isRecord(d.solution) || typeof d.solution.title !== "string")
+                return "detail.solution is not {title, note}";
+            return d.solution.note === null || isCappedText(d.solution.note) ? null : "detail.solution.note is not capped text";
+        }
         case "blocked":
             return isCappedText(d.reason) ? null : "detail.reason is not capped text";
         default:
             return null;
     }
 }
+/**
+ * DX-2730 D4 — `actor` alone cannot distinguish an `agent` event from a
+ * `machine` one (both stamp `actor: "danxbot"` today), so every line names
+ * the origin next to the actor rather than leaving it to a separate field a
+ * reader would have to cross-reference.
+ */
+function actorLabel(event) {
+    return `${event.actor} (${event.origin})`;
+}
 /** Only ever called on an event `invalidEventReason` accepted, so its casts are checked. */
 function describe(event) {
     const d = event.detail;
+    const who = actorLabel(event);
     switch (event.kind) {
-        case "comment_added":
-            return `${event.actor} commented: ${quoted(d.excerpt)}`;
+        case "comment_added": {
+            // DX-2906 — a comment naming a problem (a follow-up question, without
+            // answering it) relays distinctly from a plain comment, so an agent
+            // listening to the stream can tell which of its open problems just
+            // got a reply.
+            const problem = d.problem;
+            if (problem === undefined)
+                return `${who} commented: ${quoted(d.excerpt)}`;
+            return `${who} commented on problem ${quoted(problem.statement)}: ${quoted(d.excerpt)}`;
+        }
         case "solution_answered": {
             // DX-2735: every answer answers ONE problem on a card that may carry several,
             // so the line names the problem — otherwise the agent cannot tell which of its
             // questions just closed.
             const problem = d.problem;
-            const answered = `${event.actor} answered ${quoted(problem.statement)}:`;
+            const answered = `${who} answered ${quoted(problem.statement)}:`;
             const solution = d.solution;
             if (solution === null)
                 return `${answered} ${quoted(d.freeform)}`;
@@ -121,16 +213,32 @@ function describe(event) {
             // DX-2830 — this IS the "needs a human" signal now: a card needs one
             // exactly when it has an open problem, and this is one being opened.
             const problem = d.problem;
-            return `${event.actor} opened a problem: ${quoted(problem.statement)}`;
+            return `${who} opened a problem: ${quoted(problem.statement)}`;
+        }
+        case "problem_unanswered": {
+            // DX-2935 — MUST read as "a previous answer was withdrawn", never as a
+            // brand-new problem: a connected session that already acted on the
+            // retracted answer has to stop, not treat this as fresh work to start.
+            const problem = d.problem;
+            return `${who} retracted the answer to ${quoted(problem.statement)}`;
+        }
+        case "problem_answer_changed": {
+            // DX-2935 — ONE line for the whole retract-and-reanswer (never two
+            // separate events), naming the statement so a listener with several
+            // open questions knows which one just moved.
+            const problem = d.problem;
+            const solution = d.solution;
+            const now = solution === null ? quoted(d.freeform) : `"${solution.title}"`;
+            return `${who} changed the answer to ${quoted(problem.statement)}: now ${now}`;
         }
         case "blocked":
-            return `${event.actor} blocked the card: ${quoted(d.reason)}`;
+            return `${who} blocked the card: ${quoted(d.reason)}`;
         case "unblocked":
-            return `${event.actor} unblocked the card`;
+            return `${who} unblocked the card`;
         default:
             // A kind newer than this listener still produces a line: an event the
             // agent is never told about is exactly the failure this reader prevents.
-            return `${event.actor}: ${event.kind}`;
+            return `${who}: ${event.kind}`;
     }
 }
 /** The one readable line for an event. Always a single line; throws, naming the fault, on a malformed event. */
@@ -140,6 +248,46 @@ export function formatActivityLine(event) {
         throw new Error(`malformed activity event: ${invalid}`);
     return oneLine(`[${event.cardId} "${event.cardTitle}" ${event.boardId}] ${describe(event)}`);
 }
+function isNudgeCardRef(value) {
+    return isRecord(value) && typeof value.id === "string" && typeof value.title === "string";
+}
+function isNudgeCardRefArray(value) {
+    return Array.isArray(value) && value.every(isNudgeCardRef);
+}
+/** Why a nudge cannot be read, or `null` when it can — same checked-before-describing shape as `invalidEventReason`. */
+export function invalidNudgeReason(value) {
+    if (!isRecord(value))
+        return "the nudge is not an object";
+    if (typeof value.idleMinutes !== "number" || !Number.isFinite(value.idleMinutes)) {
+        return "idleMinutes is not a number";
+    }
+    if (!isNudgeCardRefArray(value.startable))
+        return "startable is not a {id,title}[] array";
+    if (!isNudgeCardRefArray(value.held))
+        return "held is not a {id,title}[] array";
+    return null;
+}
+function cardList(cards) {
+    return cards.map((c) => `${c.id} "${c.title}"`).join(", ");
+}
+/**
+ * The one readable line for a nudge (DX-2885). Always names the actual
+ * waiting cards — never a generic "keep going" — because that is the whole
+ * point of the feature: a session that only sees "you're idle" learns
+ * nothing a bare timer couldn't have told it. Always a single line; throws,
+ * naming the fault, on a malformed nudge.
+ */
+export function formatNudgeLine(event) {
+    const invalid = invalidNudgeReason(event);
+    if (invalid !== null)
+        throw new Error(`malformed nudge event: ${invalid}`);
+    const parts = [];
+    if (event.startable.length > 0)
+        parts.push(`startable: ${cardList(event.startable)}`);
+    if (event.held.length > 0)
+        parts.push(`held: ${cardList(event.held)}`);
+    return oneLine(`${LINE_PREFIX} this session has been idle ${event.idleMinutes}m with work waiting — ${parts.join("; ")}`);
+}
 /**
  * Incremental SSE parser. Comment lines (keep-alives, the connect marker) and
  * field-less blocks produce no message, which is what keeps them out of the output.
@@ -181,6 +329,27 @@ function parseBlock(block) {
     }
     return sawField ? { id, event, data: data.join("\n") } : null;
 }
+/**
+ * DX-2920 (round 4) — the dashboard's own `StreamEndReason` values this
+ * client recognizes on the wire, EXCLUDING `scope_narrowed` (parsed by its own
+ * dedicated branch in `handle()` below, since it alone carries `boards`).
+ * Hand-copied from `StreamEndReason` in `src/issues/plan-session-listeners.ts`
+ * — this published package cannot import danxbot source. A wire `reason` this
+ * set does not contain (a newer dashboard's reason this build predates)
+ * normalizes to `"unknown"` rather than passing the raw string through, which
+ * is what lets `Outcome`'s `reason` field below be a closed union instead of
+ * `string` — see `ListenStopReason`'s docblock for why that closure is what
+ * makes the `scope_narrowed`-requires-`boards` invariant an actual compile
+ * error rather than a comment's promise.
+ */
+const KNOWN_WIRE_END_REASONS = new Set(["superseded", "replaced", "revoked", "not_connected"]);
+function isKnownWireEndReason(reason) {
+    return KNOWN_WIRE_END_REASONS.has(reason);
+}
+/** A thrown value's message, for the one drop path that carries a real JS error — never re-derived elsewhere. */
+function describeDropError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 /** Statuses that describe the moment, not the ticket — retry them. */
 const RETRYABLE_CLIENT_STATUSES = new Set([408, 429]);
 /**
@@ -193,22 +362,102 @@ export async function runListener(options, deps) {
     let lastEventId = null;
     let unhealthySince = null;
     let attempt = 0;
+    // DX-2829 — the most recent `dropped` outcome's cause, carried across
+    // reconnect attempts so the eventual `lease_expired` stop (the only outcome
+    // reached exclusively via repeated drops) can say what actually failed
+    // instead of only "no healthy connection ... past the ticket's lease".
+    let lastDropDetail = null;
     const remember = (id) => {
         delivered.add(id);
         if (delivered.size > DELIVERED_ID_MEMORY)
             delivered.delete(delivered.values().next().value);
         lastEventId = lastEventId === null ? id : Math.max(lastEventId, id);
     };
-    for (const id of options.resumeIds.slice(-DELIVERED_ID_MEMORY))
+    for (const id of capResumeIds(options.resumeIds))
         remember(id);
-    const stop = (reason, detail, code) => {
-        deps.write({ type: "stopped", reason, detail });
+    function stop(reason, detail, code, extra) {
+        if (reason === "scope_narrowed") {
+            if (extra?.boards === undefined) {
+                throw new Error('stop("scope_narrowed", ...) requires boards — unreachable through the exported overloads above');
+            }
+            deps.write({ type: "stopped", reason, detail, boards: extra.boards });
+            return code;
+        }
+        deps.write({ type: "stopped", reason, detail, refusal: extra?.refusal });
         return code;
-    };
+    }
     const handle = (message) => {
         if (message.event === "end") {
-            const reason = JSON.parse(message.data).reason;
-            return { kind: "ended", reason: typeof reason === "string" ? reason : "unknown" };
+            // DX-2920 (round 3) — a JSON.parse failure here falls through to the
+            // pre-existing "unknown" reason below via `isRecord(null)`, unchanged
+            // from before this round. Only a `scope_narrowed` reason additionally
+            // REQUIRES a valid `boards` string array (matching the server's `end`
+            // overload, which cannot emit `scope_narrowed` without one) — a
+            // `scope_narrowed` frame that fails that check is a PROTOCOL error
+            // (a server too old to have sent boards, or a corrupted frame), never
+            // silently downgraded to the generic "the dashboard ended this
+            // listener" message the caller cannot act on.
+            let parsed;
+            try {
+                parsed = JSON.parse(message.data);
+            }
+            catch {
+                parsed = null;
+            }
+            const reasonRaw = isRecord(parsed) ? parsed.reason : undefined;
+            const reason = typeof reasonRaw === "string" ? reasonRaw : "unknown";
+            if (reason === "scope_narrowed") {
+                const boardsRaw = isRecord(parsed) ? parsed.boards : undefined;
+                const boards = Array.isArray(boardsRaw) && boardsRaw.length > 0 && boardsRaw.every((b) => typeof b === "string")
+                    ? boardsRaw
+                    : null;
+                if (boards === null) {
+                    return { kind: "ended", reason: "bad_end_payload" };
+                }
+                return { kind: "ended", reason, boards };
+            }
+            // DX-2920 (round 4) — a wire reason this build does not recognize (a
+            // newer dashboard's reason an older bridge hasn't shipped yet)
+            // normalizes to "unknown" rather than passing the raw string through:
+            // `Outcome`'s "ended" reason is now a closed set (`EndedReason`), and an
+            // open passthrough here would be exactly the hole that lets a
+            // missing-`boards` "scope_narrowed" construction slip past the compiler
+            // elsewhere — see `ListenStopReason`'s docblock.
+            return { kind: "ended", reason: isKnownWireEndReason(reason) ? reason : "unknown" };
+        }
+        if (message.event === "nudge") {
+            // DX-2885 — a nudge carries no usable id (it is advisory, re-derived
+            // fresh every tick, never replayed — see `plan-session-stream.ts`'s
+            // module doc), so it rides the SAME `{type:"event", id:null, text}`
+            // shape an ordinary activity line uses (`id` is `null` only for a frame
+            // that carried no usable id — a nudge is exactly that case). That is
+            // what lets `bridge.ts` and the plugin's relay
+            // (`danxbot/scripts/plan-event-bridge.mjs`, outside this repo) forward
+            // it with NO changes at all: both already forward any `{type:"event",
+            // id, text}` line generically, keyed only on `type`.
+            //
+            // DX-2885 — this frame must stay exempt from DX-2730 D4's digest-
+            // batching when that lands (see DX-2730 AC 29939, and the matching note
+            // at the dashboard's own emit site): it must keep delivering
+            // immediately, never held for a later digest flush.
+            let parsed;
+            let invalid;
+            try {
+                parsed = JSON.parse(message.data);
+                invalid = invalidNudgeReason(parsed);
+            }
+            catch (err) {
+                invalid = `not JSON: ${err.message}`;
+            }
+            const text = invalid === null
+                ? formatNudgeLine(parsed)
+                : `${LINE_PREFIX} could not read nudge (${invalid}): ${oneLine(message.data, 300)}`;
+            // DX-2730 D4 — `origin: null` here, not the parsed event's own origin
+            // (a nudge has none): this is the exemption the module doc above
+            // describes, letting `bridge.ts` treat it exactly like an operator
+            // event (immediate) without needing a fourth vocabulary member.
+            deps.write({ type: "event", id: null, text, origin: null });
+            return null;
         }
         if (message.event !== "activity")
             return null;
@@ -237,7 +486,13 @@ export async function runListener(options, deps) {
                 // DX-2735: oneLine caps by code point, so a bad event carrying an emoji
                 // at the cut can never leave a lone surrogate in the line.
                 oneLine(message.data, 300);
-        deps.write({ type: "event", id: knownId ? id : null, text });
+        // DX-2730 D4 — an event this listener could not parse carries `origin: null`
+        // (emit immediately) rather than the unreadable payload's own claimed
+        // origin: a fault worth surfacing at all must never be hidden behind a
+        // 10-minute digest wait just because it happened to come from an agent or
+        // a machine writer.
+        const origin = invalid === null ? parsed.origin : null;
+        deps.write({ type: "event", id: knownId ? id : null, text, origin });
         if (knownId)
             remember(id);
         return null;
@@ -262,11 +517,29 @@ export async function runListener(options, deps) {
             armIdle();
             const response = await deps.fetch(options.streamUrl, { headers, signal: controller.signal });
             if (response.status >= 400 && response.status < 500 && !RETRYABLE_CLIENT_STATUSES.has(response.status)) {
-                return { kind: "refused", detail: `HTTP ${response.status} ${oneLine(await response.text(), 300)}` };
+                const text = await response.text();
+                // DX-2920 — parsed ONCE, here, into a structured outcome a consumer can
+                // classify by status + error code (`bridge.ts` does, matching a specific
+                // admission refusal such as the dashboard's own `409 session_not_connected`)
+                // rather than re-deriving it from the flattened `detail` string below.
+                let body = null;
+                try {
+                    body = text === "" ? null : JSON.parse(text);
+                }
+                catch {
+                    body = null;
+                }
+                return {
+                    kind: "refused",
+                    status: response.status,
+                    errorCode: errorCodeOf(body),
+                    body,
+                    detail: `HTTP ${response.status} ${oneLine(text, 300)}`,
+                };
             }
             if (!response.ok || response.body === null) {
                 await response.body?.cancel();
-                return { kind: "dropped", healthy: false };
+                return { kind: "dropped", healthy: false, detail: `HTTP ${response.status} with no readable body` };
             }
             const parser = new SseParser();
             const decoder = new TextDecoder();
@@ -282,8 +555,14 @@ export async function runListener(options, deps) {
             }
             return { kind: "dropped", healthy: healthy() };
         }
-        catch {
-            return { kind: "dropped", healthy: healthy() };
+        catch (err) {
+            // DX-2829 — was a bare `catch { ... }` that discarded the causing error
+            // entirely: a connection that failed the same way on every retry (DNS
+            // failure, TLS reset, the idle-timeout abort) surfaced nothing beyond
+            // "no healthy connection" once the lease finally expired. Preserving the
+            // message here is what lets `runListener` name the actual last failure
+            // in its final `lease_expired` stop record below.
+            return { kind: "dropped", healthy: healthy(), detail: describeDropError(err) };
         }
         finally {
             clearTimeout(idle);
@@ -296,11 +575,26 @@ export async function runListener(options, deps) {
             if (outcome.reason === "superseded" || outcome.reason === "replaced") {
                 return stop(outcome.reason, "another listener for this session took over", 0);
             }
+            if (outcome.reason === "bad_end_payload") {
+                return stop("bad_end_payload", "the dashboard's scope_narrowed end event carried no valid boards array — this is a protocol error, not an ordinary end", 1);
+            }
+            // DX-2920 (round 4) — split explicitly rather than the old conditional
+            // `outcome.boards === undefined ? undefined : {boards}` pass-through:
+            // `Outcome`'s "ended" kind is now itself discriminated on `reason`, so
+            // `outcome.boards` is GUARANTEED present here (no `?? []`, no optional
+            // check needed) once narrowed to `"scope_narrowed"`.
+            if (outcome.reason === "scope_narrowed") {
+                return stop("scope_narrowed", "the dashboard ended this listener", 1, { boards: outcome.boards });
+            }
             return stop(outcome.reason, "the dashboard ended this listener", 1);
         }
         if (outcome.kind === "refused") {
-            return stop("refused", `the dashboard refused the listener ticket: ${outcome.detail}`, 1);
+            return stop("refused", `the dashboard refused the listener ticket: ${outcome.detail}`, 1, {
+                refusal: { status: outcome.status, errorCode: outcome.errorCode, body: outcome.body },
+            });
         }
+        if (outcome.detail !== undefined)
+            lastDropDetail = outcome.detail;
         if (outcome.healthy) {
             unhealthySince = null;
             attempt = 0;
@@ -308,7 +602,10 @@ export async function runListener(options, deps) {
         const now = deps.now();
         unhealthySince ??= now;
         if (now - unhealthySince >= options.leaseMs) {
-            return stop("lease_expired", `no healthy connection to ${options.streamUrl} for ${Math.round((now - unhealthySince) / 60_000)} minutes, past the ticket's lease`, 1);
+            // DX-2829 — names the last connection failure when one was ever recorded,
+            // instead of only reporting the timeout itself.
+            const cause = lastDropDetail === null ? "" : ` — last connection attempt failed: ${lastDropDetail}`;
+            return stop("lease_expired", `no healthy connection to ${options.streamUrl} for ${Math.round((now - unhealthySince) / 60_000)} minutes, past the ticket's lease${cause}`, 1);
         }
         await deps.sleep(Math.min(MAX_BACKOFF_MS, INITIAL_BACKOFF_MS * 2 ** attempt));
         attempt += 1;

package/dist/one-line.js

@@ -1,7 +1,8 @@
 /**
  * DX-2735 — the ONE way this package renders human text into an agent-facing
- * line: the listen notification line and the problems reminder both go
- * through it, so they can never disagree about how a statement looks.
+ * line: the dashboard-event stream's notification line and the problems
+ * reminder both go through it, so they can never disagree about how a
+ * statement looks.
  *
  * Every whitespace run (newlines included) collapses to a single space, because
  * a notification is one line and a reminder quotes statements inline. The