Alerts and notification delivery
Alerts turn a detected change in monitored data into a targeted user message. The system stores alert rules and delivery channels, places accepted events in a durable queue, filters them by user choice and plan, and sends them through real-time or digest paths. This page is a child of Data ingestion and refresh pipelines; see Seed pipeline orchestration and Consumer-price validation pipeline for related source and validation flows.
Alert lifecycle
An alert moves through detection, queueing, rule matching, and channel delivery. The real-time path keeps critical events close to detection, while the digest path collects lower-priority stories for a user schedule.
This diagram shows how a source condition becomes an immediate event or a scheduled digest before it reaches a user channel.
flowchart LR
A[Detected condition] --> B[Alert event or story]
B --> C[Durable event queue or digest pool]
C --> D{Delivery path}
D -->|Real time| E[Rule and safety filters]
D -->|Digest| F[Schedule and story selection]
E --> G[Verified channels]
F --> G
G --> H[User-facing notification]
Condition events
Source workers and product surfaces create alert events when a monitored condition crosses a domain threshold or when a breaking story becomes eligible. Events carry a type, severity, title, and source data. Browser-submitted events stay tied to the submitting user; trusted worker events can reach every user whose rules match.
Rules can opt into watched-site and reservoir-level events. These are paid capabilities. The aviation path can add watchlist context to a tracked flight, but that context does not admit the flight or create an event by itself. Digest processing can also publish a watchlist story alert outside the scheduled digest path.
Publishers suppress repeated source events before queueing them. A stable event identity can represent a group of notices that describe one condition, so one condition does not create a burst of messages.
References: scripts/ais-relay.cjs• L747-785 scripts/seed-aviation.mjs• L370-411 scripts/seed-digest-notifications.mjs• L606-647 scripts/seed-military-flights.mjs• L1697-1725 convex/alertRules.ts• L273-354
Market alert ledger
The market alert ledger turns fresh market quotes, prediction changes, and digest news context into persistent signal evidence. It keeps each signal in a short working window, checks closed windows against the story archive, and publishes a scorecard for later review. It is evidence for a signal, not a delivery channel; notification fan-out remains a separate step.
The ledger accepts only recent inputs. If a source or the archive cannot prove the needed time window, entries stay pending rather than becoming false misses.
References: scripts/seed-market-alert-ledger.mjs• L253-319 scripts/seed-market-alert-ledger.mjs• L358-410 scripts/seed-market-alert-ledger.mjs• L447-483
AIS gap signals
The AIS relay creates a shared gap signal from position ingestion. A vessel that returns after a long position gap is counted for a short window and published for downstream anomaly processing. This replaces separate browser-session counts with one trusted source signal.
The relay publishes the count and its freshness stamp from the same sample time. It publishes a valid zero when no return exists, but publishes neither value while the position feed is stale. Downstream health checks can therefore distinguish a quiet maritime state from a blind sensor.
References: scripts/ais-relay.cjs• L9120-9178 scripts/ais-relay.cjs• L9358-9378 scripts/ais-relay.cjs• L9641-9672 scripts/ais-relay-ais-gaps.test.cjs• L41-69
Queue processing
The shared event queue separates detection from delivery. Publishers add events to the queue, and the notification relay reads them so a relay restart does not discard queued work. Internal control events use the same service boundary but are not available through the public event endpoint.
The public notification route accepts authenticated event publishing and checks event shape, size, rate, idempotency, and reserved event types before queueing. It shapes caller-provided content before delivery. A request that times out after the queue may have accepted it returns an outcome-unknown result rather than encouraging an unsafe immediate replay.
Cross-user rule reads use bounded pages. This prevents one large account from blocking relay or digest work for every other account. Some event classes also receive a bounded copy for API-key webhook consumers; that fan-out is independent of the main queue.
References: api/notify.ts• L124-337 scripts/notification-relay.cjs• L85-98 scripts/notification-relay.cjs• L1723-1768 convex/alertRules.ts• L824-849
Rule matching
Alert rules describe which events a user wants and where to receive them. A rule belongs to a product variant and can limit event types, severity, countries, market tickers, and chokepoints. Empty scopes have different meanings: an empty country scope is broad for paid users but is not allowed for an enabled free rule; an empty ticker scope disables watchlist story delivery; and an empty chokepoint scope means any opted-in chokepoint.
The relay applies the rule before it contacts a channel. Browser-submitted events stay within the submitting user's rules. Country-scoped rules drop unattributed events by default, with narrow exceptions for news-origin, ticker, and chokepoint alerts. Regional events match through their region.
The rule service bounds the shape and number of stored rules. It normalizes scopes and keeps one rule per product variant for an account. These limits protect the shared reads that feed delivery.
References: convex/alertRules.ts• L42-81 convex/alertRules.ts• L356-475 convex/alertRules.ts• L824-849 scripts/notification-relay.cjs• L1123-1299
Channel fan-out
After a rule matches, the relay selects the user's verified channels named by that rule. Digest delivery adds ownership checks for email and Telegram. It formats the event for each target and attempts delivery independently, so one failed channel does not stop other attempts.
The real-time sinks include Telegram, Slack, Discord, Microsoft Teams, email, webhooks, and browser push. A provider can mark a destination as gone; the system then marks that channel unverified for repair. Optional personalized impact text can enrich a message, but a failure in that optional path does not remove the base alert.
Digest sends use one selected story set and one editorial synthesis for the user. The same source is adapted for each supported channel. Realtime webhook payloads also use shaped event fields, so a webhook does not bypass the notification content boundary.
References: scripts/notification-relay.cjs• L769-809 scripts/notification-relay.cjs• L1650-1721 scripts/notification-relay.cjs• L1862-1933 scripts/seed-digest-notifications.mjs• L2429-2503 scripts/seed-digest-notifications.mjs• L2679-2725
Alert rules
Rules are the user policy between a detected condition and a notification. The settings route writes rules, channels, digest settings, and quiet-hour preferences through one authenticated boundary. The system now supports a capability ladder: free accounts can use a limited critical-alert setup, while paid plans unlock broader channels, scopes, sensitivities, digest modes, and AI digest access.
Severity and cadence
Each rule has a sensitivity of critical, high, or all. Realtime delivery is reserved for critical events. High and all events use a digest cadence, which keeps frequent events from becoming an inbox flood.
Supported cadences are:
realtimefor immediate critical notifications.dailyfor one local-time digest.twice_dailyfor two local-time digest slots.weeklyfor one weekly digest slot.
The server validates sensitivity and cadence as one pair. A change from a digest to realtime therefore cannot leave an invalid intermediate rule. The settings route provides an atomic configuration action when both values change. Paid plans can also enable AI-composed digest text.
References: convex/alertRules.ts• L137-175 convex/alertRules.ts• L658-821 api/notification-channels.ts• L921-979 shared/alert-capabilities.ts• L40-52
Scope controls
Country and ticker scopes reduce the event set without changing source data. Country values and ticker values are normalized and capped. A market watchlist can update ticker scope when a user changes the watchlist, but only for a rule that opts into watchlist story alerts.
Scope meaning depends on the alert type. Paid rules may use an empty country list for worldwide alerts. Free enabled rules must name a bounded set of countries. Watchlist stories need an explicit ticker match. Chokepoint alerts accept any chokepoint after event-type opt-in, or a listed subset. Watched-site and reservoir scopes are explicit paid opt-ins.
References: convex/alertRules.ts• L178-354 convex/alertRules.ts• L740-779 shared/alert-capabilities.ts• L65-102 src/…/notification-channels.ts• L34-61
Plan capabilities
The alert capability model defines the product limits used by rule writes. Free users can receive critical alerts through email and browser push for a bounded country set. Paid users can use all supported channels, sensitivities, digest modes, wider country scope, and AI digest features. Watched-site and reservoir alerts remain Pro-only even when another free alert setting is allowed.
The edge route gives clear responses for free-ladder limits and passes structured validation or upgrade errors through to the client. The Convex write checks the effective post-write rule state in the same transaction. Delivery also applies a plan clamp so an old rule cannot grant access after a downgrade.
References: api/notification-channels.ts• L441-535 api/notification-channels.ts• L593-632 convex/alertRules.ts• L84-135 convex/alertRules.ts• L285-354 convex/…/alertCapabilities.ts• L22-76 shared/alert-capabilities.ts• L81-217
Digest generation
The digest worker turns recent story tracks into a scheduled edition. It reads enabled non-realtime rules, checks each rule's local schedule, builds a story set from the shared accumulator, and sends it only when the rule is due and has an allowed channel. It can refresh a stored brief without sending a notification.
Digest schedule
The digest job runs every 30 minutes. A per-user and per-variant last-sent record prevents repeated sends in one schedule slot. The digest window begins after the prior successful send, or uses a bounded first-send lookback when no prior send exists. A failed story read does not count as a successful send.
Digest rules use the rule's time zone and local hour. A digest is sent only when it has stories and at least one verified channel selected by the rule. Watchlist story scanning is independent of the main digest-rule read, so a scan or rule-read failure does not silently make the other path appear healthy.
The worker composes one brief candidate per user before channel fan-out. It keeps the winning rule, story set, synthesis, and signed brief link together. If composition fails, the worker can send the story list without the brief for that run while still reporting the composition failure.
References: scripts/seed-digest-notifications.mjs• L429-528 scripts/seed-digest-notifications.mjs• L606-647 scripts/seed-digest-notifications.mjs• L1544-1655 scripts/seed-digest-notifications.mjs• L2298-2456 convex/alertRules.ts• L851-862
Digest source warming
The relay keeps the shared story source current even when no reader requests a particular edition and language. It requests each catalog-defined pair through the normal digest path, then records fresh, stale, and failed results. The health heartbeat advances only when enough cells serve usable news, so a mostly failed cycle remains visible.
References: scripts/ais-relay.cjs• L5582-5625 scripts/…/news-digest-warm.cjs• L3-140 shared/news-catalog.ts• L191-215
Story selection
Digest selection favors current and meaningful event stories instead of every item seen by ingestion. The worker removes stale or unsuitable material, filters by sensitivity, orders stories by importance, merges duplicates, groups related topics when supported, and applies a bounded story count.
An optional score floor can remove low-importance clusters after deduplication. If it removes every cluster, the worker records a distinct skip signal. The digest can include an executive summary and a link to the longer WorldMonitor Brief. Fallbacks preserve the story list when summary generation fails.
References: scripts/seed-digest-notifications.mjs• L718-907 scripts/seed-digest-notifications.mjs• L909-1074 scripts/seed-digest-notifications.mjs• L1675-1815 scripts/seed-digest-notifications.mjs• L1919-2043
Accumulator retention
The digest accumulator is a shared story pool for scheduled digests and related readers. Cleanup keeps it bounded while preserving the required lookback. Deletion is a reviewed cutover: a dry run identifies exact keys, and an apply run removes members only after archive coverage proves that replacement evidence is ready.
References: scripts/_forecast-evidence-archive.mjs• L35-61 scripts/prune-digest-accumulator.mjs• L126-211 scripts/prune-digest-accumulator.mjs• L214-406
Digest channels
Digest content is rendered for the target channel. Email can carry the full brief, while Telegram, Slack, Discord, and Teams use shorter or provider-specific forms. A user webhook receives a versioned JSON digest with the selected stories and optional summary.
The worker records delivery at story-cluster and channel level after a successful send. Schedule state stays separate, so a failed channel can be retried. The schedule is marked sent only after at least one channel succeeds. Email retries use an identity based on the scheduled local hour and exact message payload, so two daily slots remain distinct.
References: scripts/seed-digest-notifications.mjs• L1352-1433 scripts/seed-digest-notifications.mjs• L2429-2529 scripts/seed-digest-notifications.mjs• L2531-2851 scripts/seed-digest-notifications.mjs• L2981-3039
Notification channels and relays
Channels hold a user's verified delivery identity. The browser settings route authenticates the user and forwards validated changes to Convex. The relay reads channels through a private service boundary and turns queued work into external side effects.
Channel types
The product supports direct and service-backed delivery targets:
| Channel | Delivery role |
|---|---|
| Telegram | Sends messages to a paired private chat after trusted callback proof. |
| Slack | Sends text to an OAuth-linked incoming webhook. |
| Discord | Sends text to an OAuth-linked guild webhook. |
| Microsoft Teams | Sends alert or notice cards to a connected Teams workflow. |
| Sends a message to the verified account address. | |
| Webhook | Sends a signed WorldMonitor event or digest envelope to a user endpoint. |
| Browser Push | Sends a short notification to a browser push subscription. |
Provider failures can mark a channel unverified without deleting its saved record. This lets the settings surface show that the connection needs attention. Removing a channel also removes it from alert rules.
References: convex/schema.ts• L136-200 convex/notificationChannels.ts• L189-200 convex/notificationChannels.ts• L422-464 src/…/notification-channels.ts• L9-32
Channel registration
The edge route authenticates the session, applies a per-user write limit, and forwards validated channel and rule changes. Optional idempotency keys let a client retry a write without applying it twice. Billing verification failures remain retryable; confirmed free accounts continue through the free alert ladder and receive a structured denial only when they request a paid capability.
Telegram uses a short-lived pairing token. Slack and Discord use an OAuth handoff. Browser Push registers a browser subscription and transfers a shared endpoint to the current account. Webhook registration checks the destination before storage, encrypts the endpoint, and returns a signing secret only once. Saving a webhook again rotates that secret.
New channel connections use durable welcome scheduling when the backend owns that capability. During a mixed deployment, the edge route fails closed rather than creating both durable and legacy welcomes. The legacy queue is used only when the backend has not taken ownership.
References: api/notification-channels.ts• L43-49 api/notification-channels.ts• L291-343 api/notification-channels.ts• L441-689 api/notification-channels.ts• L703-792 api/_notification-webhook-ssrf.ts• L161-244
Relay boundaries
The notification relay reads queued events, current rules, and verified channels. It checks the user's plan, applies quiet hours and deduplication, shapes content, and calls each provider. The queue keeps source workers independent from provider latency and outages.
Channel welcomes and quiet-hour flushes use controlled internal event types. A welcome checks the current channel identity before sending. Held alerts are drained only when the current rule still allows the channel. Each provider attempt is isolated from the others.
References: scripts/notification-relay.cjs• L47-60 scripts/notification-relay.cjs• L225-350 scripts/notification-relay.cjs• L1363-1519 scripts/notification-relay.cjs• L1723-1933 convex/http.ts• L469-550
Webhook envelopes
User webhooks receive HTTPS POST requests with a versioned JSON envelope. Real-time events contain the event type, severity, timestamp, variant, and shaped event payload. Digest deliveries contain the digest event type, selected stories, optional summary, and story count. The relay and digest worker share this contract.
Slack, Discord, and Teams use provider-specific payloads instead of the WorldMonitor webhook envelope. Webhook targets are decrypted only for delivery and are not exposed in normal channel reads. Realtime webhook payloads use shaped title, source, description, link, and corroboration fields.
References: scripts/notification-relay.cjs• L1485-1508 scripts/notification-relay.cjs• L1900-1927 scripts/seed-digest-notifications.mjs• L1385-1432 api/notification-channels.ts• L739-752
Delivery safeguards
Delivery safeguards protect access rights, reduce repeated messages, and stop unsafe or stale destinations. They apply at more than one boundary because a rule, event, or channel can arrive from another service or an older deployment.
Entitlement and identity gates
User-facing notification writes use the alert capability ladder. Free accounts can create the limited free setup; paid features are rejected with a machine-readable upgrade response. The edge route returns a retryable response when billing cannot be verified. The relay checks the entitlement again before fan-out and fails closed when that check is unavailable.
Browser-submitted events carry the authenticated user's identity and match only that user's rules. The public event route rejects reserved relay events, limits writes, and bounds the payload so a user cannot turn it into a broadcast path.
References: api/notification-channels.ts• L441-535 api/notification-channels.ts• L593-632 api/notify.ts• L99-185 convex/alertRules.ts• L84-135 shared/alert-capabilities.ts• L159-215
Duplicate suppression
Deduplication operates before queue fan-out and again per recipient. Publishers use a stable event identity with a limited lifetime. The relay uses a user-specific key and can coalesce notices that describe one condition. If queue insertion fails after a dedup claim, the claim is removed or the enqueue is atomic so a transient queue error does not suppress the next attempt.
Digest sends use separate schedule and delivered-story records. This supports repeat-story analysis without making a failed channel look successful. Email adds a channel-specific key for safe retries after an uncertain provider response.
References: scripts/ais-relay.cjs• L747-781 scripts/notification-relay.cjs• L115-127 scripts/notification-relay.cjs• L1824-1860 scripts/seed-digest-notifications.mjs• L2531-2665 scripts/seed-digest-notifications.mjs• L2727-2807
Quiet-hour handling
Users can define a local quiet window with one of three policies: allow critical events only, silence all events, or hold non-critical events until wake. Held events use a bounded queue and expire after 24 hours. When the window ends or the policy changes away from batching, the relay sends a compact batch through channels still allowed by the current rule.
Quiet hours apply to real-time event delivery. Digest schedules remain separate and use their own cadence and delivery checks.
References: scripts/notification-relay.cjs• L387-550 convex/alertRules.ts• L478-655 api/notification-channels.ts• L860-892
Destination safety
Webhook registration accepts only non-empty HTTPS destinations and checks their DNS answers for private or reserved addresses. The relay repeats the DNS check at send time and pins the request to the checked address. It also limits request time and response size.
Browser Push uses an allow-list of known push-service hosts before it stores a subscription. A provider response that says a webhook or push subscription no longer exists deactivates that channel and stops repeated attempts.
References: api/_notification-webhook-ssrf.ts• L128-244 api/notification-channels.ts• L755-792 scripts/…/notification-webhook-ssrf.cjs• L172-301 scripts/notification-relay.cjs• L559-679
Event shaping
Event shaping is the content safety boundary between accepted alert data and user-facing channels. The publish route cleans caller-provided fields. The relay repeats the shaping for trusted worker events that bypass the route, then applies channel-specific link rules.
Text channels can show an article link with its destination host. Browser Push uses a first-party dashboard path when it cannot safely disclose the destination. Realtime webhooks and Teams cards receive shaped content. Optional AI impact text is treated as untrusted and cannot block the base alert.
References: api/notify.ts• L217-337 scripts/notification-relay.cjs• L1373-1519 scripts/notification-relay.cjs• L1650-1721 scripts/notification-relay.cjs• L1888-1927
Link suppression
Link suppression is an operator-controlled revoke path for notification links. Operators can block one normalized HTTP(S) URL or a host and its subdomains in a shared Redis set. The relay checks this set before fan-out and checks held events again when quiet-hour batches drain.
The anonymous suppression endpoint serves the service worker a snapshot for already-delivered push messages. Exact URLs are returned as SHA-256 digests so query strings and fragments are not exposed; host rules remain readable for subdomain matching. The endpoint rejects query strings, uses a shared cache, and limits origin requests. Redis read failures return an explicit unavailable result without caching it, so the service worker fails open and does not strand normal notification clicks.
The relay and service worker use the same URL normalization. Alert tracking parameters are removed before comparison, so an operator block applies both before and after delivery adds channel-specific tracking parameters.
References: scripts/…/notification-link-suppression.cjs• L1-27 scripts/…/notification-link-suppression.cjs• L44-180 api/notification-suppressions.js• L1-24 api/notification-suppressions.js• L45-63 api/notification-suppressions.js• L186-252
Change checklist
When these files or sections are changed, remember to consider these:
- Change the event envelope in both the real-time relay and digest worker; user webhook consumers can receive events from both producers.
- Change a channel type or ownership proof only with matching schema, edge validation, browser service calls, relay and digest dispatch, and channel removal behavior.
- Change
digestModeorsensitivityas one policy; preserve the atomic notification-config path so an intermediate invalid pair cannot be stored. - Change free or paid alert limits in the shared capability model, edge prechecks, Convex writes, and delivery-time clamp together.
- Change country, ticker, or chokepoint scope rules with their matching relay semantics; empty scopes do not have one universal meaning.
- Change watched-site or reservoir alerts with their paid gates, bounded rule shape, event registry, and downstream event matching.
- Change rule row shape or count limits with every writer and every cross-tenant paginated reader; one oversized account must not stop delivery for all users.
- Change queue or dedup behavior with the publisher rollback or atomic enqueue path; a dedup claim without a queued event silently loses an alert.
- Change webhook URL checks in both registration and delivery paths; registration-time DNS safety does not cover later DNS changes.
- Change quiet-hour control events with reserved-event protection; public event publishing must not gain a way to drain held alerts.
- Change the channel welcome flow with durable scheduling and legacy fallback; mixed edge and backend versions must not send duplicate welcomes.
- Change notification payload fields with both publish-route and relay shaping; worker events bypass the edge endpoint and sinks use different link rules.
- Change operator link suppression with the shared matcher, relay cache, quiet-hour drain check, anonymous snapshot, and service-worker click check.
- Change digest story filters, score floors, dedup, or synthesis with the formatter story set, webhook payload, delivered-story log, and channel send pass.
- Change digest email rendering or scheduled-slot handling with the provider idempotency key; retries must reuse one key while separate slots remain distinct.
- Change suppression snapshot caching or failure handling without preserving the anonymous endpoint's fail-open click behavior and no-store unavailable response.
Important failure modes
| Trigger | Consequence | Guard |
|---|---|---|
| A rule combines realtime delivery with high or all sensitivity. | The rule is rejected and no such realtime stream is created. | Shared delivery-mode validation and the atomic config update. |
| A free account requests an unsupported channel, sensitivity, digest mode, or worldwide scope. | The write is rejected with a targeted upgrade response. | Shared capability checks at the edge and Convex layers. |
| A watched-site or reservoir alert is requested by a free account. | The paid alert policy is not created. | Feature-specific Pro checks on rule writers. |
| The entitlement service cannot confirm a user during fan-out. | Delivery stops until the short fail-closed cache expires. | Delivery-time entitlement check. |
| A shared rule page exceeds its read budget. | Relay or digest work can fail for all users. | Byte-bounded, cursor-based cross-tenant reads. |
| A source claims a dedup key but queue insertion fails. | The alert is suppressed for the dedup window without delivery. | Atomic enqueue or dedup-key rollback. |
| A non-critical event arrives during batch-on-wake quiet hours. | It waits in a bounded queue and can expire after 24 hours. | Wake drain, settings-change flush, and queue TTL. |
| A webhook or push provider reports a gone destination. | Future attempts stop for that channel. | The relay marks the channel unverified. |
| A webhook URL is blank, private, reserved, or resolves to a private address. | The channel is rejected or the request is not sent. | Registration and delivery DNS checks with a pinned address. |
| A notification link is added to the operator suppression set. | New delivery stops, and a clicked push notification can stop before navigation. | Shared exact/host matching at relay and service-worker boundaries. |
| Redis cannot be read for the suppression snapshot. | The service worker continues normal navigation without applying a possibly stale block. | Explicit unavailable response, no-store failure shape, and fail-open click behavior. |
| Digest composition fails for a user. | The story list can still be sent without the brief content for that run. | Composition fallback and a final run-level failure signal. |
| An email provider accepts a digest but its response times out. | The send may be retried because schedule state is not yet marked sent. | Exact-payload idempotency key scoped to the scheduled local hour. |
| Edge and Convex disagree about durable welcome scheduling. | A new channel can receive duplicate welcomes or no welcome. | Capability negotiation and fail-closed mixed-version behavior. |
| A trusted event contains unsafe content or an unsafe link. | A user-facing channel can show misleading content or an unsafe click target. | Relay-side shaping, channel link rules, and first-party push fallback. |
Key files
| File | Why to read it |
|---|---|
| convex/alertRules.ts | Defines rule policy, capability checks, cadence and sensitivity rules, scope limits, row limits, and paginated reads. |
| shared/alert-capabilities.ts | Defines the free alert ladder and the paid capabilities that rule writes must satisfy. |
| convex/notificationChannels.ts | Defines channel ownership, verification, deletion cleanup, internal writes, and welcome work. |
| convex/schema.ts | Shows the durable shape of notification channels and alert rules. |
| api/notification-channels.ts | Connects the settings surface to Convex and coordinates validation, plan responses, idempotency, rate limits, and welcome scheduling. |
| api/notify.ts | Defines the event-publish boundary, payload shaping, queue limits, idempotency, and publish outcome contract. |
| api/notification-suppressions.js | Serves the anonymous suppression snapshot used by notification clicks. |
| scripts/notification-relay.cjs | Shows queue consumption, rule matching, plan checks, quiet hours, suppression, shaping, deduplication, and provider fan-out. |
| scripts/…/notification-link-suppression.cjs | Defines the exact-URL and host suppression rules shared by the relay and service worker. |
| scripts/seed-digest-notifications.mjs | Shows digest timing, story selection, brief composition, channel formatting, delivery, and delivered-story records. |
| scripts/…/news-digest-warm.cjs | Defines the source-warm cycle that keeps digest story cells fresh and reports partial coverage. |
| scripts/seed-market-alert-ledger.mjs | Shows how fresh market and news inputs become persistent market-alert evidence and a scorecard. |
| scripts/prune-digest-accumulator.mjs | Shows the reviewed cleanup flow for bounded digest accumulator retention. |