From f2011b9b86025084a8a250fdb134dd2a9422f53c Mon Sep 17 00:00:00 2001
From: Makisuo <minetoaster12@gmail.com>
Date: Wed, 14 Oct 2026 20:40:25 +0200
Subject: [PATCH 1/2] feat(errors): server-side Closed tab, issue search,
 errors:tick and errors:replay

The Resolved tab filtered a mixed page of the 50 most recently seen issues in
the browser, so it rendered empty, with no "Load more", whenever that page was
all open issues. Done issues archived after 14 days never showed at all.

- v2 GET /error_issues takes `state=open|closed`, `search` and
  `include_archived`; the web list asks the server for exactly its view.
- Tabs are Open / Closed / All (old `view` values still decode). Closed holds
  verifying, done, cancelled and wontfix, archived ones included.
- A debounced search box (`?q=`) over type, message, label and service.
- The stat strip keeps error events and their share of spans; the toolbar
  counts issues.
- `bun run errors:tick` fires the alerting minute cron on a local stack.
- `bun run errors:replay` groups a sample of error events with today's
  fingerprint and a proposed v3, checks parity against production hashes,
  and lists the largest merges.
---
 apps/api/src/routes/v2/error-issues.http.ts   |   3 +
 .../components/errors/error-signal-row.tsx    |   2 +-
 .../src/components/errors/errors-hub-view.tsx | 102 ++++++++-----
 apps/web/src/components/errors/errors-hub.tsx |  23 +--
 .../components/errors/errors-stat-strip.tsx   |   9 +-
 apps/web/src/lab/errors-lab.tsx               |  20 ++-
 apps/web/src/lib/errors/hub-params.ts         |  14 +-
 apps/web/src/routes/errors/index.tsx          |  10 +-
 apps/web/src/routes/errors/issues/index.tsx   |  19 +--
 docs/error-issue-lifecycle.md                 |  14 ++
 package.json                                  |   2 +
 .../ErrorIssueReadModelsService.test.ts       |  52 +++++++
 .../errors/ErrorIssueReadModelsService.ts     |  10 +-
 packages/domain/src/http/v2/error-issues.ts   |   7 +
 scripts/errors-replay.ts                      | 136 ++++++++++++++++++
 scripts/errors-replay/candidate.ts            | 115 +++++++++++++++
 scripts/errors-replay/corpus.jsonl            |  18 +++
 scripts/errors-tick.ts                        |  44 ++++++
 18 files changed, 530 insertions(+), 70 deletions(-)
 create mode 100644 scripts/errors-replay.ts
 create mode 100644 scripts/errors-replay/candidate.ts
 create mode 100644 scripts/errors-replay/corpus.jsonl
 create mode 100644 scripts/errors-tick.ts

diff --git a/apps/api/src/routes/v2/error-issues.http.ts b/apps/api/src/routes/v2/error-issues.http.ts
index 1dae016783..6b41b49b05 100644
--- a/apps/api/src/routes/v2/error-issues.http.ts
+++ b/apps/api/src/routes/v2/error-issues.http.ts
@@ -151,6 +151,9 @@ export const HttpV2ErrorIssuesLive = HttpApiBuilder.group(MapleApiV2, "errorIssu
 						endTime: query.end_time,
 						introducedAfter: query.introduced_after,
 						actionable: query.actionable === "true",
+						stateGroup: query.state,
+						search: query.search?.trim() || undefined,
+						includeArchived: query.include_archived === "true",
 						sort,
 						limit: query.limit ?? 20,
 						cursor,
diff --git a/apps/web/src/components/errors/error-signal-row.tsx b/apps/web/src/components/errors/error-signal-row.tsx
index bc70b8d3c9..32954b0f0d 100644
--- a/apps/web/src/components/errors/error-signal-row.tsx
+++ b/apps/web/src/components/errors/error-signal-row.tsx
@@ -180,7 +180,7 @@ export function ErrorSignalHeader({
 				) : null}
 			</span>
 			<span className={LANE.severity} />
-			<span className={LANE.identity}>Error</span>
+			<span className={LANE.identity}>Issue</span>
 			<span className={LANE.volume}>
 				<span className={LANE.spark}>Trend · 24h</span>
 				<span className={LANE.count}>Events</span>
diff --git a/apps/web/src/components/errors/errors-hub-view.tsx b/apps/web/src/components/errors/errors-hub-view.tsx
index 7bdad7569b..fa5e8ffcb3 100644
--- a/apps/web/src/components/errors/errors-hub-view.tsx
+++ b/apps/web/src/components/errors/errors-hub-view.tsx
@@ -4,6 +4,7 @@ import { useNavigate } from "@tanstack/react-router"
 
 import type { ErrorIssueId, WorkflowState } from "@maple/domain/http"
 import { Button } from "@maple/ui/components/ui/button"
+import { ToolbarSearch } from "@maple/ui/components/toolbar"
 import { LoadMoreButton } from "@maple/ui/components/ui/list-footer"
 import { SkeletonList } from "@maple/ui/components/ui/skeleton"
 import { Empty, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from "@maple/ui/components/ui/empty"
@@ -63,37 +64,22 @@ const SKELETON_ROWS = 8
 
 const VIEW_LABEL: Record<HubView, string> = {
 	open: "Open",
-	triage: "Triage",
-	active: "Active",
-	resolved: "Resolved",
+	closed: "Closed",
 	all: "All",
 } satisfies Record<HubView, string>
 
 /**
- * Which workflow states each view covers. `triage` is the untouched queue,
- * `active` is everything someone has picked up, `resolved` is closed work.
- * `regressed` sits in triage because a fix that did not hold is untriaged
- * again, not in-progress.
- *
- * `open` is the union of triage and active, spelled out rather than left as
- * `"all"`. The SERVER already narrows it — `actionable=true` maps to exactly
- * these five states — so on the real page the client filter passes every row it
- * is given and discards nothing. Spelling it out is what lets the view be
- * rendered off a fixture (`/lab/errors`) and still show the set the server
- * would have returned.
+ * Which workflow states each view covers. The server applies the same sets
+ * (`state=open|closed`); spelling them out here lets `/lab/errors` render a
+ * view off a fixture, and drops a row the moment a triage action moves it out.
+ * `verifying` is Closed: the fix has merged and the tick, not a person, acts next.
  */
 const VIEW_STATES = {
 	open: ["triage", "regressed", "todo", "in_progress", "in_review"],
-	triage: ["triage", "regressed"],
-	active: ["todo", "in_progress", "in_review"],
-	resolved: ["done", "cancelled", "wontfix"],
+	closed: ["verifying", "done", "cancelled", "wontfix"],
 	all: "all",
 } satisfies Record<HubView, ReadonlyArray<WorkflowState> | "all">
 
-/** Views the server can narrow with `actionable=true`, so the page it returns
- *  is already the right one. */
-export const ACTIONABLE_VIEWS: ReadonlyArray<HubView> = ["open", "triage", "active"]
-
 /** Membership against the view's state set. The literal tuples above keep their
  *  inferred element types, which do not accept an arbitrary `WorkflowState` as
  *  an `includes` argument — widening happens here, once. */
@@ -200,27 +186,17 @@ const EMPTY_COPY = {
 	open: {
 		icon: CircleCheckIcon,
 		title: "Nothing open",
-		description: "Every error here is closed out. Check Resolved to see recent fixes.",
-	},
-	triage: {
-		icon: CircleCheckIcon,
-		title: "Nothing waiting on triage",
-		description: "Every error here has been picked up.",
-	},
-	active: {
-		icon: CircleCheckIcon,
-		title: "Nothing in progress",
-		description: "No one has claimed an error yet. Start from the triage queue.",
+		description: "Every issue here is closed out. Check Closed to see recent fixes.",
 	},
 	all: {
 		icon: CircleCheckIcon,
 		title: "No errors recorded",
 		description: "Your services are sending traces and none have failed.",
 	},
-	resolved: {
+	closed: {
 		icon: HistoryIcon,
-		title: "Nothing resolved yet",
-		description: "Errors you close land here, so you can check whether a fix held.",
+		title: "Nothing closed yet",
+		description: "Issues you close land here, so you can check whether a fix held.",
 	},
 } satisfies Record<HubView, { icon: typeof CircleCheckIcon; title: string; description: string }>
 
@@ -240,6 +216,9 @@ export interface ErrorsHubViewProps {
 	onViewChange: (view: HubView) => void
 	onSortChange: (sort: HubSort) => void
 	onSeverityChange: (severity: SeverityFilter) => void
+	/** The applied search term, matched server-side. */
+	search: string
+	onSearchChange: (search: string | undefined) => void
 	/** The window totals above the toolbar. A slot rather than a component
 	 *  because it is the one part of the list that fetches for itself. */
 	stats?: React.ReactNode
@@ -260,6 +239,8 @@ export function ErrorsHubView({
 	onViewChange,
 	onSortChange,
 	onSeverityChange,
+	search,
+	onSearchChange,
 	stats,
 	paging,
 	onClearFilters,
@@ -278,14 +259,21 @@ export function ErrorsHubView({
 				tabs={HUB_VIEWS.map((value) => ({ value, label: VIEW_LABEL[value] }))}
 				active={view}
 				label="Filter errors"
-				countNoun={["error", "errors"]}
+				countNoun={["issue", "issues"]}
 				/* No count until there is one to state. "0 errors" under a spinner is
 				   a claim about the data, and it is wrong every time. */
 				totalCount={status === "ready" ? sorted.length : undefined}
-				countLabel={status === "ready" && hasUnshownPages ? `${sorted.length}+ errors` : undefined}
+				countLabel={status === "ready" && hasUnshownPages ? `${sorted.length}+ issues` : undefined}
 				onChange={onViewChange}
 				trailing={
 					<>
+						<ToolbarSearch
+							query={search}
+							onSearch={onSearchChange}
+							placeholder="Search issues..."
+							size="sm"
+							className="w-52"
+						/>
 						<Select
 							value={sort}
 							onValueChange={(value) => {
@@ -383,8 +371,10 @@ export function ErrorsHubView({
 			toolbar={toolbar}
 			view={view}
 			severity={severity}
+			search={search}
 			onViewChange={onViewChange}
 			onSeverityChange={onSeverityChange}
+			onSearchChange={onSearchChange}
 			paging={paging}
 			onClearFilters={onClearFilters}
 		/>
@@ -400,8 +390,10 @@ function HubList({
 	toolbar,
 	view,
 	severity,
+	search,
 	onViewChange,
 	onSeverityChange,
+	onSearchChange,
 	paging,
 	onClearFilters,
 }: {
@@ -410,8 +402,10 @@ function HubList({
 	toolbar: React.ReactNode
 	view: HubView
 	severity: SeverityFilter
+	search: string
 	onViewChange: (view: HubView) => void
 	onSeverityChange: (severity: SeverityFilter) => void
+	onSearchChange: (search: string | undefined) => void
 	paging: HubPaging | undefined
 	onClearFilters: (() => void) | undefined
 }) {
@@ -476,8 +470,10 @@ function HubList({
 				<HubEmpty
 					view={view}
 					severity={severity}
+					search={search}
 					onViewChange={onViewChange}
 					onSeverityChange={onSeverityChange}
+					onSearchChange={onSearchChange}
 					onClearFilters={onClearFilters}
 				/>
 			) : (
@@ -516,14 +512,18 @@ function HubList({
 function HubEmpty({
 	view,
 	severity,
+	search,
 	onViewChange,
 	onSeverityChange,
+	onSearchChange,
 	onClearFilters,
 }: {
 	view: HubView
 	severity: SeverityFilter
+	search: string
 	onViewChange: (view: HubView) => void
 	onSeverityChange: (severity: SeverityFilter) => void
+	onSearchChange: (search: string | undefined) => void
 	onClearFilters: (() => void) | undefined
 }) {
 	const empty = EMPTY_COPY[view]
@@ -536,6 +536,34 @@ function HubEmpty({
 	const narrowed = filtered || onClearFilters !== undefined
 	const presence = useSignalPresence("traces")
 
+	if (search !== "") {
+		return (
+			<Empty className="py-12">
+				<EmptyHeader>
+					<EmptyMedia variant="icon">
+						<MagnifierIcon size={18} />
+					</EmptyMedia>
+					<EmptyTitle>No issues match “{search}”</EmptyTitle>
+					<EmptyDescription>
+						{view === "all"
+							? "Search covers the type, message and service of every issue."
+							: `Nothing in ${VIEW_LABEL[view]} matches. It may be in another tab.`}
+					</EmptyDescription>
+				</EmptyHeader>
+				<div className="flex flex-wrap items-center justify-center gap-2">
+					{view !== "all" ? (
+						<Button size="sm" variant="outline" onClick={() => onViewChange("all")}>
+							Search all issues
+						</Button>
+					) : null}
+					<Button size="sm" variant="ghost" onClick={() => onSearchChange(undefined)}>
+						Clear search
+					</Button>
+				</div>
+			</Empty>
+		)
+	}
+
 	// An all-clear is only true once traces arrive. Before that, the empty list means setup.
 	if (!narrowed && presence.status === "absent") {
 		return (
diff --git a/apps/web/src/components/errors/errors-hub.tsx b/apps/web/src/components/errors/errors-hub.tsx
index 60495f4f1f..37a122325a 100644
--- a/apps/web/src/components/errors/errors-hub.tsx
+++ b/apps/web/src/components/errors/errors-hub.tsx
@@ -18,7 +18,7 @@ import {
 	sparkFingerprintHashes,
 } from "@/lib/models/error-signal"
 
-import { ACTIONABLE_VIEWS, ErrorsHubView, type HubPaging, viewCovers } from "./errors-hub-view"
+import { ErrorsHubView, type HubPaging, viewCovers } from "./errors-hub-view"
 import { ErrorsStatStrip } from "./errors-stat-strip"
 
 /**
@@ -65,6 +65,8 @@ export interface ErrorsHubProps {
 	env?: string
 	kind?: IssueKind
 	regressed?: boolean
+	/** Free-text search, matched server-side on type, message, label and service. */
+	search?: string
 	/** Present while a sidebar filter is on, for the empty state's way out.
 	 *  Owned by the route, which is where navigation lives. */
 	onClearFilters?: () => void
@@ -130,15 +132,17 @@ export function ErrorsHub(props: ErrorsHubProps) {
 			...(props.service ? { service_name: props.service } : undefined),
 			...(props.env ? { deployment_environment: props.env } : undefined),
 			...(props.kind ? { kind: props.kind } : undefined),
-			// One state per request is all the API takes, so multi-state views are
-			// filtered client-side from the page. `actionable` covers the common
-			// triage+active case server-side so that page is the right one; the
-			// regression toggle is a single state and replaces it outright.
+			// The server narrows every view, so paging reaches every match. Filtering
+			// a mixed page client-side left Closed empty whenever the newest page was
+			// all open issues.
 			...(props.regressed
 				? { workflow_state: "regressed" as const }
-				: ACTIONABLE_VIEWS.includes(props.view)
-					? { actionable: "true" as const }
-					: undefined),
+				: props.view === "all"
+					? undefined
+					: { state: props.view }),
+			// Done issues are archived two weeks after closing; they still belong in Closed.
+			...(props.view === "open" ? undefined : { include_archived: "true" as const }),
+			...(props.search ? { search: props.search } : undefined),
 			...(warehouseFirst ? { fingerprint_hash: rankedHashes.join(",") } : undefined),
 		}
 	}, [
@@ -149,6 +153,7 @@ export function ErrorsHub(props: ErrorsHubProps) {
 		props.env,
 		props.kind,
 		props.regressed,
+		props.search,
 		warehouseFirst,
 		rankedHashes,
 	])
@@ -312,6 +317,8 @@ export function ErrorsHub(props: ErrorsHubProps) {
 			onViewChange={(value) => setSearch({ view: value === "open" ? undefined : value })}
 			onSortChange={(value) => setSearch({ sort: value === "last_seen" ? undefined : value })}
 			onSeverityChange={(value) => setSearch({ severity: value === "all" ? undefined : value })}
+			search={props.search ?? ""}
+			onSearchChange={(value) => setSearch({ q: value })}
 			stats={<ErrorsStatStrip filters={warehouseFilters} />}
 			paging={paging}
 			onClearFilters={props.onClearFilters}
diff --git a/apps/web/src/components/errors/errors-stat-strip.tsx b/apps/web/src/components/errors/errors-stat-strip.tsx
index e15a867453..e75b241a57 100644
--- a/apps/web/src/components/errors/errors-stat-strip.tsx
+++ b/apps/web/src/components/errors/errors-stat-strip.tsx
@@ -27,9 +27,8 @@ export function ErrorsStatStrip({ filters }: { filters: GetErrorsSummaryInput })
 		Result.builder(summaryResult)
 			.onInitial(() => (
 				<div className="flex items-center gap-4 px-3 py-2">
-					<Skeleton className="h-4 w-24" />
 					<Skeleton className="h-4 w-28" />
-					<Skeleton className="h-4 w-24" />
+					<Skeleton className="h-4 w-28" />
 				</div>
 			))
 			// A failed summary must not take the list down with it — the rows carry
@@ -48,10 +47,10 @@ export function ErrorsStatStrip({ filters }: { filters: GetErrorsSummaryInput })
 						aria-busy={result.waiting || undefined}
 					>
 						<ToolbarStats className="flex-wrap gap-y-1">
-							<ToolbarStat value={summary.totalErrors} label="errors" />
+							{/* Events, not issues: the toolbar right below counts issues. Services
+							    are counted in the sidebar already. */}
+							<ToolbarStat value={summary.totalErrors} label="error events" />
 							<ToolbarStat value={formatErrorRate(summary.errorRate)} label="of all spans" />
-							<ToolbarStat value={summary.affectedServicesCount} label="services" />
-							<ToolbarStat value={summary.affectedTracesCount} label="traces" />
 						</ToolbarStats>
 						<span className="text-xs text-muted-foreground/60">in the last 24 hours</span>
 					</div>
diff --git a/apps/web/src/lab/errors-lab.tsx b/apps/web/src/lab/errors-lab.tsx
index b410d3941f..6498f84f14 100644
--- a/apps/web/src/lab/errors-lab.tsx
+++ b/apps/web/src/lab/errors-lab.tsx
@@ -48,6 +48,7 @@ export function ErrorsLab() {
 	const [view, setView] = useState<HubView>("open")
 	const [sort, setSort] = useState<HubSort>("last_seen")
 	const [severity, setSeverity] = useState<SeverityFilter>("all")
+	const [search, setSearch] = useState("")
 	const [state, setState] = useState<LabState>("ready")
 	const [width, setWidth] = useState<number | null>(null)
 
@@ -60,7 +61,16 @@ export function ErrorsLab() {
 				if (severity === "unset") return signal.severity === null
 				return signal.severity === severity
 			})
-	}, [fixture.signals, state, view, severity])
+			.filter((signal) => {
+				// Mirrors the server's ILIKE over type, message, label and service.
+				const term = search.toLowerCase()
+				if (term === "") return true
+				const { issue } = signal
+				return [issue.exceptionType, issue.exceptionMessage, issue.errorLabel, issue.serviceName].some(
+					(field) => field.toLowerCase().includes(term),
+				)
+			})
+	}, [fixture.signals, state, view, severity, search])
 
 	return (
 		<DashboardLayout.Root>
@@ -92,6 +102,8 @@ export function ErrorsLab() {
 								onViewChange={setView}
 								onSortChange={setSort}
 								onSeverityChange={setSeverity}
+								search={search}
+								onSearchChange={(value) => setSearch(value ?? "")}
 								stats={<LabStatStrip summary={fixture.summary} />}
 								onRetry={() => setState("ready")}
 							/>
@@ -181,10 +193,8 @@ function LabStatStrip({
 	}
 }) {
 	const stats = [
-		{ value: formatNumber(summary.totalErrors), label: "errors" },
+		{ value: formatNumber(summary.totalErrors), label: "error events" },
 		{ value: formatErrorRate(summary.errorRate), label: "of all spans" },
-		{ value: formatNumber(summary.affectedServicesCount), label: "services" },
-		{ value: formatNumber(summary.affectedTracesCount), label: "traces" },
 	]
 	return (
 		<div className="flex flex-wrap items-center gap-x-4 gap-y-1 px-3 py-2 text-xs">
@@ -194,7 +204,7 @@ function LabStatStrip({
 					<span className="text-muted-foreground">{stat.label}</span>
 				</span>
 			))}
-			<span className="text-muted-foreground/60">in the selected window</span>
+			<span className="text-muted-foreground/60">in the last 24 hours</span>
 		</div>
 	)
 }
diff --git a/apps/web/src/lib/errors/hub-params.ts b/apps/web/src/lib/errors/hub-params.ts
index edb7bb87eb..47f142425d 100644
--- a/apps/web/src/lib/errors/hub-params.ts
+++ b/apps/web/src/lib/errors/hub-params.ts
@@ -5,9 +5,21 @@
  * whole list there with them.
  */
 
-export const HUB_VIEWS = ["open", "triage", "active", "resolved", "all"] as const
+export const HUB_VIEWS = ["open", "closed", "all"] as const
 export type HubView = (typeof HUB_VIEWS)[number]
 
+/** Tabs the list used to have. Old links still decode and land on the tab that
+ *  now holds the same issues. */
+export const LEGACY_HUB_VIEWS = ["triage", "active", "resolved"] as const
+export type LegacyHubView = (typeof LEGACY_HUB_VIEWS)[number]
+
+export const hubViewOf = (view: HubView | LegacyHubView | undefined): HubView =>
+	view === undefined || view === "triage" || view === "active"
+		? "open"
+		: view === "resolved"
+			? "closed"
+			: view
+
 /** `last_seen` leads because it is the default: newest activity first, paged
  *  back through older issues. `volume` is the one sort only the warehouse can
  *  answer, so it is the one scoped to the time range. */
diff --git a/apps/web/src/routes/errors/index.tsx b/apps/web/src/routes/errors/index.tsx
index 116cd66020..5e82cbe8fe 100644
--- a/apps/web/src/routes/errors/index.tsx
+++ b/apps/web/src/routes/errors/index.tsx
@@ -14,9 +14,10 @@ import {
 	ERRORS_WINDOW,
 	HUB_SORTS,
 	HUB_VIEWS,
+	LEGACY_HUB_VIEWS,
 	SEVERITY_FILTERS,
+	hubViewOf,
 	type HubSort,
-	type HubView,
 	type SeverityFilter,
 } from "@/lib/errors/hub-params"
 import { CLEARED_ERROR_FILTERS, errorFilterChips, hasErrorFilters } from "@/lib/errors/error-filter-chips"
@@ -34,7 +35,9 @@ const errorsSearchSchema = Schema.Struct({
 	env: Schema.optional(Schema.String),
 	kind: Schema.optional(IssueKind),
 	regressed: Schema.optional(Schema.Union([Schema.Boolean, BooleanFromStringParam])),
-	view: Schema.optional(Schema.Literals(HUB_VIEWS)),
+	view: Schema.optional(Schema.Literals([...HUB_VIEWS, ...LEGACY_HUB_VIEWS])),
+	// Free-text search over type, message, label and service, applied server-side.
+	q: Schema.optional(Schema.String),
 	sort: Schema.optional(Schema.Literals(HUB_SORTS)),
 	severity: Schema.optional(Schema.Literals(SEVERITY_FILTERS)),
 })
@@ -73,7 +76,7 @@ function ErrorsContent() {
 		navigate({ search: (prev) => ({ ...prev, ...CLEARED_ERROR_FILTERS }) })
 	}
 
-	const view: HubView = search.view ?? "open"
+	const view = hubViewOf(search.view)
 	const sort: HubSort = search.sort ?? "last_seen"
 	const severity: SeverityFilter = search.severity ?? "all"
 
@@ -93,6 +96,7 @@ function ErrorsContent() {
 				env={search.env}
 				kind={search.kind}
 				regressed={search.regressed}
+				search={search.q}
 				onClearFilters={hasErrorFilters(search) ? clearFilters : undefined}
 			/>
 		</DashboardPage>
diff --git a/apps/web/src/routes/errors/issues/index.tsx b/apps/web/src/routes/errors/issues/index.tsx
index 60731e85b7..657da7976c 100644
--- a/apps/web/src/routes/errors/issues/index.tsx
+++ b/apps/web/src/routes/errors/issues/index.tsx
@@ -17,19 +17,20 @@ export const Route = createFileRoute("/errors/issues/")({
 	},
 })
 
-type HubView = "open" | "triage" | "active" | "resolved" | "all"
+type HubView = "open" | "closed" | "all"
 
 /** The old list's `workflowState` tabs map onto the hub's views. A Map rather
  *  than an object because the incoming value is unvalidated search-param text. */
 const VIEW_FOR_STATE = new Map<string, HubView>([
-	["triage", "triage"],
-	["regressed", "triage"],
-	["todo", "active"],
-	["in_progress", "active"],
-	["in_review", "active"],
-	["done", "resolved"],
-	["cancelled", "resolved"],
-	["wontfix", "resolved"],
+	["triage", "open"],
+	["regressed", "open"],
+	["todo", "open"],
+	["in_progress", "open"],
+	["in_review", "open"],
+	["verifying", "closed"],
+	["done", "closed"],
+	["cancelled", "closed"],
+	["wontfix", "closed"],
 	["all", "all"],
 ])
 
diff --git a/docs/error-issue-lifecycle.md b/docs/error-issue-lifecycle.md
index 8e4bf6a880..5292ec4bf4 100644
--- a/docs/error-issue-lifecycle.md
+++ b/docs/error-issue-lifecycle.md
@@ -215,3 +215,17 @@ loop in verification without a human ever seeing it.
 | PR links and verification windows       | `packages/backend/src/services/errors/IssueFixVerificationService.ts`                                        |
 | The verification tick                   | `packages/backend/src/services/errors/FixVerificationTickService.ts`                                         |
 | What agents are told                    | `apps/ai/src/mcp/resources/instructions.ts`                                                                  |
+
+## Testing it locally
+
+- **Seed exceptions:** `bun run seed:demo:env`, then `MAPLE_DEV_ENV_FILE=.env.screenshots bun dev api web ingest alerting`
+  and `bun run seed:demo -- --reset --follow`. The alerting Worker skips its crons off production unless
+  `MAPLE_ALERTING_ALLOW_NONPROD=1` is set (the screenshot env sets it).
+- **Run the tick now:** `bun run errors:tick` fires the alerting minute cron once (errors tick plus fix
+  verification) instead of waiting for it. `--url` targets a branch stack's `<branch>.alerting.localhost`.
+- **Measure a fingerprint change before shipping it:** `bun run errors:replay -- --file <sample>` groups
+  a sample of real error events with today's fingerprint and with the proposal in
+  `scripts/errors-replay/candidate.ts`, checks the TS mirror is in parity with production's hashes, and
+  lists the largest merges to read for false positives. The script header has the export query; samples
+  hold customer data and stay out of the repo.
+- **The list without a backend:** `/lab/errors` renders the real list view over fixtures.
diff --git a/package.json b/package.json
index 1b59452bec..d1c33c2371 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,8 @@
 		"build": "turbo build",
 		"dev": "bun run ./scripts/dev.ts",
 		"dev:signin": "bun run ./scripts/dev-signin.ts",
+		"errors:tick": "bun run ./scripts/errors-tick.ts",
+		"errors:replay": "bun run ./scripts/errors-replay.ts",
 		"seed:demo": "bun run ./scripts/seed-demo.ts",
 		"seed:demo:env": "bun run ./scripts/seed-demo/make-env.ts",
 		"prepare": "effect-tsgo unpatch --no-typescript --oxlint && effect-tsgo patch --no-typescript --oxlint",
diff --git a/packages/backend/src/services/errors/ErrorIssueReadModelsService.test.ts b/packages/backend/src/services/errors/ErrorIssueReadModelsService.test.ts
index e3b6228460..cef81cfb48 100644
--- a/packages/backend/src/services/errors/ErrorIssueReadModelsService.test.ts
+++ b/packages/backend/src/services/errors/ErrorIssueReadModelsService.test.ts
@@ -225,6 +225,58 @@ describe("ErrorIssueReadModelsService", () => {
 		}).pipe(Effect.provide(makeLayer(contexts)))
 	})
 
+	it.effect("pages closed issues server-side, past newer open ones and into the archive", () => {
+		const contexts: Array<string> = []
+		return Effect.gen(function* () {
+			const readModels = yield* ErrorIssueReadModelsService
+			const now = yield* Clock.currentTimeMillis
+			const open = asIssueId(randomUUID())
+			const verifying = asIssueId(randomUUID())
+			const wontfix = asIssueId(randomUUID())
+			const archivedDone = asIssueId(randomUUID())
+
+			// The open issue is the newest, so a recency page of one would hold only it.
+			yield* seedIssue(ORG, open, now + 5_000, { workflowState: "triage" })
+			yield* seedIssue(ORG, verifying, now, { workflowState: "verifying" })
+			yield* seedIssue(ORG, wontfix, now - 1_000, { workflowState: "wontfix" })
+			yield* seedIssue(ORG, archivedDone, now - 2_000, {
+				workflowState: "done",
+				archivedAt: now - 1_000,
+			})
+
+			const firstClosed = yield* readModels.listIssues(ORG, { stateGroup: "closed", limit: 1 })
+			expect(firstClosed.issues.map((issue) => issue.id)).toEqual([verifying])
+
+			const closed = yield* readModels.listIssues(ORG, { stateGroup: "closed", includeArchived: true })
+			expect(closed.issues.map((issue) => issue.id)).toEqual([verifying, wontfix, archivedDone])
+
+			const opened = yield* readModels.listIssues(ORG, { stateGroup: "open", includeArchived: true })
+			expect(opened.issues.map((issue) => issue.id)).toEqual([open])
+		}).pipe(Effect.provide(makeLayer(contexts)))
+	})
+
+	it.effect("searches type, message and service case-insensitively", () => {
+		const contexts: Array<string> = []
+		return Effect.gen(function* () {
+			const readModels = yield* ErrorIssueReadModelsService
+			const now = yield* Clock.currentTimeMillis
+			const byMessage = asIssueId(randomUUID())
+			const byService = asIssueId(randomUUID())
+			const unrelated = asIssueId(randomUUID())
+
+			yield* seedIssue(ORG, byMessage, now, { exceptionMessage: "Stripe webhook signature mismatch" })
+			yield* seedIssue(ORG, byService, now - 1_000, { serviceName: "stripe-sync" })
+			yield* seedIssue(ORG, unrelated, now - 2_000)
+
+			const found = yield* readModels.listIssues(ORG, { search: "STRIPE" })
+			expect(found.issues.map((issue) => issue.id)).toEqual([byMessage, byService])
+
+			// LIKE wildcards in the term are literal, not "match everything".
+			const literal = yield* readModels.listIssues(ORG, { search: "%" })
+			assert.lengthOf(literal.issues, 0)
+		}).pipe(Effect.provide(makeLayer(contexts)))
+	})
+
 	it.effect("preserves issue ownership and not-found semantics", () => {
 		const contexts: Array<string> = []
 		return Effect.gen(function* () {
diff --git a/packages/backend/src/services/errors/ErrorIssueReadModelsService.ts b/packages/backend/src/services/errors/ErrorIssueReadModelsService.ts
index eb6b62808c..fe9d651bef 100644
--- a/packages/backend/src/services/errors/ErrorIssueReadModelsService.ts
+++ b/packages/backend/src/services/errors/ErrorIssueReadModelsService.ts
@@ -56,6 +56,9 @@ const ACTIONABLE_WORKFLOW_STATES: ReadonlyArray<WorkflowState> = [
 	"in_progress",
 	"in_review",
 ]
+/** The list's "Closed" set: nobody has to act. `verifying` is here because the
+ *  fix has merged and the verification tick, not a person, owns what happens next. */
+const CLOSED_LIST_WORKFLOW_STATES: ReadonlyArray<WorkflowState> = ["verifying", "done", "cancelled", "wontfix"]
 
 type IssueColumns = PG.ColumnAccessor<typeof ErrorIssues.columns>
 type IssueConditions = ($: IssueColumns) => Array<PG.Condition | undefined>
@@ -106,6 +109,8 @@ export interface IssueListFilters {
 	/** First seen or last regressed at or after this instant. */
 	readonly introducedAfter?: string
 	readonly actionable?: boolean
+	/** `open` = the actionable states; `closed` = verifying and the closed exits. */
+	readonly stateGroup?: "open" | "closed"
 }
 
 export interface ErrorIssueReadModelsPublicApi {
@@ -237,7 +242,10 @@ const make: Effect.Effect<
 		const conditions: IssueConditions = ($) => [
 			$.orgId.eq(orgId),
 			opts.workflowState ? $.workflowState.eq(opts.workflowState) : undefined,
-			opts.actionable ? $.workflowState.in_(...ACTIONABLE_WORKFLOW_STATES) : undefined,
+			opts.actionable || opts.stateGroup === "open"
+				? $.workflowState.in_(...ACTIONABLE_WORKFLOW_STATES)
+				: undefined,
+			opts.stateGroup === "closed" ? $.workflowState.in_(...CLOSED_LIST_WORKFLOW_STATES) : undefined,
 			opts.severity === "unset"
 				? $.severity.isNull()
 				: opts.severity
diff --git a/packages/domain/src/http/v2/error-issues.ts b/packages/domain/src/http/v2/error-issues.ts
index c74050646a..810a9a74fd 100644
--- a/packages/domain/src/http/v2/error-issues.ts
+++ b/packages/domain/src/http/v2/error-issues.ts
@@ -156,6 +156,13 @@ export const V2ErrorIssueListQuery = Schema.Struct({
 	// deploy introduced, rather than everything still occurring.
 	introduced_after: Schema.optional(Timestamp),
 	actionable: Schema.optional(Schema.Literal("true")),
+	// `open`: someone still has to act (same set as `actionable`). `closed`: the
+	// work is over or handed to verification (verifying, done, cancelled, wontfix).
+	state: Schema.optional(Schema.Literals(["open", "closed"])),
+	// Case-insensitive substring of the exception type, message, label or service.
+	search: Schema.optional(Schema.String.check(Schema.isMaxLength(200))),
+	// Done issues are archived 14 days after they close; include them.
+	include_archived: Schema.optional(Schema.Literal("true")),
 	sort: Schema.optional(Schema.Literals(["last_seen", "severity"])),
 }).annotate({
 	identifier: "ErrorIssueListQuery",
diff --git a/scripts/errors-replay.ts b/scripts/errors-replay.ts
new file mode 100644
index 0000000000..34f762a58d
--- /dev/null
+++ b/scripts/errors-replay.ts
@@ -0,0 +1,136 @@
+/**
+ * Replay error events through today's fingerprint and a proposed one, and show
+ * how the issue count and grouping would change. Measure a fingerprint change
+ * here before it rotates every issue in production.
+ *
+ *   bun run errors:replay                          # the synthetic corpus
+ *   bun run errors:replay -- --file sample.json    # a real sample
+ *
+ * A sample is JSONL, or the `{ "rows": [...] }` object the `run_sql` MCP tool
+ * returns. Each row: serviceName, exceptionType, statusMessage,
+ * exceptionStacktrace, and optionally count (events the row stands for) and
+ * fingerprintHash (production's hash, which turns on the parity check).
+ * One way to pull a week of variants from an org:
+ *
+ *   SELECT ServiceName AS serviceName, ExceptionType AS exceptionType,
+ *          StatusMessage AS statusMessage, ExceptionStacktrace AS exceptionStacktrace,
+ *          toString(FingerprintHash) AS fingerprintHash, count() AS count
+ *   FROM error_events WHERE $__orgFilter AND $__timeFilter(Timestamp)
+ *   GROUP BY serviceName, exceptionType, statusMessage, exceptionStacktrace, fingerprintHash
+ *   ORDER BY count DESC LIMIT 3 BY fingerprintHash
+ *
+ * The proposal lives in `./errors-replay/candidate.ts`. Samples hold customer
+ * data: keep them out of the repo.
+ */
+import { readFileSync } from "node:fs"
+import { parseArgs } from "node:util"
+import { Schema } from "effect"
+
+import { candidateKey, currentKey, type ReplayEvent } from "./errors-replay/candidate"
+
+const { values } = parseArgs({
+	options: {
+		file: { type: "string", default: new URL("./errors-replay/corpus.jsonl", import.meta.url).pathname },
+		top: { type: "string", default: "12" },
+	},
+})
+const top = Number(values.top)
+
+const Row = Schema.Struct({
+	serviceName: Schema.String,
+	exceptionType: Schema.String,
+	statusMessage: Schema.String,
+	exceptionStacktrace: Schema.String,
+	count: Schema.optional(Schema.Union([Schema.Number, Schema.NumberFromString])),
+	fingerprintHash: Schema.optional(Schema.String),
+})
+type Row = Schema.Schema.Type<typeof Row>
+const decodeRows = Schema.decodeUnknownSync(Schema.Array(Row))
+const decodeEnvelope = Schema.decodeUnknownSync(Schema.Struct({ rows: Schema.Array(Schema.Unknown) }))
+const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown))
+
+const text = readFileSync(values.file ?? "", "utf8").trim()
+const raw = text.startsWith("{") && text.includes('"rows"')
+	? decodeEnvelope(decodeJson(text)).rows
+	: text.split("\n").filter((line) => line.trim() !== "").map((line) => decodeJson(line))
+const rows = decodeRows(raw)
+
+const weight = (row: Row) => row.count ?? 1
+const events = rows.reduce((sum, row) => sum + weight(row), 0)
+
+interface Keyed {
+	readonly row: Row
+	readonly current: string
+	readonly candidate: string
+}
+const keyed: ReadonlyArray<Keyed> = rows.map((row) => {
+	const event: ReplayEvent = row
+	return { row, current: currentKey(event), candidate: candidateKey(event) }
+})
+
+const distinct = (keys: Iterable<string>) => new Set(keys).size
+const currentGroups = distinct(keyed.map((k) => k.current))
+const candidateGroups = distinct(keyed.map((k) => k.candidate))
+const pct = (from: number, to: number) => (from === 0 ? "0%" : `${Math.round(((from - to) / from) * 100)}%`)
+
+console.log(`\n${rows.length} sampled variants, ${events.toLocaleString()} events (${values.file})\n`)
+console.log(`  issues today      ${currentGroups}`)
+console.log(`  issues proposed   ${candidateGroups}   (${pct(currentGroups, candidateGroups)} fewer)`)
+
+// Parity: the TS mirror should group exactly as the MV hashed. A mismatch means
+// the replay is not measuring production, and its numbers are not to be trusted.
+const hashed = keyed.filter((k) => k.row.fingerprintHash !== undefined)
+if (hashed.length > 0) {
+	const hashes = distinct(hashed.map((k) => k.row.fingerprintHash ?? ""))
+	const mirrored = distinct(hashed.map((k) => k.current))
+	console.log(`  production hashes ${hashes}   (TS mirror: ${mirrored}${hashes === mirrored ? ", in parity" : ", NOT in parity"})`)
+}
+
+const groupBy = <K>(items: ReadonlyArray<Keyed>, key: (k: Keyed) => K) => {
+	const map = new Map<K, Array<Keyed>>()
+	for (const item of items) map.set(key(item), [...(map.get(key(item)) ?? []), item])
+	return map
+}
+
+const clip = (s: string, n: number) => (s.length > n ? `${s.slice(0, n - 1)}…` : s)
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim()
+
+console.log(`\nWhere the change lands (service · type: issues today -> proposed)\n`)
+const byType = [...groupBy(keyed, (k) => `${k.row.serviceName} · ${k.row.exceptionType || "(no type)"}`)]
+	.map(([label, items]) => ({
+		label,
+		before: distinct(items.map((k) => k.current)),
+		after: distinct(items.map((k) => k.candidate)),
+	}))
+	.filter((entry) => entry.before !== entry.after)
+	.sort((a, b) => b.before - b.after - (a.before - a.after))
+for (const entry of byType.slice(0, top)) {
+	console.log(`  ${String(entry.before).padStart(4)} -> ${String(entry.after).padEnd(4)} ${clip(entry.label, 90)}`)
+}
+if (byType.length === 0) console.log("  (no change)")
+
+// The merges are where a proposal goes wrong: read the messages and ask whether
+// they are really one bug.
+console.log(`\nLargest merges (check these are one bug)\n`)
+const merges = [...groupBy(keyed, (k) => k.candidate).values()]
+	.map((items) => ({ items, merged: distinct(items.map((k) => k.current)) }))
+	.filter((entry) => entry.merged > 1)
+	.sort((a, b) => b.merged - a.merged)
+for (const { items, merged } of merges.slice(0, top)) {
+	const head = items[0].row
+	console.log(`  ${merged} issues -> 1   ${head.serviceName} · ${head.exceptionType || "(no type)"}`)
+	for (const message of [...new Set(items.map((k) => oneLine(k.row.statusMessage)))].slice(0, 3)) {
+		console.log(`      ${clip(message || "(empty message)", 110)}`)
+	}
+}
+if (merges.length === 0) console.log("  (none)")
+
+const splits = [...groupBy(keyed, (k) => k.current).values()].filter(
+	(items) => distinct(items.map((k) => k.candidate)) > 1,
+)
+console.log(`\nIssues the proposal would split: ${splits.length}`)
+for (const items of splits.slice(0, top)) {
+	const head = items[0].row
+	console.log(`  ${head.serviceName} · ${head.exceptionType} -> ${distinct(items.map((k) => k.candidate))}`)
+}
+console.log("")
diff --git a/scripts/errors-replay/candidate.ts b/scripts/errors-replay/candidate.ts
new file mode 100644
index 0000000000..e13cf2177e
--- /dev/null
+++ b/scripts/errors-replay/candidate.ts
@@ -0,0 +1,115 @@
+/**
+ * A PROPOSED fingerprint (v3), replayed against real samples before it ships.
+ *
+ * Nothing in production reads this. It exists so a grouping change can be
+ * measured (`bun run errors:replay`) instead of argued. When a proposal wins,
+ * port it to `packages/domain/src/tinybird/fingerprint.ts` and the MV SQL, and
+ * bump FINGERPRINT_VERSION.
+ *
+ * Each rule below targets a split seen in prod (2026-10-13 sample):
+ *  1. Caller frames: one upstream 503 became one issue per query that hit it,
+ *     because frames 2-3 are the callers. A namespaced error type already names
+ *     the failure, so only the throw site is kept for those.
+ *  2. Effect span frames (`(definition)`) vary the stack depth for one call path.
+ *  3. Filesystem paths outside the home dir (`/tmp/...`, `/srv/...`) and the
+ *     random suffixes inside them. Route paths (`/api/...`) are still kept.
+ *  4. Prefixed and non-hex ids (`org_2Nn...`, `cus_...`, ULIDs) and UUIDs inside JSON.
+ */
+import { Option, Schema } from "effect"
+import {
+	applyRedactions,
+	computeFingerprintInputs,
+	FRAME_LINE_PATTERN,
+	FRAME_REDACTIONS,
+	MAX_FINGERPRINT_FRAMES,
+	MSG_SCAN_CHARS,
+	MSG_SIGNATURE_CHARS,
+	MSG_TEXT_REDACTIONS,
+	type Redactions,
+} from "../../packages/domain/src/tinybird/fingerprint"
+
+export interface ReplayEvent {
+	readonly serviceName: string
+	readonly exceptionType: string
+	readonly statusMessage: string
+	readonly exceptionStacktrace: string
+}
+
+const FRAME_LINE_RE = new RegExp(FRAME_LINE_PATTERN)
+
+/** `@maple/http/errors/Foo`, `effect/ai/AiError`: a type that names one failure. */
+const isNamespacedType = (type: string) => type.includes("/")
+
+const isEffectSpanFrame = (line: string) => line.includes("(definition)")
+
+const CANDIDATE_FRAME_REDACTIONS: Redactions = [
+	// pnpm/bun store paths carry the package version; a dependency bump is not a new bug.
+	["@[0-9]+\\.[0-9]+\\.[0-9]+[^/ )]*", "@#"],
+	["\\(index [0-9]+\\)", "(index #)"],
+	...FRAME_REDACTIONS,
+]
+
+const FS_ROOTS = "tmp|var|srv|private|opt|mnt|data|Volumes|System|app|work|run"
+
+// Replacements may use `$1`; ClickHouse's replaceRegexpAll spells it `\1`. No
+// lookbehind: these must port to RE2 for the MV.
+const CANDIDATE_MSG_REDACTIONS: Redactions = [
+	// ClickHouse errors echo the failing query; the error class is the bug, the
+	// query text (an agent's own SQL, mostly) is a value.
+	["(DB::Exception: [A-Za-z ]+?)[:.(][\\s\\S]*", "$1"],
+	["^(\\[Error\\] [A-Za-z ]+?)[`'\"#:.(][\\s\\S]*", "$1"],
+	// Filesystem paths, rooted where a route never is, and only at the start of a
+	// token so `/api/data/x` is not read as `/data`. Runs before the home-dir pass.
+	[`(^|[\\s'"(\`=])(~|/(${FS_ROOTS}|Users/[^/ ]+|home/[^/ ]+))(/[^ '"\`:,)]*)?`, "$1PATH"],
+	// Prefixed ids: Clerk `org_`/`user_`, Stripe `cus_`/`sub_`, and their like.
+	["\\b[a-z]{2,8}_[A-Za-z0-9]{10,}\\b", "ID"],
+	// ULIDs: 26 Crockford base32 characters.
+	["\\b[0-9A-HJKMNP-TV-Z]{26}\\b", "ID"],
+	...MSG_TEXT_REDACTIONS,
+]
+
+const CANDIDATE_JSON_VALUE_REDACTIONS: Redactions = [["[0-9a-fA-F-]{6,}|[0-9]+", "#"]]
+
+function candidateFrames(event: ReplayEvent): string {
+	const keep = isNamespacedType(event.exceptionType) ? 1 : MAX_FINGERPRINT_FRAMES
+	return event.exceptionStacktrace
+		.split("\n")
+		.filter((line) => FRAME_LINE_RE.test(line) && !isEffectSpanFrame(line))
+		.slice(0, keep)
+		.map((line) => applyRedactions(line, CANDIDATE_FRAME_REDACTIONS))
+		.join("\n")
+}
+
+function candidateMessage(message: string): string {
+	const json = parseJsonObject(message)
+	if (json !== undefined) {
+		return Object.keys(json)
+			.map((key) => `${key}=${applyRedactions(JSON.stringify(json[key]), CANDIDATE_JSON_VALUE_REDACTIONS)}`)
+			.sort()
+			.join("|")
+	}
+	return applyWithGroups(message.slice(0, MSG_SCAN_CHARS), CANDIDATE_MSG_REDACTIONS).slice(0, MSG_SIGNATURE_CHARS)
+}
+
+const applyWithGroups = (value: string, redactions: Redactions): string =>
+	redactions.reduce((acc, [pattern, replacement]) => acc.replace(new RegExp(pattern, "g"), replacement), value)
+
+const decodeJsonObject = Schema.decodeUnknownOption(
+	Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)),
+)
+
+const parseJsonObject = (text: string): Record<string, unknown> | undefined =>
+	Option.getOrUndefined(decodeJsonObject(text))
+
+/** The grouping key production computes today (the TS mirror of the MV). */
+export function currentKey(event: ReplayEvent): string {
+	const inputs = computeFingerprintInputs(event)
+	return [event.serviceName, event.exceptionType, inputs.fpFrames, inputs.msgSignature].join("\u0000")
+}
+
+/** The proposed grouping key. */
+export function candidateKey(event: ReplayEvent): string {
+	return [event.serviceName, event.exceptionType, candidateFrames(event), candidateMessage(event.statusMessage)].join(
+		"\u0000",
+	)
+}
diff --git a/scripts/errors-replay/corpus.jsonl b/scripts/errors-replay/corpus.jsonl
new file mode 100644
index 0000000000..d541e6c844
--- /dev/null
+++ b/scripts/errors-replay/corpus.jsonl
@@ -0,0 +1,18 @@
+{"serviceName":"web","exceptionType":"@acme/http/errors/WarehouseUpstreamError","statusMessage":"HTTP 503","exceptionStacktrace":"@acme/http/errors/WarehouseUpstreamError: HTTP 503\n    at Object.transform (https://app.example.com/assets/Schema-va6l_Bfn.js:2:58950)\n    at e (https://app.example.com/assets/Schema-va6l_Bfn.js:2:32917)\n    at serviceUsage (https://app.example.com/assets/query-atoms-l4GZq8Vn.js:1:6826)\n    at QueryEngine.getServiceUsage (https://app.example.com/assets/query-atoms-l4GZq8Vn.js:1:151730)","count":5}
+{"serviceName":"web","exceptionType":"@acme/http/errors/WarehouseUpstreamError","statusMessage":"HTTP 503","exceptionStacktrace":"@acme/http/errors/WarehouseUpstreamError: HTTP 503\n    at Object.transform (https://app.example.com/assets/Schema-va6l_Bfn.js:2:58950)\n    at e (https://app.example.com/assets/Schema-va6l_Bfn.js:2:32917)\n    at QueryEngine.getServiceUsage (https://app.example.com/assets/query-atoms-l4GZq8Vn.js:1:151730)\n    at QueryEngine.getServiceUsage (definition) (https://app.example.com/assets/query-atoms-l4GZq8Vn.js:1:47457)","count":5}
+{"serviceName":"web","exceptionType":"@acme/http/errors/WarehouseUpstreamError","statusMessage":"HTTP 503","exceptionStacktrace":"@acme/http/errors/WarehouseUpstreamError: HTTP 503\n    at Object.transform (https://app.example.com/assets/Schema-va6l_Bfn.js:2:58950)\n    at e (https://app.example.com/assets/Schema-va6l_Bfn.js:2:32917)\n    at QueryEngine.scopeServicesToNamespaces (https://app.example.com/assets/query-atoms-l4GZq8Vn.js:1:51345)","count":4}
+{"serviceName":"web","exceptionType":"@acme/http/errors/WarehouseUpstreamError","statusMessage":"HTTP 503","exceptionStacktrace":"@acme/http/errors/WarehouseUpstreamError: HTTP 503\n    at Object.transform (https://app.example.com/assets/Schema-va6l_Bfn.js:2:58950)\n    at e (https://app.example.com/assets/Schema-va6l_Bfn.js:2:32917)\n    at serviceDetailOverview (https://app.example.com/assets/query-atoms-l4GZq8Vn.js:1:6826)","count":4}
+{"serviceName":"cli","exceptionType":"@acme/cli/LocalStoreDirtyError","statusMessage":"the local store at /tmp/acme-checkpoint.OXto4w/data was not cleanly closed. Run `acme restore --yes` to restore.","exceptionStacktrace":"","count":1}
+{"serviceName":"cli","exceptionType":"@acme/cli/LocalStoreDirtyError","statusMessage":"the local store at /srv/proxy/data/acme was not cleanly closed. Run `acme restore --yes` to restore.","exceptionStacktrace":"","count":1}
+{"serviceName":"cli","exceptionType":"@acme/cli/LocalStoreDirtyError","statusMessage":"the local store at ~/.acme/data was not cleanly closed. Run `acme restore --yes` to restore.","exceptionStacktrace":"","count":40}
+{"serviceName":"api","exceptionType":"@acme/backend/billing/CustomerNotFound","statusMessage":"No customer for org org_2NnXk9QbVt7Lm3Pq","exceptionStacktrace":"","count":3}
+{"serviceName":"api","exceptionType":"@acme/backend/billing/CustomerNotFound","statusMessage":"No customer for org org_2RbTy8WcZe1Hj6Ks","exceptionStacktrace":"","count":2}
+{"serviceName":"api","exceptionType":"@acme/backend/billing/CustomerNotFound","statusMessage":"No customer for org org_2KdPw4MnAs9Fg2Lr","exceptionStacktrace":"","count":1}
+{"serviceName":"api","exceptionType":"ProblemError","statusMessage":"{\"title\":\"Not found\",\"instance\":\"e29b41d4-a716-4466-5544-0000a3f19c2e\"}","exceptionStacktrace":"","count":2}
+{"serviceName":"api","exceptionType":"ProblemError","statusMessage":"{\"title\":\"Not found\",\"instance\":\"a3f1c2e4-b716-4466-9544-00007e2a1b0d\"}","exceptionStacktrace":"","count":2}
+{"serviceName":"api","exceptionType":"HttpClientError","statusMessage":"Transport error (POST /api/query-engine/service-overview)","exceptionStacktrace":"","count":9}
+{"serviceName":"api","exceptionType":"HttpClientError","statusMessage":"Transport error (POST /api/data/export)","exceptionStacktrace":"","count":4}
+{"serviceName":"api","exceptionType":"DatabaseError","statusMessage":"relation \"planetscale_events\" does not exist","exceptionStacktrace":"","count":6}
+{"serviceName":"api","exceptionType":"DatabaseError","statusMessage":"relation \"anomaly_detector_states\" does not exist","exceptionStacktrace":"","count":6}
+{"serviceName":"web","exceptionType":"TypeError","statusMessage":"Cannot read properties of undefined (reading 'id')","exceptionStacktrace":"TypeError: Cannot read properties of undefined (reading 'id')\n    at renderRow (https://app.example.com/assets/list-a1b2c3d4.js:1:200)\n    at map (https://app.example.com/assets/list-a1b2c3d4.js:1:900)\n    at List (https://app.example.com/assets/list-a1b2c3d4.js:1:1200)","count":12}
+{"serviceName":"web","exceptionType":"TypeError","statusMessage":"Cannot read properties of undefined (reading 'id')","exceptionStacktrace":"TypeError: Cannot read properties of undefined (reading 'id')\n    at renderRow (https://app.example.com/assets/list-a1b2c3d4.js:1:200)\n    at map (https://app.example.com/assets/list-a1b2c3d4.js:1:900)\n    at Sidebar (https://app.example.com/assets/sidebar-e5f6a7b8.js:1:330)","count":3}
diff --git a/scripts/errors-tick.ts b/scripts/errors-tick.ts
new file mode 100644
index 0000000000..e29595bac4
--- /dev/null
+++ b/scripts/errors-tick.ts
@@ -0,0 +1,44 @@
+/**
+ * Fire the alerting Worker's minute cron once, on a local `bun dev` stack.
+ *
+ * That cron runs the errors tick (candidates -> issues, incidents, regressions)
+ * and the fix-verification tick, so this is the way to see newly ingested
+ * exceptions become issues without waiting for the next minute.
+ *
+ *   bun run errors:tick
+ *   bun run errors:tick -- --url https://my-branch.alerting.localhost
+ *
+ * The Worker skips every cron off production unless MAPLE_ALERTING_ALLOW_NONPROD=1
+ * is in the env `bun dev` was started with; the alerting log says so once.
+ */
+import { parseArgs } from "node:util"
+
+const MINUTE_CRON = "* * * * *"
+
+const { values } = parseArgs({
+	options: {
+		url: { type: "string" },
+		cron: { type: "string", default: MINUTE_CRON },
+	},
+})
+
+const base = (values.url ?? process.env.MAPLE_DEV_ALERTING_URL ?? "https://alerting.localhost").replace(/\/$/, "")
+const cron = values.cron ?? MINUTE_CRON
+const target = `${base}/cdn-cgi/handler/scheduled?cron=${encodeURIComponent(cron)}`
+
+const started = Date.now()
+const response = await fetch(target).catch((cause: unknown) => {
+	console.error(`Could not reach ${base}: ${String(cause)}`)
+	console.error("Is the stack up with alerting in it? `bun dev api web ingest alerting`")
+	process.exit(1)
+})
+const body = (await response.text()).trim()
+
+if (!response.ok) {
+	console.error(`${response.status} from ${target}${body ? `\n${body}` : ""}`)
+	process.exit(1)
+}
+
+console.log(`Fired "${cron}" on ${base} in ${Date.now() - started}ms${body ? ` (${body})` : ""}.`)
+console.log("Issues appear once the tick finishes; the alerting log shows the run.")
+console.log("Nothing happened? Start `bun dev` with MAPLE_ALERTING_ALLOW_NONPROD=1.")

From 32a37bb5008636d459bc286e6a27a5a2aba1c768 Mon Sep 17 00:00:00 2001
From: Makisuo <minetoaster12@gmail.com>
Date: Wed, 14 Oct 2026 20:48:08 +0200
Subject: [PATCH 2/2] fix(errors): regenerate iOS spec, clamp issue search,
 name every lane errors:tick runs

The iOS OpenAPI check failed on the new list params. A pasted log line longer
than the API's 200-char search cap now clamps instead of failing the page. The
minute cron also runs the alert and escalation lanes; the script and doc say so.
---
 .../MapleAPI/Sources/MapleAPI/openapi.json    | 32 +++++++++++++++++++
 apps/web/src/components/errors/errors-hub.tsx |  4 ++-
 docs/error-issue-lifecycle.md                 |  5 +--
 packages/domain/src/http/v2/error-issues.ts   |  5 ++-
 scripts/errors-tick.ts                        |  5 +--
 5 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/apps/ios/Packages/MapleAPI/Sources/MapleAPI/openapi.json b/apps/ios/Packages/MapleAPI/Sources/MapleAPI/openapi.json
index 153e120a84..b24ee4676a 100644
--- a/apps/ios/Packages/MapleAPI/Sources/MapleAPI/openapi.json
+++ b/apps/ios/Packages/MapleAPI/Sources/MapleAPI/openapi.json
@@ -5393,6 +5393,38 @@
               "type": "string"
             }
           },
+          {
+            "in": "query",
+            "name": "state",
+            "required": false,
+            "schema": {
+              "enum": [
+                "open",
+                "closed"
+              ],
+              "type": "string"
+            }
+          },
+          {
+            "in": "query",
+            "name": "search",
+            "required": false,
+            "schema": {
+              "maxLength": 200,
+              "type": "string"
+            }
+          },
+          {
+            "in": "query",
+            "name": "include_archived",
+            "required": false,
+            "schema": {
+              "enum": [
+                "true"
+              ],
+              "type": "string"
+            }
+          },
           {
             "in": "query",
             "name": "sort",
diff --git a/apps/web/src/components/errors/errors-hub.tsx b/apps/web/src/components/errors/errors-hub.tsx
index 37a122325a..a673c0cd09 100644
--- a/apps/web/src/components/errors/errors-hub.tsx
+++ b/apps/web/src/components/errors/errors-hub.tsx
@@ -2,6 +2,7 @@ import { useMemo, useState } from "react"
 import { useNavigate } from "@tanstack/react-router"
 
 import type { ErrorIssueDocument, IssueKind } from "@maple/domain/http"
+import { ERROR_ISSUE_SEARCH_MAX_LENGTH } from "@maple/domain/http/v2"
 
 import { useRefreshableAtomValue } from "@/hooks/use-refreshable-atom-value"
 import { Atom, Result, useAtomRefresh, useAtomValue } from "@/lib/effect-atom"
@@ -142,7 +143,8 @@ export function ErrorsHub(props: ErrorsHubProps) {
 					: { state: props.view }),
 			// Done issues are archived two weeks after closing; they still belong in Closed.
 			...(props.view === "open" ? undefined : { include_archived: "true" as const }),
-			...(props.search ? { search: props.search } : undefined),
+			// A pasted log line can outrun the API's cap; clamp rather than fail the page.
+			...(props.search ? { search: props.search.slice(0, ERROR_ISSUE_SEARCH_MAX_LENGTH) } : undefined),
 			...(warehouseFirst ? { fingerprint_hash: rankedHashes.join(",") } : undefined),
 		}
 	}, [
diff --git a/docs/error-issue-lifecycle.md b/docs/error-issue-lifecycle.md
index 5292ec4bf4..45e393eb9c 100644
--- a/docs/error-issue-lifecycle.md
+++ b/docs/error-issue-lifecycle.md
@@ -221,8 +221,9 @@ loop in verification without a human ever seeing it.
 - **Seed exceptions:** `bun run seed:demo:env`, then `MAPLE_DEV_ENV_FILE=.env.screenshots bun dev api web ingest alerting`
   and `bun run seed:demo -- --reset --follow`. The alerting Worker skips its crons off production unless
   `MAPLE_ALERTING_ALLOW_NONPROD=1` is set (the screenshot env sets it).
-- **Run the tick now:** `bun run errors:tick` fires the alerting minute cron once (errors tick plus fix
-  verification) instead of waiting for it. `--url` targets a branch stack's `<branch>.alerting.localhost`.
+- **Run the tick now:** `bun run errors:tick` fires the alerting minute cron once instead of waiting
+  for it. That cron runs the alert and escalation lanes too, not only the errors tick and fix
+  verification, so alert rules evaluate (and may notify) on the same fire. `--url` targets a branch stack's `<branch>.alerting.localhost`.
 - **Measure a fingerprint change before shipping it:** `bun run errors:replay -- --file <sample>` groups
   a sample of real error events with today's fingerprint and with the proposal in
   `scripts/errors-replay/candidate.ts`, checks the TS mirror is in parity with production's hashes, and
diff --git a/packages/domain/src/http/v2/error-issues.ts b/packages/domain/src/http/v2/error-issues.ts
index 810a9a74fd..927adb239e 100644
--- a/packages/domain/src/http/v2/error-issues.ts
+++ b/packages/domain/src/http/v2/error-issues.ts
@@ -131,6 +131,9 @@ export const V2ErrorIssueDetail = Schema.Struct({
 })
 export type V2ErrorIssueDetail = Schema.Schema.Type<typeof V2ErrorIssueDetail>
 
+/** Longest `search` term the list accepts; clients clamp to it rather than fail. */
+export const ERROR_ISSUE_SEARCH_MAX_LENGTH = 200
+
 export const V2ErrorIssueListQuery = Schema.Struct({
 	...ListQuery.fields,
 	workflow_state: Schema.optional(WorkflowState),
@@ -160,7 +163,7 @@ export const V2ErrorIssueListQuery = Schema.Struct({
 	// work is over or handed to verification (verifying, done, cancelled, wontfix).
 	state: Schema.optional(Schema.Literals(["open", "closed"])),
 	// Case-insensitive substring of the exception type, message, label or service.
-	search: Schema.optional(Schema.String.check(Schema.isMaxLength(200))),
+	search: Schema.optional(Schema.String.check(Schema.isMaxLength(ERROR_ISSUE_SEARCH_MAX_LENGTH))),
 	// Done issues are archived 14 days after they close; include them.
 	include_archived: Schema.optional(Schema.Literal("true")),
 	sort: Schema.optional(Schema.Literals(["last_seen", "severity"])),
diff --git a/scripts/errors-tick.ts b/scripts/errors-tick.ts
index e29595bac4..4ab639ca58 100644
--- a/scripts/errors-tick.ts
+++ b/scripts/errors-tick.ts
@@ -2,8 +2,9 @@
  * Fire the alerting Worker's minute cron once, on a local `bun dev` stack.
  *
  * That cron runs the errors tick (candidates -> issues, incidents, regressions)
- * and the fix-verification tick, so this is the way to see newly ingested
- * exceptions become issues without waiting for the next minute.
+ * with fix verification, and also the alert and escalation lanes
+ * (`apps/alerting/src/schedule.ts`): alert rules evaluate and may notify too.
+ * It is the way to see newly ingested exceptions become issues without waiting.
  *
  *   bun run errors:tick
  *   bun run errors:tick -- --url https://my-branch.alerting.localhost