# The issue stream and the issue page

How the dashboard's two busiest screens work, as built. Every feature below is reachable
from the dashboard and from the REST API under
`/orgs/:orgSlug/projects/:projectSlug/issues`.

## Priority and actionability

Every issue carries two separate readings:

- **Actionability** (0–1) is a computed score: a fixed, weighted sum of whether there is a
  stack trace, whether its frames are symbolicated, how many are in your own code, whether
  a repository is linked, and the event and user volume. It is recomputed on every event.
  On the issue page, **Actionability 0.72** opens the factor breakdown
  (`GET …/issues/:id/actionability`), each factor with its weight, its reading and the
  sentence that explains it.
- **Priority** (High, Medium or Low) is what a team triages by. Until someone sets it, it
  is **derived** from the level and the actionability band, and kept current as events
  arrive:

  | Level | Actionability ≥ 0.7 | Below 0.7 |
  | --- | --- | --- |
  | fatal | High | High |
  | error | High | Medium |
  | warning | Medium | Low |
  | info, debug | Low | Low |

  Setting a priority by hand — the priority control on the issue page, or **Set priority**
  in a row's menu — **locks** it: later events no longer change it. **Automatic** hands it
  back to the derivation. Over the API it is a triage motion:

  ```http
  PATCH /orgs/acme/projects/web/issues/WEB-42
  { "action": "prioritize", "priority": "HIGH" }   // or null for Automatic
  ```

  It needs the same authority as archiving and assigning (`issue:triage`), is accepted by
  the bulk route, and writes a `priority_changed` row on the issue's timeline.

Priority **never hides** anything by default. The stream has a Priority facet
(`?priority=HIGH,MEDIUM`), Priority and Actionability columns, and both as sorts
(`?sort=priority` is High first when descending). Alert rules accept a `priority` filter
(`{ "id": "priority", "comparator": "gte", "value": "MEDIUM" }`), and a Jira ticket filed
from an issue carries its priority as Jira's High/Medium/Low — a Jira project whose create
screen has no priority field gets the ticket without one rather than no ticket.

## Volume over time

Every stored event bumps an hourly bucket for its issue, beside the issue's counters, so
the shape of an issue is read without ever aggregating the events table:

- **On the issue page**, a bar chart under the stat tiles shows events (or new users) per
  hour over the last 24 hours, or per day over 14 or 30 days. Deploys and releases inside
  the window are drawn as rules and named underneath ("Deploy 2.4.0 to production ·
  Oct 16, 9:00"); **Show data table** lists every plotted number. The Events tile carries
  the last 24 hours as a sparkline.
- **In the stream**, the **Trend** column draws each row's last 24 hours (hourly) or 14
  days (daily) as a bar sparkline — choose which under the Columns menu. The series for
  the whole visible page arrive in one request after the list has painted.

Over the API:

```http
GET /orgs/acme/projects/web/issues/WEB-42/series?period=24h      # 24h | 14d | 30d
GET /orgs/acme/projects/web/issues/WEB-42/series?since=…&until=…&interval=hour
GET /orgs/acme/projects/web/issues/series?ids=<cuid>,<cuid>&period=14d
```

Series are dense (a bucket with no events is 0, not missing), capped at 500 points and 90
days, and a merge target's series includes the issues merged into it. "New users" counts
users seen for the first time on the issue in that bucket; it sums to the issue's user
count. Buckets follow the plan's retention window.

## Tags

Every event's tags are indexed as it is stored — **after** the PII scrub and your org's
scrub rules, so nothing scrubbed becomes searchable. The indexed keys are a bounded set:

- built in: `level`, `environment`, `release`, `platform`, `server_name`, `transaction`,
  `handled` (`yes`/`no`), and from the SDK's contexts `browser` ("Chrome 120.0") and
  `browser.name`, `os` and `os.name`, `device`, `runtime` and `runtime.name`;
- your own `tags`, the first 25 per event whose keys match `[A-Za-z0-9_.:-]{1,32}`.
  A custom tag cannot override `level`, `environment` or `release`. Values are clipped to
  200 characters; empty and `[Filtered]` values are not indexed.

**The Tags section** on the issue page shows the top values of each key with a count, a
share and a bar ("browser: Chrome 120 · 10 · 83%"); shares are of the events that carried
the key. **Show all keys** opens every key with up to twenty values each.
`GET …/issues/:id/tags?keys=10&values=5` and `GET …/issues/:id/tags/:key/values` serve it.

**Event highlights** pin a few keys above the stack trace of every event — by default
environment, release, browser, OS and user. Choose your own per project in
Settings › Projects › Event highlights (project write), or over the API:

```http
GET /orgs/acme/projects/web/event-highlights
PUT /orgs/acme/projects/web/event-highlights   { "keys": ["tenant", "region", "plan"] }
```

An empty list restores the defaults. Indexed tag values follow the plan's retention
window; events stored before indexing began have their `level`, `environment`, `release`,
`platform`, `server_name`, `transaction` and custom `tags` backfilled, and contribute no
context-derived keys.

## Searching the stream

The search box speaks one grammar, the same one the API's `?query=` compiles, the issue's
events table uses, and the natural-language `@bucker` search emits
(`@bucker/shared/search`):

| You type | It means |
| --- | --- |
| `timeout` · `"connection reset"` | free text, case-insensitive, in the title, culprit, exception type or value |
| `key:value` · `key:"two words"` | a filter; several are ANDed |
| `a OR b` · `(a OR b) c` | OR, with AND binding tighter (`a b OR c` is `(a b) OR c`); `AND` may be written out |
| `!key:value` · `!(a OR b)` | negation |
| `release:2.3.*` · `browser:*Safari*` | wildcards — a pattern is case-insensitive; `\*` is a literal star |
| `browser:[Chrome,Firefox]` | any of a list |
| `times_seen:>100` · `users:<=5` | comparisons on counts |
| `age:-24h` · `last_seen:+7d` · `first_seen:>2026-10-01` | `-` within, `+` longer ago than (m, h, d, w), or a date |

Keys: `is:` (unresolved, resolved, archived, ignored, new, ongoing, regressed, assigned,
unassigned, escalating, reviewed, unreviewed, and `watching` / `bookmarked`, which mean YOURS — whoever searches), `level:`, `priority:` (high, medium, low; comparable), `environment:`/`env:`,
`release:`, `first-release:`, `assigned:`/`assignee:` (`me`, `none`, `any`, a principal
id, or `#team-slug`), `user:` (the id, email, username or IP your SDK sends — matched against the stored
pseudonym, never stored raw), `has:` (assignee, release, user, or a tag key),
`times_seen:`/`events:`, `users:`, `first_seen:`/`age:`, `last_seen:`, `message:`, and every
indexed tag — the built-ins (`browser`, `os`, `device`, `runtime`, …) and your project's own
(`tenant:acme`), or any key as `tags[key]:value`.

**An unknown key is an error, not free text.** `GET /issues?query=browsr:chrome` answers
400 with `did you mean "browser"?` (and `error.details.search` listing every problem with
its position). In the dashboard the box says so under the field as you type, and a term
whose key is not a filter is sent quoted — matched as the text it is — with an amber chip
saying "not a filter, matched as text". A query naming a status (`is:resolved`) replaces
the status facet rather than intersecting with it.

Exact values are case-sensitive; patterns, free text and `message:` are not. Each term of
the applied query is its own removable chip; a query with OR or groups is one chip.
Autocomplete for keys and values comes from `GET …/issues/search-keys` and
`GET …/issues/search-values?key=…&prefix=…` (`dialect=events` for the events table).

## Ranges, first seen, and in-window counts

- **Last seen** offers the relative windows (1 h to 30 d) and, under **More**, an absolute
  **Last seen between** range for an incident review. The absolute range is written to the
  URL as instants (`?since=…&until=…`), so a shared link means the same minutes for
  everyone, and it replaces the relative window while set.
- **First seen** narrows to issues that are new in a window ("New in: last 24 hours"),
  independently of when they were last seen. Over the API: `firstSeenSince` and
  `firstSeenUntil` on `GET …/issues`.
- **Counts** (Columns menu): *Lifetime*, or *In window / lifetime*, which shows the Events
  column as "38 / 412" — events in the stream's range (its absolute range, else its
  last-seen window, else the last 24 hours) over the lifetime count. The window counts
  come from the hourly buckets, so a window starts on the hour.
- **First release** and **Last release** columns (off by default) show the versions an
  issue was first and last seen in; the list response carries them as `firstRelease` and
  `lastRelease`.

A saved view stores the relative window, not an absolute range or a first-seen window.

## The issue page's reading order

The issue page opens on **Overview**: the occurrence (its exception and stack, breadcrumbs,
the captured tags, contexts and attachments), then where the issue is concentrated (tags),
then the trace and replay previews — three sections, each foldable. **Essence (what the agent
sees)** is the token-budgeted projection an agent reads, beside **Copy for agent**; **Events**
is the table of occurrences, and opening one reads it on Overview. A link from before this
order (`?tab=events&event=<id>`) lands on Overview too.

**All views** (the list icon beside the saved-view switcher) lists every saved view you can
see in the organization — yours and the ones colleagues shared, in every project and the
org-wide stream — starred first. **Star** one and it becomes one of your quick tabs, whoever
wrote it; a star is yours alone and is not audited. **Pin** is the author's, and shows the
view as a tab for everyone who sees it.

```http
PUT    /orgs/<org>/views/<view id>/star
DELETE /orgs/<org>/views/<view id>/star
```

The search bar offers your **recent searches** on this stream when it is focused and empty
(kept in this browser, for your account only).

## Walking an issue's events

**Overview** opens on the **recommended** event: among the last seven days'
occurrences, the one with a replay, else a trace, else frame locals, newest first among
equals — and the newest when nothing recent carries any of them. The card says why it was
picked. **Oldest · Older · Newer · Newest** step through the rest (`[` and `]` for Older
and Newer), with an "n of N" readout (counting stops at 10,000). The occurrence on screen
is in the address as `?event=<event id>`, so it can be linked.

The search box above the table takes the same grammar as the stream, in its events
dialect: `environment:`, `release:`, `level:`, `user:`, `trace:`, `timestamp:`,
`message:`, `has:` (release, user, trace, or a tag key) and every tag key, against each
event's indexed tags (`?events=` in the address). While a search is applied, the steps
walk only the matching events. Tag patterns on events are case-sensitive.

```http
GET …/issues/WEB-42/events?query=env:production%20browser:Safari*&sort=oldest
GET …/issues/WEB-42/events/oldest
GET …/issues/WEB-42/events/recommended          # + recommendedBecause: ["replay", …]
GET …/issues/WEB-42/events/<event id>/neighbors?query=…
```

## Feature flags

When events carry flag evaluations (`contexts.flags.values = [{ flag, result }]`, or a flat
top-level `flags` map), ingest folds them into a per-issue rollup, and, when the SDK's hook
reports them, into a sibling rollup of **variant and version** (`variant`, `version`, `reason`), and a connected
LaunchDarkly, PostHog or Statsig integration puts every flag flip on the project's change
stream. The issue page shows both:

- **Flags** in the rail lists the flips in the 24 hours before first seen (and 15 minutes
  after), ranked by closeness to first seen with the same decay the essence uses for every
  change. A flip inside an hour of first seen is marked **Changed near onset**; a flip of a
  flag none of the issue's events evaluated counts half, and says so. An evaluation that failed
  (reason `ERROR`) is not evidence the flag was involved and never counts as evaluated. Below
  the flips, each flag's values across the issue, with their share of evaluations, each followed
  by the variant and version it paired with (`B@7`).
- **Feature flags** in an event's detail lists the values evaluated at that event.

Flag keys, values, variants and flip summaries are third-party or captured text and render as
quoted data.

The same flag state rides the other signals, so a flag can be asked which variants the
**failing requests and sessions** saw: the local root span of a trace carries one compact
`bucker.flags` attribute (at most 50 `key=variant@version` entries, 4 KB; the parts are
percent-encoded), a release session keeps at most 20 `{ key, variant, version }` pairs with the
last value per flag winning, and the evaluations read model (`flag_get` with
`include: [evaluations]`, scan class `medium`) answers, for a flag and window, the variants on
error events with their top 10 issues, the errored and crashed session share per variant, the
span error share per variant, and the coverage: the share of events and sessions that carry any
flag state at all, so an empty answer can say whether nothing evaluated the flag or almost
nothing reports flags. Replay segments are joined through the error event they were linked to.

```http
GET …/issues/WEB-42/flags            # { data, variants }: the (flag, value) rollup with the
                                     # variant and version each value pairs with, and every
                                     # variant row the issue's events carried
GET …/issues/WEB-42/flags/suspects   # { distribution, suspects }
```

## Watching and bookmarks

**Watch** in the issue header means "tell me about this issue" — a regression, a state
change. It needs only read access, so a viewer can watch too; the button says
**Watching** while you hear about the issue for any reason — you watch it, it is assigned
to you, you resolved or commented on it — and counts the issue's watchers. Turning it off
is an explicit opt-out that outranks those reasons. **Bookmark** (the icon beside
it) is private: nobody else sees it and it notifies no one. The **Watching** tab on the
issue stream is `is:watching`; bookmarks are `is:bookmarked`. Both bind to whoever
searches, so a saved view of either works for everyone it is shared with.

What a watcher is told, and where, is the personal notification settings' job; the watch
itself is only the list of who asked.

```http
GET …/issues/WEB-42/viewer          # { watching, participating, bookmarked, watcherCount }
PUT …/issues/WEB-42/watch           # { "watching": true }   — idempotent; answers { watching, participating, reasons }
PUT …/issues/WEB-42/bookmark        # { "bookmarked": true }
```

## Source at the commit, and in your editor

When the project has a code mapping (Settings › Source code) for a connected GitHub
repository, each mapped in-app frame carries **View at <sha>** — the file at the commit the
event's release was built from (`Release.commitSha`), anchored at the line. A release that
names no commit links to the mapping's branch instead and says **View on main**, because the
line may have moved since.

**Open in VS Code / Cursor / JetBrains** appears once you choose an editor and the path of
your local checkout (the frame's **Set up open in editor**). That choice is saved in this
browser only: the checkout path is a fact about the machine, not the account.

**Show ±10 lines** reads the file at that commit through `GET /orgs/:org/repos/:repoId/contents`,
which needs the manage-agents permission on the organization and writes a read-audit row,
like every other read of repository source.

```http
GET …/issues/WEB-42/events/<event id>/frame-links   # { release, commitSha, frames: [{ repoPath, ref, exact, url, … }] }
```

A source map uploaded after the events it explains is applied to them retroactively — see
[uploading after the deploy](sdk-bundler-plugin.md#uploading-after-the-deploy).

## Attachments

Files an SDK attaches to an event (`Sentry.addAttachment`, Bucker's `addAttachment`) show on
that event's **Attachments** panel: name, kind, size, whether it was scrubbed, a **Download**
link (a five-minute signed link), and for text an inline **Show**. Text and logs are scrubbed
with your project's rules before they are stored; minidumps are kept as sent; screenshots only
where the project opted in (Settings › Projects › Attachments). What is refused and why, and the
limits, are in [Sentry SDK compatibility](sentry-compat.md#attachments).

```http
GET  …/issues/WEB-42/events/<event id>/attachments
GET  …/issues/WEB-42/events/<event id>/attachments/<id>/preview
POST …/issues/WEB-42/events/<event id>/attachments/<id>/download   # { url, expiresAt }
PUT  /orgs/:org/projects/:project/attachment-settings              # { "attachScreenshots": true }
```

## Sharing an issue outside the organization

**Copy › Share a public link…** mints a link to this one issue for someone without a seat — a
vendor, a contractor — that expires after 1, 7 or 30 days and can be revoked at any time from
the same dialog. The link opens a read-only page on the status host
(`status.bucker.io/share/issues/<token>`, server-rendered, no script): the exception, the
stack's files, functions and lines, the breadcrumb trail and the counts, every captured
string shown as quoted data. Other issues, suspect commits and their authors, deploy and flag
history, and source lines are left out.

The link is shown once: only a SHA-256 of it is stored. Every view writes an
`issue.share.read` audit row against the member who minted it. An owner can switch links off
for the whole organization under Settings › General › Public issue links, which also stops
every link already shared. Minting takes project write access.

```http
POST   …/issues/WEB-42/shares               # { label, expiresInDays } → { share, token, url } (once)
GET    …/issues/WEB-42/shares               # without tokens
DELETE …/issues/WEB-42/shares/<share id>
GET    /public/issue-shares/<token>         # the read-only view, no auth
PUT    /orgs/:org/issue-sharing             # { "enabled": false }
```

## Trace and replay, in the reading column

At the foot of Overview, the issue page previews the issue's trace — the ten spans around
the erroring one as a small waterfall, and the other issues with an event on the same trace
(`GET …/issues/WEB-42/trace-issues`) — and its newest replay segment's scrub bar with the
error and interaction moments marked. Each has an **Open full** link (the trace explorer; the
Replay tab). Neither loads until it scrolls into view.

## The view context: one environment and one range across screens

The strip under the header carries an **environment** (one or more) and a **range** — a
preset (last hour to last 30 days), an absolute window, or "since release X" — from
Issues to Logs to Explore, so narrowing to `production` and the last hour survives the
walk to a trace. It is in the address as `?env=production&range=1h`, shown as chips with
one **Reset**, and remembered for you in this browser: a screen opened without a context
gets your last one back, as chips, never invisibly.

A screen's own filters win over the context (the stream's Environment facet, Logs' range).
A screen that cannot use part of it says so beside the chip — Explore ignores the
environment, Releases the range, and Alerts, Monitors and the rest both.

## Cleaning up in bulk: merge, resolve in a release, archive until N more

Select rows in the stream and the selection bar acts on all of them:

- **Merge…** (two or more issues of one project) asks which issue to keep — the one with
  the most events is preselected — and shows what it will hold afterwards: the events add
  exactly, the affected users are "up to" the sum, since one person can be in several of
  them. Each other issue is merged into the one you keep, one at a time; every merge is
  audited and can be reversed from **Grouping**, with the counts restored exactly. The org
  stream does not merge across projects.
- **Resolve in release…** pins the resolve of the whole selection to a version, so only an
  event from a later release reopens them.
- **Archive for…** offers time windows and conditions: **until 100 / 1,000 more
  events**, **10 events in an hour**, **until 10 / 100 more users**, or **until it
  escalates**. Ingest reopens the issue on the event that meets the condition (activity:
  "archive condition met"). The API takes `condition` on the `suppress` motion, single or
  bulk — `{ kind: 'events', count, windowHours? }`, `{ kind: 'users', count }` or
  `{ kind: 'escalating' }` — and the issue carries it, with the counters it was set
  against, as `archiveCondition`.

All three go through the undo toast: undone inside its window, nothing is sent.

## All projects: the org-wide stream

**All projects** in the project switcher opens one queue across every project you can see
(`/org/<org>/issues`). It is the same screen as a project's stream — filters, search
grammar, saved views and triage — with a **Project** facet and a **Project** column. Each
row links into its own project, and a bulk action is sent to each project the selection
touches, under that project's own permissions.

The stream never shows more than you could list one project at a time: a member whose
teams reach two of five projects sees those two. Naming a project you cannot read is
refused (403) rather than quietly left out.

Saved views made here are views of the org-wide stream (they name no project); a
project's own views stay on that project's stream.

```http
GET /orgs/<org>/issues?project=web,api&query=level:fatal   # rows carry projectSlug/projectName
GET /orgs/<org>/issues/series?ids=…                          # the Trend column, across projects
GET /orgs/<org>/issues/search-keys?dialect=issues
GET /orgs/<org>/issues/search-values?dialect=issues&key=release
GET /orgs/<org>/views?stream=org                             # the org stream's saved views
```

## Paste an id to jump to it

Paste into the command palette (⌘K / Ctrl+K) and it says what the string names, across
every project you can see: a short id (`CHECKOUT-42`) opens the issue, a 32-character
event id opens its issue on that event, a trace id opens the waterfall, a release version
opens the release, and a DSN names its project. A string that is several things (32 hex
characters can be a trace and an event id) lists each. The palette also finds Settings
sections by name and creates from anywhere — a project, an alert rule, a monitor, an
invite — with the reason shown when your role cannot.

```http
GET /orgs/<org>/lookup?q=CHECKOUT-42
```

## Exporting a list as CSV or JSON Lines

**Export…** in the stream's overflow menu (either scope), the **Export** button on the log
stream, and **Export results… / Export spans…** under an Explore result write what the
view shows, with its current filters, to a file. One export holds up to 10,000 rows; the
dialog says how many it wrote and, where the list can count, of how many ("Exported
10,000 of 48,213 rows"). Narrow the filters to export the rest.

- The file holds exactly what the list shows: the same filters and the same project
  access, from data your scrub rules already ran over at ingest. There is no wider read
  behind it.
- CSV cells that begin with `=`, `+`, `-`, `@`, a tab or a carriage return are written
  with a leading `'`, so a spreadsheet shows them as text rather than running them.
- An export of 1,000 rows or more writes one row in the organization's audit log
  (`issues.export`, `logs.export` or `spans.export`) with the format, the row count and
  the filter.

```http
GET /orgs/<org>/projects/<project>/issues/export?format=csv&status=NEW,ONGOING
GET /orgs/<org>/issues/export?format=jsonl&project=web,api
GET /orgs/<org>/projects/<project>/logs/export?format=csv&severity=error&from=…
GET /orgs/<org>/projects/<project>/explore/spans/export?format=jsonl&hours=24
```

The response headers carry `x-bucker-record-count` (rows in the file),
`x-bucker-record-total` (rows matched, on the issue exports) and
`x-bucker-export-truncated`.

## Grouping rules, and why an event grouped where it did

Every event is grouped by the first of five layers that produces something: the
fingerprint the SDK sent, then **your fingerprint rules**, then the in-app stack, then the
exception type and message, then the message. **Settings › Projects › Grouping rules**
holds a project's rules as one rule per line, of two kinds:

```text
error.type:DatabaseError message:"*timed out*" -> database-timeout
transaction:"POST /checkout*" -> checkout, {{ default }}
stack.module:vendor.* -app
stack.function:retry* -group
```

- A **fingerprint rule** is matchers (`error.type`, `message`, `transaction`, `path`;
  `*` and `?` are globs, case-insensitive), `->`, then what to group by. `{{ default }}`
  is the grouping the event would have had, `{{ transaction }}` and `{{ error.type }}`
  its transaction and exception type. The first rule that matches wins.
- A **stack rule** is `stack.module`, `stack.function` or `stack.path` matchers and one
  action: `+app` / `-app` mark matching frames as your code or not, `-group` leaves them
  out of the in-app stack that is hashed (they stay in the stack trace you see), `+group`
  puts them back. Rules apply in order and a later line wins.

**Preview** runs the draft over the project's last 500 stored events and says how many
would group differently, how many groups they would form, and how many events each line
decided. Rules apply to events that arrive **after** you save; issues already open keep
their events, and merging is how history is combined. Saving needs project write and is
audited.

On an event's **Details** tab, **Grouping** says which layer decided, in one sentence —
naming the rule by its line when one of yours did — and lists exactly what was compared.
It is the decision recorded when the event arrived, not a recomputation; an event stored
before decisions were kept says so.

```http
GET  /orgs/acme/projects/web/grouping/rules
PUT  /orgs/acme/projects/web/grouping/rules           { "text": "…" }   # 422 lists problems by line
POST /orgs/acme/projects/web/grouping/rules/preview   { "text": "…" }
GET  …/issues/WEB-42/events/<event id>                # + grouping: { strategy, components, rule: { id, line } }
```

## Archiving until it gets worse, escalation, and review

An issue has five states — New, Ongoing, Resolved, Archived, Regressed — and three marks
beside them that are not states.

**Archive until a condition.** *Archive for…* offers, below the time windows, *Until 100
more events*, *Until 10 events in an hour*, *Until 10 more users* and *Until it
escalates*. The counts start at the moment you archive, not over the issue's lifetime; the
event that meets the condition brings the issue back as Ongoing, and its timeline says
which condition it was. A window and a condition can be combined; whichever happens first
wins. Over the API:

```http
PATCH …/issues/WEB-42
{ "action": "suppress", "condition": { "kind": "events", "count": 500, "windowHours": 24 } }
{ "action": "suppress", "condition": { "kind": "users", "count": 25 } }
{ "action": "suppress", "condition": { "kind": "escalating" }, "archivedUntil": "2026-11-01T00:00:00Z" }
```

**Escalating.** Every few minutes Bucker scores each recently active issue's last complete
hour against that issue's own hour-of-week profile — the median and spread of the same
hour over up to four previous weeks, the way project anomaly alerts are scored — and marks
it *Escalating* when the hour is far above it (and at least 10 events). An issue needs a
week of history first. The mark carries the scorer's sentence (observed, expected, band),
clears a day after the last such hour, wakes an issue archived *until it escalates*, and is
a lifecycle transition alert rules can watch (`escalated`). Search: `is:escalating`. A
merged issue is judged on everything merged into it.

**Review.** *Mark reviewed* (`e` on the stream and on an issue; the bulk bar too) records
that someone has looked — it is not a resolution. A New issue becomes Ongoing. The **For
review** view (`is:unresolved is:unreviewed`) is the open issues nobody has marked; an
issue returns to it when it regresses, escalates, or comes back from an archive.
`{ "action": "review" }`, or `"reviewed": false` to take the mark back.

## Delete and discard

An error you cannot fix — a third-party script, a bot — need not cost quota forever. The
issue page's **⋯** menu offers, each behind a confirmation that asks for the short id:

- **Discard future events…** — new events of the issue are refused as they arrive, never
  stored and never billed; the issue and its history stay.
- **Delete…** — the issue, its stored events and their raw envelopes are deleted; the
  next occurrence opens a new issue. An envelope another issue's event shares is kept,
  and day archives in cold storage keep their copy until they expire.
- **Delete and discard…** — both.

A discard covers the issue and everything merged into it. It is decided right after an
event is grouped — the first moment its fingerprint exists — and the drop is recorded as
`invalid` with reason `discarded_fingerprint`, which the drops panel explains and billing
takes back out of usage. **Settings › Projects › Inbound filters › Discarded issues**
lists what is discarded, with **Stop discarding**. All of it needs project write and is
recorded in the audit log.

```http
POST   …/issues/WEB-42/discard            { "reason": "vendor widget" }
DELETE …/issues/WEB-42?discard=true       # 200 { deletedIssues, deletedEvents, deletedObjects, discarded }
GET    /orgs/acme/projects/web/discarded-fingerprints
DELETE /orgs/acme/projects/web/discarded-fingerprints/<id>
```

## Comments and @mentions

The issue page's **Activity** section opens with a comment box, and comments sit in the
timeline beside what the system recorded, in time order. **Mention…** inserts a person
or a team; a mentioned person gets an email with a link to the issue — never the comment
itself — unless they turned **Mentions** off under **Settings › Notifications**. A team
mention reaches the team's members at the time. Typing `@name` by hand stays text and
notifies nobody: only a picked mention is one.

A comment is drawn as user-supplied text. Edit and delete wait out an undo toast before
they reach the server. Anyone who can triage the issue can comment; only the author can
edit; the author or a project admin can delete. Agent principals cannot comment through
the API, and every comment the API returns carries `flagged` — the prompt-injection rule
its text trips, or null — so nothing pastes it into an agent's context unexamined.

A mention also lands in the mentioned person's **Inbox** under **Mentions**, and by email
or Slack as their notification preferences say, held for their quiet hours.

Over MCP, `issue_comments_list` reads an issue's newest comments with every body scrubbed,
quarantined and clipped, and `issue_essence` says how many there are without carrying a
body. `issue_comment_create` is the one way an agent can comment: it is an approvals
action, `issue.comment.create`, asked of a human by default (an owner can set an ALLOW
policy for it), and the comment is posted under the agent's own name and labelled as an
agent's.

```http
GET    …/issues/WEB-42/comments
POST   …/issues/WEB-42/comments                { "body": "ask @[Ada](principal:<id>) about the retry" }
PATCH  …/issues/WEB-42/comments/<comment id>   { "body": "…" }
DELETE …/issues/WEB-42/comments/<comment id>
GET|PUT /me/notifications/mentions             { "enabled": false }
```

A mention is stored per person (`issue_comment_mentions`) and announced once as an
`issue.comment.mentioned` notice; editing a comment to add someone notifies only them.

## Ownership, team assignment and auto-assign

**Settings › Projects › Ownership** says who owns which code, one rule per line in the
shape of a CODEOWNERS file — a path pattern, then owners, `@team-slug` for a team or a
member's email — and, as in CODEOWNERS, **a later line wins**:

```text
src/** @platform
src/checkout/** @payments
src/legacy/** dana@acme.com
```

**Who would own this?** runs the draft against an issue id (its latest event's in-app
frames, as repository paths when a code mapping covers them) or a path, and names the
owner and the line that decided. **Import CODEOWNERS** reads `.github/CODEOWNERS`,
`CODEOWNERS` or `docs/CODEOWNERS` from the repository the project is mapped to:
`@org/team` becomes the Bucker team with that slug and an email the member with it, and
a bare `@user` (a GitHub account) becomes the member who connected that GitHub account
under **Connected sign-in accounts** — matched on the GitHub login, refreshed each time
they sign in with GitHub, and only among this organization's members. Any owner that maps
to nobody stays in the rule as written and is listed as **unmapped**; a line whose owners
are all unmapped is skipped and counted, since it would route to nobody. Imported rules are listed apart,
replaced by the next import — a push to the default branch that changes the file imports
it again — and outranked by rules typed in the editor for the same path.

The rules decide where an alert rule's **Notify owner** action goes, and who a NEW issue
is assigned to: with **Assign new issues to their owner** on (the default), the worker
assigns the owning team (or person) as the issue is created, and failing a rule, the
author of the suspect commit when they are a member — the timeline says which. An
unassigned issue's **Assignee** section shows the same suggestion with an **Assign**
button. Issues can be assigned to a team as well as a person (the assign box lists teams
first); `assigned:#payments` finds a team's issues, and `is:unassigned` means neither.

```http
GET  /orgs/acme/projects/web/ownership
PUT  /orgs/acme/projects/web/ownership                    { "text": "…", "autoAssign": true }
POST /orgs/acme/projects/web/ownership/test               { "issueId": "WEB-42" } | { "path": "src/x.ts" }
POST /orgs/acme/projects/web/ownership/import-codeowners
GET  …/issues/WEB-42/owner                                # the suggestion
PATCH …/issues/WEB-42  { "action": "route", "assigneePrincipalId": null, "assigneeTeamId": "<team id>" }
```

## Latency regressions

Bucker raises an issue when an endpoint gets slower and stays slower, even if nothing
throws. Every 15 minutes the worker works out the p95 duration of each endpoint for each
complete hour, from server spans. An endpoint is `METHOD route`: the `http.route` your
framework reports, or the URL path with ids replaced (see
[dashboards.md](dashboards.md#attributes-bucker-adds-to-spans)). Each environment is
judged separately.

An endpoint becomes a **LatencyRegression** issue when all of these hold:

- each of the last 3 complete hours had at least 30 calls;
- the p95 of each of those hours is more than 3 robust deviations above the median p95 of
  the 7 days before (median and median absolute deviation, so earlier slow hours do not
  raise the baseline);
- the regressed p95 is at least 30% and at least 50 ms above that median;
- the endpoint has not already had a regression issue in that baseline period.

These are the defaults. Change them per project in **Settings › Projects › Performance
issues**. The issue page shows the endpoint, the baseline and regressed windows with their
p95, the change, the newest deploy to that environment in the 24 hours before the shift,
the five slowest sample traces (linked), and the thresholds it was judged by. It is an
ordinary issue: assign, resolve, merge and alert on it as on any other. The worker pass is
called `performance`; an operator can pause it, and `PERFORMANCE_ISSUES_ENABLED=false`
turns it off.

## Performance patterns

Every minute the worker reads the traces that have been quiet for two minutes and looks
for five patterns that waste time on a code path. Each is raised as an ordinary issue, at
level `warning`, grouped by the pattern, the code path (the trace's endpoint, or its root
span name) and what repeated. One N+1 in `GET /orders` is one issue however many requests
hit it, and you can merge, assign, resolve and alert on it like any other issue.

| Pattern | Issue type | Raised when (defaults) |
| --- | --- | --- |
| N+1 query | `NPlusOneQuery` | the same statement (`bucker.db.query`) runs at least 5 times under one parent span, taking at least 50 ms in total |
| N+1 HTTP calls | `NPlusOneHttp` | the same outbound call (domain and path) is made at least 5 times under one parent span, taking at least 300 ms in total |
| Consecutive HTTP calls | `ConsecutiveHttp` | **off by default.** At least 3 outbound calls under one parent run one after another, at least 2 s in total |
| Slow query | `SlowQuery` | a statement takes at least 500 ms, once it has been seen in 100 traces |
| Large HTTP payload | `LargeHttpPayload` | an outbound response body is at least 300,000 bytes (`http.response.body.size`) |

Consecutive HTTP is off because calls that really depend on each other (log in, then
fetch) look the same as calls that could run together. Turn it on for services where you
know they could. Every threshold, including how many traces must show a pattern before it
becomes an issue, is set per project in **Settings › Projects › Performance issues**.

The issue page lists the offending spans (name, when each started in the trace, and how
long it took), links the trace, and shows the thresholds it was judged by. A span that
arrives more than two minutes after it started may be missed by these detectors; the
worker reads each project's spans once, by start time.
