Skip to content
DashboardWebsite

Analysis Engine

This page explains how OpenTremor loads pack plugins, routes content to packs, runs server-side analysis, detects agent injection, and manages findings. It is for engineers and platform administrators who need to understand or operate the analysis pipeline.

class BasePack(ABC):
name: str # URL slug e.g. "python-code-change"
description: str
is_ready: bool = True # False -> never registered
version: str = "1.0.0"
repository_url: str | None = None # where the source lives; shown on the dashboard
file_globs: list[str] = [] # auto-routing: glob-matched against a diff's changed file paths
def sniff(self, raw_input: str) -> float: return 0.0 # auto-routing: content confidence, non-diff input
parse: Callable[[str], list[AnalysisUnit]] # set by the pack: parse = staticmethod(parse_x)
def ingest(self, raw_input: str) -> list[dict]: ... # parse(), as plain dicts
def get_rules(self, rule_type=None) -> str: ...
@property
def manifest(self) -> dict: ... # {name, description, version, repository_url, file_globs, detects_content, ...}
registry = PackRegistry()
for entry_point in importlib.metadata.entry_points(group="opentremor_core.packs"):
registry.register(entry_point.load()())

The core repository does not hardcode a list of packs. At startup, create_app() walks the opentremor_core.packs entry-point group and registers each pack it finds. A pack is a separate package with its own parser, rules, and manifest. Each unit returned by ingest() is an AnalysisUnit.model_dump()-shaped dictionary. The model is pack-agnostic: a changed Python function, a Terraform resource block, and an Ansible task are all units.

The router looks up the pack by name in the URL path and delegates parsing and rule retrieval to it. It then:

  • Runs only packs enabled for the target: the org’s installed_packs rows, plus the enabled_packs of its product and repository. A pack with no setting is off (core ADR 0044).
  • Appends the org’s enabled custom rules for that pack, if any, after the built-in rules from get_rules(). It groups them by category through get_effective_rules() (controllers/services/rules/ruleset.py).

A diff-shaped pack parses a unified git diff, such as python-code-change, and can process a pull request through the GitHub App integration. A plan-shaped pack needs CLI output as input. The server does not run that CLI.

Auto-routing — picking the pack instead of naming one

Section titled “Auto-routing — picking the pack instead of naming one”

POST /v1/{changeset}/ingest/auto and POST /v1/{changeset}/analyze/auto (controllers/services/analysis/content_router.py) let a caller omit the pack name. Auto-routing uses file globs and content sniffing in this order:

flowchart TD
    A["raw_input"] --> B{"unified diff?\n(has 'diff --git a/... b/...')"}
    B -- yes --> C["split per file"]
    C --> D["glob each path against every\npack's file_globs"]
    D -- "an enabled pack matches" --> E["run each matched pack\non its own files, merged"]
    D -- "only disabled packs match" --> K["Detection(pack=None,\nreason='not enabled here')"]
    D -- "no pack matches" --> S["ask each pack that overrides sniff()\nto score the file's added lines"]
    S -- "one pack >= 0.5, 0.2 ahead of the rest" --> SE{"enabled?"}
    SE -- yes --> H2["route the file to that pack"]
    SE -- no --> K
    S -- "two packs within 0.2" --> F
    S -- "nothing clears 0.5" --> F
    F{"generic enabled\nfor the org?"}
    B -- no --> G["ask every pack's sniff(raw_input)\nfor a confidence score"]
    G -- "an enabled pack >= 0.5" --> H["route to that pack"]
    G -- "only a disabled pack >= 0.5" --> K
    G -- "nothing clears 0.5" --> F
    F -- yes --> I["route to generic\nDetection(pack='generic', fallback=True, reason=...)"]
    F -- no --> J["Detection(pack=None, reason=...)\n— reported, not dropped"]

A diff file no glob claims is routed by its content (OpenTremor-core#0035). Each pack that overrides sniff() scores the file’s added lines, without diff markers. Packs that keep the default sniff() are not asked. The best score wins when it reaches 0.5 and leads every other score at or above 0.5 by at least 0.2. When two packs score within 0.2, the file goes to generic with the reason content matches several packs: <a>, <b>. Kubernetes, Compose, and Ansible are all YAML at arbitrary paths, so each sniff() must match its own schema, not just YAML. A glob match always wins: a file a glob claims is never sniffed. A file with no added lines is not sniffed.

A file or blob that no pack claims returns a Detection with path, detected_kind (a generic, pack-independent display label from libs/content_sniff.detect_label, never used to route), pack, reason when pack is null, and fallback. It does not silently disappear. This matters for the GitHub webhook: before auto-routing, a PR diff was always handed wholesale to terraform-code-change, whose parser silently discarded every non-.tf file. Multiple packs may match the same file; auto-routing runs all of them.

The generic fallback. When neither strategy finds a match, content_router.py checks whether the optional opentremor-pack-generic plugin (reference) is installed and enabled for the org. If so, it routes the content there, and the resulting Detection has fallback: true. A caller can render “no pack found — falling back” instead of showing a confident match. generic is excluded from the normal file_globs and sniff() candidate pools by name. It is reached only through this fallback path and starts off like any other pack, so an org must enable it to use it. If it is not installed or enabled, routing returns the unmatched Detection(pack=None, reason=...).

Units from matched packs land in the same changeset, tagged with their own metadata.pack. POST /v1/{changeset}/claims already resolves rules per unit, so a changeset can contain units from multiple packs. A single rule_type override does not mean the same thing across packs. For this reason, /analyze/auto uses each matched pack’s own default_rule_type and does not accept a variant override.


POST /v1/{pack}/{changeset}/analyze lets the server call the LLM instead of having a client drive the ingest, analysis, and submission cycle. The server.sync_analysis_max_units setting defaults to 5 units; runs at or below that threshold run inline, and larger runs use a background job.

flowchart LR
    A["POST .../analyze\n{connection_id, model, api_key?, raw_input}"] --> R["ingest → new revision"]
    R --> B{"unit count <=\nsync_analysis_max_units?"}
    B -- yes --> C["jobs doc (running, mode=sync)\nrun_analysis() inline\n-> 200 + report + job_id"]
    B -- no --> D["jobs doc (queued, mode=async)\n-> 202 + job_id"]
    D -. "stored connection" .-> Q["platform job queue\nany replica's worker"]
    D -. "inline api_key" .-> L["this replica only\n(the key is never stored)"]
    Q --> E["run_analysis()\n-> jobs doc: done | failed | cancelled"]
    L --> E

Both branches leave a job document. An inline run is recorded as mode: "sync" and returns its job_id with the report. You can look up, resume, and audit every analysis, including small runs. Previously, a run at or below sync_analysis_max_units created no job. If it failed, the caller received a 502, the Jobs page was empty, and there was no way to resume resources that had already been ingested. Error responses now carry the job_id too.

A sync job cannot be cancelled. It runs inside the request that started it, so by the time a caller could ask to cancel, the run has ended. POST /v1/jobs/{job_id}/cancel returns 409. A resumed job always runs in the background, regardless of the mode of the job it resumes.

run_analysis() (controllers/services/analysis/runner.py) follows the client-led loop’s sequence: ingest() → get_rules() plus the org’s custom pack rules → call the LLM for each unanalyzed unit → analysis_service.record_analysis() → write a usage_events entry. The server does not need an agentic tool-calling loop because it already knows this sequence.

analyze_unanalysed_units() processes units and makes the provider calls. The settings that control the loop are in the analysis config section.

  • Concurrency. The loop analyzes up to analysis.max_concurrent_units units in parallel, then starts the next batch. The default is 4. The limit applies per run: N concurrent jobs can make N × max_concurrent_units calls at once. The org’s monthly budget remains the spend limit.
  • Deadline. Each provider call uses analysis.llm_timeout_seconds, which defaults to 120 seconds and is passed to the SDK. Without it, each SDK’s own default applies. Anthropic’s default is 10 minutes.
  • Retry. A transient failure (429, 5xx, timeout, or dropped connection) is retried up to analysis.llm_max_attempts times. The default is 3 total attempts; 1 disables retries. The loop uses exponential backoff with full jitter. Errors that retries cannot fix, such as a bad key, rejected schema, or unparseable response, fail on the first attempt.
  • Response size. Each call is capped at analysis.llm_max_output_tokens, which defaults to 4096. A response that reaches the cap is truncated. Each backend checks its provider’s stop signal (stop_reason or finish_reason) and raises LLMTruncatedError with the cap value. Truncated responses are not retried because the same prompt and cap would overflow again.
  • Cancellation. Before each batch, the loop reads the job document and stops if its status is no longer running. It checks storage rather than an in-process handle because another replica may handle the cancel request. A job cancelled while queued is never claimed.

Untrusted content, and what the loop does about it

Section titled “Untrusted content, and what the loop does about it”

A unit’s body comes from the input. On the GitHub App path, that input is a pull-request diff. Contributors outside the org can write that content. The analysis is posted to the same PR as a comment under the App’s identity, along with a commit status that can gate the merge. Text that steers the model’s verdict could therefore make the product publish that verdict as its own. The loop uses three guards:

  • A nonce-delimited content boundary. Every system prompt gets a boundary paragraph with a per-run random marker. The unit body is fenced between BEGIN/END UNTRUSTED CONTENT <nonce>. The prompt says that this content is data to analyze, not instructions. It also says that content addressing the reviewer—claiming prior approval, changing the rules, or asking for a different verdict—is itself a finding to report (rule_id: AGENT-INJECTION, severity HIGH). The nonce is random so content cannot predict the marker and close the block. The nonce does not exist when the payload is written.
  • Quote verification (libs/analysis_guard.verify_quotes). The loop checks each Finding.quotes entry against the unit body as a verbatim snippet, allowing collapsed whitespace. It drops entries that do not appear in the body. If none remain, it demotes the finding to confidence: LOW, routes it to needs_review, and adds unverified-quote. It keeps the finding so a fabricated quote cannot erase a real one.
  • Rule ID check (services/analysis/rule_check.py). A finding must name a rule in its unit’s ruleset, or use null when no rule applies. Findings are stored by unit and rule, so two findings for one rule and unit would overwrite each other. The server refuses caller-submitted analysis with an invalid rule ID. For the server’s LLM response, it changes an unknown ID to null, adds unknown-rule, and merges findings with the same rule.
  • Markdown sanitization at the publication boundary (libs/analysis_guard.sanitize_for_external_comment). Before it renders a PR comment, the system entity-escapes every LLM-authored string and names parsed from the input file. This prevents images, links, @ mentions, raw HTML, backticks, pipes, and newlines from changing the markdown_report_light table. The system sanitizes only this publication path. The report API and dashboard responses return unescaped values because those consumers escape the values themselves; the HTML template autoescapes them.

These guards bound the effects of an injection that succeeds. They do not detect injections; the detection pass is described below.

Budget accounting is checked per batch, so a run can exceed the org’s cap by at most max_concurrent_units - 1 units. A unit’s cost is known only after the call has completed.

LLM provider abstraction (libs/llm/): each provider has an LLMClient implementation (Anthropic, OpenAI, and Mistral). Each client requests structured JSON through its provider’s mechanism: a forced tool call for Anthropic, response_format=json_schema for OpenAI, or JSON mode with the schema in the prompt for Mistral. Mistral’s JSON mode does not accept a schema directly, so MistralClient retries once after a validation failure, sending the invalid output and validation error back to the model. Anthropic and OpenAI do not need this repair retry. get_llm_client(backend, api_key) is the factory.

The schema’s required fields differ across providers. OpenAI’s strict json_schema mode enforces the schema. Anthropic’s forced tool call and Mistral’s JSON mode treat required as a strong hint. If the prompt omits a field, a model may omit it. That happened with UnitAnalysis.verdict, then called summary: a clean unit’s response omitted it even though the findings were present. Two changes address this:

  • The system prompt names every response field, including verdict.
  • UnitAnalysis.verdict is optional in the schema, and all three backends validate through shared parse_unit_analysis(). If verdict is missing or blank, the parser fills it from the findings the model did send (for example, "3 findings — 1 HIGH, 2 LOW."). It does not invent a verdict. Other malformed fields still fail the unit because guessing at a finding would invent a security result.

The issue was one missing line of prose causing a unit to fail and taking the whole run down with it, even when the findings were present.

Each backend translates retryable SDK failures into the shared TransientLLMError, so libs/llm/retry.py can implement the retry policy without knowing each provider’s exception types. A new provider can classify its errors in its own client without changing the retry logic.

Credential resolution: the request body’s api_key, if present; otherwise the key on the named LLM connection; otherwise the request fails with 400. Connections are stored through POST /v1/orgs/{org_id}/llm-connections. Their keys are encrypted at rest with Fernet in libs/crypto.py, using a key derived from config.secrets.encryption_key.

This pass asks whether a change is trying to manipulate automation that reads it next: a code-review bot, an agent running in CI, or OpenTremor’s analysis loop. The guards above bound the effects of an injection on analysis output. This pass tries to detect one.

libs/injection_scan/segment.py splits a change into typed spans before matching. This ordering is part of the design.

A reviewer may skim comments, docstrings, YAML description: fields, HTML comments in Markdown, and commit messages while a machine reads them in full. A pattern corpus matched against whole files treats those channels the same as executable code and prose, making it less useful. In measurements against 60 real workspace files, matching a 721-rule corpus against whole file contents fired on 13 of 60 files in 29.4 seconds. Matching the same rules against machine-only channels fired on 0 of 60 in 1.1 seconds. The sample is indicative, not a benchmark.

Two rules guide segmentation:

  • Added lines only. Context and removed lines are not changes the pull request asks anyone to accept. Scanning them would re-report a file’s history on every push, including when a commit removes an injection.
  • Line-level channel classification. The scanner classifies comment, docstring, html_comment, config_text, prose, fenced_code, and code lines. It also classifies text with no file as pr_title, pr_body, or commit_message. MACHINE_ONLY_CHANNELS names the subset a reviewer skims and a machine reads in full. A match in these channels has more weight than the same match in code or prose. An instruction-shaped sentence is common in a design document and more concerning in a code comment.

Classification is line-level and best-effort, not a parser. A diff often contains only part of a multi-line construct, and the file may not parse at this commit. The scanner tracks limited state for open block comments, Markdown fences, and Python docstrings so it can classify lines after an opener. Each Span carries (path, channel, line, text). The line number comes from the hunk header so a finding points to a line a reviewer can open.

libs/injection_scan/structural.py checks path globs and codepoint classes. It uses no patterns, corpus, or model.

GitInject tested live prompt-injection attacks against real GitHub workflows for four commercial coding agents. Its most successful vector was adding CLAUDE.md, AGENTS.md, or GEMINI.md to a pull request branch. actions/checkout puts the file in the workspace, where an agent can load it as operator-level instruction before reading code. The models resisted prose injected into a PR body best.

Agent instruction files. The scanner checks globs such as CLAUDE.md, AGENTS.md, GEMINI.md, .cursorrules, .cursor/rules/**, .github/copilot-instructions.md, .claude/**, .mcp.json, and SKILL.md. It conditions these detections on author trust to avoid flagging every maintainer PR. A maintainer editing CLAUDE.md is doing their job; a first-time contributor from a fork could change the instructions used by bots reviewing their PR. A trusted author produces one INFO record that does not block. An untrusted author produces HIGH, which holds the merge. On GitHub, trust comes from author_association and whether the head repo is a fork. On GitLab, it comes from the author’s access level on the target project (Developer or higher).

Invisible and reordering codepoints. Unicode Tags (U+E0000–U+E007F) and bidirectional controls are CRITICAL. Bidirectional controls can support the Trojan Source attack (CVE-2021-42574), where reviewed code can differ from executed code. Zero-width characters are HIGH. The scanner spells out these characters in evidence, such as # app<U+200B>rove, so the finding shows what is hidden.

Base64 and hex blobs in comments are not tier 0 checks. They can appear in checksums, lockfiles, certificates, and minified assets. They are checked in tier 1, where the channel affects the match weight.

libs/injection_scan/patterns.py matches a pinned subset of Agent Threat Rules: 244 rules and 1051 patterns, licensed under MIT.

The subset is vendored and pinned rather than installed as a dependency. src/tools/refresh_atr_rules.py clones upstream at a commit, reapplies the recorded filter, and prints an added, removed, and changed summary. rules/ATR-PIN.json records the commit and filter. rules/LICENSE.ATR records the license. Do not hand-edit the subset; change the filter and rerun the tool.

The filter keeps categories about content that manipulates a reader and have conditions on text fields. It drops categories such as tool_response, tool poisoning, and excessive autonomy, which describe agent runtime behavior rather than content represented in a diff.

Measured with the shipped code, the subset has 98.6% recall against ATR’s 1,309 documented payloads, 2.3% false positives against its 1,240 negatives, and 0 of 60 matches against real workspace files in 0.6 seconds. Treat the recall figure as a tripwire for a bad refresh, not as a detection rate. It measures whether the corpus still matches its documented payloads; paraphrasing can evade its rules.

Three details make the corpus usable:

  • Only instruction-bearing channels are matched: machine-only channels, plus the PR title and body. Excluding prose and code accounts for the 0/60 result. As a result, an “ignore previous instructions” sentence in a README is not flagged.
  • One finding per location uses the stable rule_id AGENT-PATTERN-MATCH. The corpus has overlapping rules, so one line may match several. Reporting each matched ID would create multiple findings for one line and could lose a reviewer’s triage decision if the upstream rules change. The matched IDs are kept in the finding’s tags. The title (“Instruction addressed to an AI reviewer”) and risk text are fixed.
  • Bounds limit attacker-controlled input and regex work: 2000 characters per span, 20 matches per pattern, and a 5-second wall-clock budget. If the scanner exhausts the budget, it raises an AGENT-SCAN-TRUNCATED finding instead of returning quietly.

Tier 2 — semantic scoring, paid by the organization

Section titled “Tier 2 — semantic scoring, paid by the organization”

libs/injection_scan/semantic.py and services/analysis/injection_scoring.py implement tier 2. Tier 1 matches phrases that can also appear in test fixtures or security notes. Tier 2 asks an LLM whether each tier 1 match addresses an automated reader or people.

Tier 2 runs only when both switches are on: the platform allows it with analysis.injection_scan_semantic, and the organization turns it on in Organization → Features → Agent Injection (PUT /v1/orgs/{org_id}/injection-settings). The organization chooses because it pays for scoring and bears its risk (core ADR 0033).

  • Cost. The scorer makes one call per tier 1 match, up to analysis.injection_scan_semantic_max_spans (default 20) per change. Each call creates an llm_tokens usage event with purpose: injection-scoring and counts against the org’s monthly LLM budget. It does not create a resource_analyzed event.
  • Model. The organization may choose a connection and model for scoring. If it does not, or if the chosen connection is deleted or its model is no longer allowed, scoring uses the review’s connection and model.
  • Verdict. benign lowers the finding to INFO; injection raises its confidence to HIGH; unsure leaves it unchanged. Scoring does not create or delete findings or raise severity. Tier 0 detections are not scored.
  • Limits. The scorer reads the payload it judges, so that payload could manipulate it. A manipulated answer can lower one finding to INFO, where a reviewer can still see it. The verdict’s reason goes into the finding’s consequence, not its quotes, so a rescanned PR keeps its triage.
  • Failures. A spent budget, provider failure, or invalid answer leaves the tier 1 verdict in place. Tier 2 does not fail the review. The job records scoring details in injection_scoring (matches scored, why it stopped, and cost), which appear in the job panel.

A knowledge sync flags an ADR or agent-instruction file with a match and does not create a rule proposal from a flagged file. An organization can let tier 2 clear such a file with Also score files read for rule proposals (injection_settings.knowledge_sync_enabled, off by default). This applies only when semantic scoring is on (core ADR 0039).

  • The file is read only when every match is scored benign. An injection or unsure verdict, invalid answer, spent budget, or provider failure keeps it flagged, and the file detail says why.
  • Tier 0 detections are never scored. A file with hidden codepoints stays flagged without an LLM call.
  • If a file has more than analysis.injection_scan_semantic_max_spans matches, it is not scored.
  • An unchanged file is not scored again. A file flagged before the setting was enabled is scored at the next sync.
  • The same model and budget apply as for pull requests. A cleared file produces proposals only; a person approves each one.

The scanner records a detection as an ordinary Finding on a synthetic resource, one per file (or per pull-request or commit-messages for text that belongs to no file). Triage status, needs-review notifications, retention, report rendering, PR comments, and the commit-status gate already work with findings.

The synthetic units are pre-analyzed. find_unanalysed selects units with an empty analysis field, so a unit without analysis would be sent through the LLM loop and charged. The units are also unmetered, through record_analysis(metered=False). Agent-injection detection is free on every plan: the deterministic tiers make no LLM call, use no demo credit (demo credit is gated on LLM-analyzed units), and book no resource_analyzed event. The resource hash covers the detections. Rescanning an unchanged PR finds the same resource and preserves a human’s decision.

The scanner checks each channel that carries PR text, not only the diff. The PR title and body arrive in the webhook payload. Commit messages come from an extra /pulls/{n}/commits call. If that call fails, the scanner still checks the other channels. A commit message may contain a payload that appears in no file, so scanning only the diff would miss it.

The following analysis settings are live-editable through PATCH /v1/admin/settings:

FieldDefaultWhat it does
injection_scan_enabledtrueRuns the deterministic tiers on every change
injection_scan_semanticfalseAllows organizations to turn on tier 2
injection_scan_semantic_max_spans20Maximum tier 1 matches tier 2 scores in one change
injection_scan_gate"review"Default commit-status behavior for organizations that have not chosen a gate

An organization sets its own gate in Organization → Features → Agent Injection. The platform value is the default for organizations that have not chosen one.

The gate has three settings. off records and reports the finding but does not block. review forces a HIGH or CRITICAL injection finding to pending with “Possible agent manipulation — needs human review.” This is distinguishable from the generic needs-review hold. fail treats it as a normal finding of its severity. review is the default because an unreviewed finding should be held for human review.

Under review, the hold lasts while the finding is untriaged (open or needs_review). Any triage decision, including acknowledged, releases it. Under fail, the finding follows the ordinary severity gate, which keys off open; acknowledgement clears it there too.

On GitHub, author_association and whether the head repo is a fork determine author trust. On GitLab, trust comes from the author’s access level (Developer or higher). This keeps the agent-instruction-file rule from firing on every maintainer pull request.

A commit status is a push, not a poll: GitHub holds the last state written to a SHA. Triage therefore updates the check as well as the finding. PATCH /v1/findings/{hash}/{rule_id} reposts the pull request’s commit status through controllers/services/integrations/pr_gate.py. A PR held at pending goes green when the last finding holding it is triaged; it does not need another push, rerun, or webhook event.

The mechanics:

  • The review job records where it posted (pr_gates), keyed by org_id and changeset. It stores the provider, repository, PR number, head SHA, host adapter’s locator, and resource count used in the status description. It records this immediately before posting, so a status on the host has a row that can repost it.
  • pr_gate.compute_gate_state() defines how findings map to a check state. Both the analysis run and repost call it.
  • One resource can belong to several changesets. For example, two open PRs may touch the same CLAUDE.md and use one content-addressed unit. The system refreshes every gate that resource feeds.
  • Reposting is best-effort. Triage is already persisted, so a GitHub outage is logged and does not turn a successful PATCH into an error. If the org disconnected the App after the analysis ran, the system skips reposting.
  • Findings from API and dashboard paths do not belong to a pull request and do not reach GitHub.

The stored resource_count lets a repost quote the same “N unit(s) analysed” count as the original status. Triage changes the check state, not the size of the run.


flowchart LR
    A["record_analysis()\n(client-led PUT or server-led run_analysis)"] --> R["compute_initial_status()\nmatched rule.requires_review, or LOW/UNKNOWN confidence?"]
    R --> B["storage.upsert_finding()\nkeyed by org_id + resource_hash + rule_id"]
    B --> C{"first time seen?"}
    C -- yes --> D["status = open or needs_review\nfirst_seen = last_seen = now"]
    D -. needs_review .-> W["needs_review.notify_needs_review()\n(trigger=auto)"]
    C -- no --> E["last_seen, occurrence_count refreshed\nstatus UNCHANGED (initial_status ignored)"]
    F["PATCH /v1/findings/{hash}/{rule_id}"] --> G["status = open|needs_review|acknowledged|suppressed|false_positive"]
    G -- needs_review --> W2["needs_review.notify_needs_review()\n(trigger=manual)"]
    G --> V["review feedback recorded\n(acknowledged, suppressed, false_positive)"]
    G --> P["pr_gate.refresh_pr_gates_for_resource()\nre-post the commit status and edit the comment\nfor every pull request this resource gates"]
    G -.persists across re-scans.-> E

build_report_data() (controllers/services/reports/data.py, shared by the report endpoints and the GitHub webhook job) joins a changeset’s resources against findings. By default, it omits suppressed and false_positive findings from the rendered report; use ?include_suppressed=true to include them. acknowledged findings remain visible with a status badge.