stacktrace-cli 0.4.1__tar.gz → 0.5.0__tar.gz

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stacktrace-cli
-Version: 0.4.1
+Version: 0.5.0
 Summary: CLI for Stacktrace — Detection and Response platform for AI Agents.
 Project-URL: Homepage, https://stacktrace.ai
 Author-email: "Stacktrace AI, Inc" <founders@stacktrace.ai>
@@ -51,7 +51,7 @@ Requires Python 3.11 or newer.
 
 ```console
 $ stacktrace --version
-stacktrace 0.4.1 (openaca 0.7.0)
+stacktrace 0.5.0 (openaca 0.7.0)
 ```
 
 ## Quick start

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/README.md

@@ -24,7 +24,7 @@ Requires Python 3.11 or newer.
 
 ```console
 $ stacktrace --version
-stacktrace 0.4.1 (openaca 0.7.0)
+stacktrace 0.5.0 (openaca 0.7.0)
 ```
 
 ## Quick start

stacktrace_cli-0.5.0/docs/releases/v0.5.0.md

@@ -0,0 +1,113 @@
+# 0.5.0 — the alert says what happened, and a stalled agent earns one
+
+0.4.0 put a daemon behind the session and gave it a socket back to the agent
+that caused a finding. This release is about what arrives over that socket and
+what you get when you follow it. Two things it could not do: an alert read
+`Stacktrace detected a high-severity finding` and named a rule id, which tells
+a reader the severity of something they still have to go and identify; and the
+`/stacktrace:findings` page it sent them to answered with one line per finding
+in the same shape, so following the alert returned the alert.
+
+Both now say what happened and what to do about it. The eligibility gate also
+widens by one severity, which is what lets a blocked agent page you at all.
+
+## An alert names the rule in plain language
+
+Notification text is selected by **rule id only** — a Stacktrace-owned lookup,
+not the finding's own title. That is the same boundary ADR-0031 draws for
+everything the daemon retains: detector prose, component names and evidence
+never supply notification text, and nothing read from a transcript travels into
+an alert.
+
+| Rule | The alert now says |
+| --- | --- |
+| `stacktrace-credential-egress` | Credential-shaped material appeared in an outbound tool call |
+| `stacktrace-agent-blocked` | The agent encountered a block while working |
+| `stacktrace-deceptive-completion` | A success claim conflicts with verification evidence |
+
+The body carries the severity and the rule id as fields rather than as the
+headline, and points at `/stacktrace:findings` for evidence and next steps.
+
+The credential wording is deliberately about *shape*: credential-shaped
+material reached an outbound call. It does not claim the credential was valid,
+and it does not claim the destination received it — neither is something the
+detector knows, and an alert that asserts either is one a reader learns to
+discount.
+
+## `stacktrace findings` explains the record it kept
+
+`findings` printed `HIGH stacktrace-agent-blocked: <title>` and stopped. It now
+renders each retained record as a block: the plain-language explanation, the
+confidence, every evidence descriptor with the span it sits at, and a next step
+written for that rule.
+
+For `stacktrace-agent-blocked` the block reason does better than the generic
+line. When the first evidence descriptor's kind is a code from the existing
+reason catalogue — `quota_exhausted`, `policy_blocked`, `provider_throttled`,
+`upstream_refused` — the finding is titled and remedied from that catalogue, so
+a throttle reads as a throttle that clears by itself and a spend limit reads as
+one that does not.
+
+Two properties this output holds to:
+
+- **Stored descriptors are quoted as data.** `kind`, `detail` and `span` are
+  JSON-encoded on the way to the terminal, with non-ASCII and control
+  characters escaped. A ledger is written from a machine's session; it is not
+  a trusted source of terminal escapes.
+- **It says what it does not know.** The ledger retains no tool or component
+  names and no raw call content, so the text output states that attribution was
+  not retained and directs the reader to the cited session locations instead of
+  quietly printing a finding that looks complete.
+
+`--format json` is unchanged — the same stored-record contract 0.4.0 shipped.
+
+Old records need no migration. Explanations are derived at display time from
+the rule id and the retained reason code, so a finding written by 0.4.0 or
+0.4.1 renders under the new templates with nothing rewritten on disk. Reading
+findings does not rerun analysis or touch the ledger.
+
+## A medium-severity finding now notifies
+
+The eligibility gate took `{high, critical}`, so a high-confidence medium
+finding was persisted and never announced.
+
+`stacktrace-agent-blocked` is what this mostly opens up. Its severity is
+derived from who can act on the block: `user` is high, `upstream` and `env` are
+medium, `agent` is low. Both of the catalogue's upstream reasons —
+`provider_throttled` and `upstream_refused` — are therefore medium, and the
+gate was the only thing between a stalled agent and a page about it.
+
+**The confidence gate is untouched.** A finding still needs `confidence ==
+"high"` to notify; this widens severity only, and `low` stays silent.
+
+The store test that covered this used `medium` as its negative case, so it
+would have passed for the wrong reason after the change. It now records four
+findings — high/high, medium/high, low/high, high/low — and asserts exactly the
+first two notify.
+
+See `docs/specs/notification-delivery.md`.
+
+## Install
+
+`uv tool install stacktrace-cli==0.5.0` or `pip install stacktrace-cli==0.5.0`.
+Python 3.11 or newer; macOS and Linux.
+
+## Compatibility
+
+Beta — no back-compat hedging.
+
+- **You will get more notifications.** Any high-confidence `medium` finding now
+  pages the session where it was silently persisted before; in practice that is
+  a throttled or refused upstream stopping the agent. Nothing that was silent
+  for want of *confidence* has become noisy.
+- **Notification title and body text changed.** Anything matching on the old
+  `Stacktrace detected a {severity}-severity finding` string will stop matching.
+  The severity and rule id are still both present, in the body.
+- **`stacktrace findings --format text` is multi-line per finding.** It was one
+  line; a consumer parsing that output should read `--format json`, whose shape
+  is unchanged.
+- **Already-queued notifications and delivery acknowledgements are unaffected.**
+  Text is generated when a notification is built, so anything in flight keeps
+  the wording it was built with, under the same stable event id.
+- **A monitor and a CLI of the same version are still required.**
+- **Dependencies are unchanged**: `openaca==0.7.0` and `openaidr==0.3.0`.

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/docs/specs/notification-delivery.md

@@ -61,6 +61,29 @@ fired in which session. It does not carry transcript text, detector-written
 titles, evidence detail, spans or remediation. Widening that is a separate
 decision about the data boundary, not about delivery.
 
+### Readable alerts and local details
+
+The notification title explains the rule in plain language, using a
+Stacktrace-owned lookup rather than the finding's supplied title. Its body
+names severity and rule ID and points to `/stacktrace:findings`. A credential
+alert describes credential-shaped material in an outbound call; it does not
+claim the credential was valid or prove that the destination received it.
+
+`stacktrace findings` renders the retained record with a readable explanation,
+confidence, evidence descriptors and span locations, and a rule-specific next
+step. A known agent-blocked reason uses the existing reason catalogue's title
+and remedy. Raw arguments, credentials, component names, and detector-supplied
+prose are not added to notification text or persistence. The local evidence
+descriptors are quoted as data, with terminal control characters escaped.
+
+Old records need no migration: explanations are derived at display time from
+rule IDs and retained block-reason codes. JSON output keeps the existing
+stored-record contract. Text output explicitly states that component/tool
+attribution was not retained and directs the reader to the cited local session
+locations. Reading findings does not rerun analysis or change the ledger.
+Already queued notification text and delivery acknowledgements are unchanged;
+new notifications use the readable templates.
+
 ## Design
 
 ```
@@ -230,6 +253,7 @@ mean the same thing whether they come from the harness or from Slack, so the
 mute key belongs to the policy system's vocabulary. Until that key exists, a
 mute from Slack and a mute from the terminal are two unrelated records.
 
-`Severity` is `low | medium | high`. The eligibility gate also tests for
-`"critical"`, which appears nowhere else in the codebase, so that branch cannot
-run. This is recorded, not fixed here.
+`Severity` is `low | medium | high`, and the gate notifies on `medium` and
+above at high confidence. It also tests for `"critical"`, which appears nowhere
+else in the codebase, so that branch cannot run. This is recorded, not fixed
+here.

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stacktrace-cli"
-version = "0.4.1"
+version = "0.5.0"
 description = "CLI for Stacktrace — Detection and Response platform for AI Agents."
 readme = "README.md"
 requires-python = ">=3.11"

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/src/stacktrace_cli/__init__.py

@@ -1,3 +1,3 @@
 """The `stacktrace` command-line interface — detection and response for AI agents."""
 
-__version__ = "0.4.1"
+__version__ = "0.5.0"

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/src/stacktrace_cli/daemon/cli.py

@@ -9,6 +9,7 @@ import sys
 import click
 
 from .paths import RuntimePaths
+from .presentation import render_finding
 from .store import FindingStore, SessionKey
 
 
@@ -100,7 +101,4 @@ def findings(agent_kind: str, session_id: str, output_format: str) -> None:
         click.echo("No Stacktrace findings for this session.")
         return
     for finding in stored:
-        click.echo(
-            f"{str(finding.get('severity', 'unknown')).upper()} "
-            f"{finding.get('rule_id', 'unknown-rule')}: {finding.get('title', 'Finding')}"
-        )
+        click.echo(render_finding(finding))

stacktrace_cli-0.5.0/src/stacktrace_cli/daemon/presentation.py

@@ -0,0 +1,68 @@
+"""Explain durable findings without reintroducing discarded transcript prose."""
+
+from __future__ import annotations
+
+import json
+
+from stacktrace_cli.detector.blocked import REASON_CODES, reason_for
+
+# Notification prose is selected by rule ID only (ADR-0031). In particular,
+# finding titles, component names and evidence never supply notification text.
+_GUIDANCE = {
+    "stacktrace-credential-egress": (
+        "Credential-shaped material appeared in an outbound tool call",
+        (
+            "Treat the credential as potentially exposed: revoke or rotate it, "
+            "then inspect why the outbound tool received it."
+        ),
+    ),
+    "stacktrace-deceptive-completion": (
+        "A success claim conflicts with verification evidence",
+        "Inspect the cited verification results before relying on the completion claim.",
+    ),
+    "stacktrace-agent-blocked": (
+        "The agent encountered a block while working",
+        "Inspect the recorded block reason before retrying the task.",
+    ),
+}
+
+
+def rule_guidance(rule_id: str) -> tuple[str, str]:
+    return _GUIDANCE.get(
+        rule_id,
+        ("A finding was recorded", "Inspect the retained evidence in the local session."),
+    )
+
+
+def render_finding(finding: dict[str, object]) -> str:
+    """Render the old, title-less ledger as well as newly recorded findings."""
+    rule_id = str(finding.get("rule_id", "unknown-rule"))
+    title, remedy = rule_guidance(rule_id)
+    evidence = finding.get("evidence", [])
+    items = (
+        [item for item in evidence if isinstance(item, dict)] if isinstance(evidence, list) else []
+    )
+    if rule_id == "stacktrace-agent-blocked" and items:
+        code = items[0].get("kind")
+        if isinstance(code, str) and code in REASON_CODES:
+            reason = reason_for(code)
+            title, remedy = reason.title, reason.remedy
+
+    lines = [
+        f"{str(finding.get('severity', 'unknown')).upper()} {rule_id}: {title}",
+        f"  Confidence: {finding.get('confidence', 'unknown')}",
+    ]
+    for item in items:
+        # Quote stored descriptors as data, including escaped terminal controls.
+        kind = json.dumps(item.get("kind"), ensure_ascii=True)
+        detail = json.dumps(item.get("detail"), ensure_ascii=True)
+        span = json.dumps(item.get("span"), ensure_ascii=True)
+        lines.extend((f"  Evidence ({kind}): {detail}", f"    Location: {span}"))
+    if not items:
+        lines.append("  Evidence: no descriptors were retained.")
+    lines.append(f"  Next step: {remedy}")
+    lines.append(
+        "  Tool/component names and raw call content are not retained in this ledger; "
+        "inspect the cited locations in the local session for attribution."
+    )
+    return "\n".join(lines)

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/src/stacktrace_cli/daemon/store.py

@@ -17,6 +17,8 @@ from stacktrace_cli.detector.rules import scope_of
 from stacktrace_cli.private_state import ensure_private_directory
 from stacktrace_cli.telemetry import emit_derived
 
+from .presentation import rule_guidance
+
 
 @dataclass(frozen=True)
 class SessionKey:
@@ -266,10 +268,16 @@ class FindingStore:
         identity = f"{session.agent_kind}\0{session.session_id}\0{rule_id}\0{anchor}".encode()
         return f"stn_{hashlib.sha256(identity).hexdigest()[:24]}"
 
+    #: Severities that earn a notification. `Severity` is `low | medium | high`;
+    #: `critical` is carried because the gate has always tested for it, though
+    #: no rule emits it. `low` stays silent.
+    _NOTIFIABLE_SEVERITIES = frozenset({"medium", "high", "critical"})
+
     @staticmethod
     def _eligible(finding: dict[str, object]) -> bool:
         return (
-            finding.get("severity") in {"high", "critical"} and finding.get("confidence") == "high"
+            finding.get("severity") in FindingStore._NOTIFIABLE_SEVERITIES
+            and finding.get("confidence") == "high"
         )
 
     @staticmethod
@@ -302,13 +310,17 @@ class FindingStore:
         severity = finding["severity"]
         assert isinstance(rule_id, str)
         assert isinstance(severity, str)
+        explanation, _ = rule_guidance(rule_id)
         return Notification(
             event_id=event_id,
             session=session,
             rule_id=rule_id,
             severity=severity,
-            title=f"Stacktrace detected a {severity}-severity finding",
-            body=f"{rule_id} in this agent session. Run /stacktrace:findings for details.",
+            title=f"Stacktrace: {explanation}",
+            body=(
+                f"Severity: {severity}. Rule: {rule_id}. "
+                "Run /stacktrace:findings for evidence and next steps."
+            ),
         )
 
     @staticmethod

stacktrace_cli-0.5.0/tests/daemon/test_cli.py

@@ -0,0 +1,224 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+import pytest
+from click.testing import CliRunner
+
+from stacktrace_cli.cli import main
+from stacktrace_cli.daemon import cli as daemon_cli
+from stacktrace_cli.daemon.store import FindingStore, SessionKey, TranscriptFingerprint
+from stacktrace_cli.detector.rules import RULE_IDS
+
+
+def test_subscribe_uses_the_native_session_environment(monkeypatch, tmp_path: Path) -> None:
+    seen: dict[str, Any] = {}
+    monkeypatch.setenv("STACKTRACE_DAEMON_SOCKET", str(tmp_path / "daemon.sock"))
+    monkeypatch.setenv("STACKTRACE_DAEMON_STATE", str(tmp_path / "state.json"))
+
+    def follow(paths, session, stdout, stderr) -> None:
+        seen.update(paths=paths, session=session, stdout=stdout, stderr=stderr)
+
+    monkeypatch.setattr(
+        daemon_cli,
+        "_runtime",
+        lambda: (lambda _path: True, follow, lambda _paths: None),
+    )
+
+    result = CliRunner().invoke(
+        main,
+        ["daemon", "subscribe", "--agent-kind", "claude-code"],
+        env={"CLAUDE_CODE_SESSION_ID": "native-session"},
+    )
+
+    assert result.exit_code == 0
+    assert seen["session"] == SessionKey("claude-code", "native-session")
+    assert seen["paths"].socket == tmp_path / "daemon.sock"
+
+
+def test_subscribe_requires_a_native_session_id() -> None:
+    result = CliRunner().invoke(
+        main,
+        ["daemon", "subscribe", "--agent-kind", "claude-code"],
+        env={"CLAUDE_CODE_SESSION_ID": None},
+    )
+
+    assert result.exit_code == 2
+    assert "--session-id" in result.output
+
+
+def test_findings_reads_only_the_requested_session(monkeypatch, tmp_path: Path) -> None:
+    state_path = tmp_path / "state.json"
+    monkeypatch.setenv("STACKTRACE_DAEMON_STATE", str(state_path))
+    store = FindingStore(state_path)
+    store.record(
+        SessionKey("claude-code", "wanted"),
+        TranscriptFingerprint(size=1, mtime_ns=1),
+        (
+            {
+                "rule_id": "stacktrace-credential-egress",
+                "severity": "high",
+                "confidence": "high",
+                "title": "A credential left the session.",
+                "session": {"session_id": "claude-code:wanted"},
+                "evidence": [
+                    {
+                        "span": "claude-code:wanted:u1:0",
+                        "kind": "credential",
+                        "detail": "token",
+                    }
+                ],
+            },
+        ),
+    )
+
+    result = CliRunner().invoke(
+        main,
+        [
+            "findings",
+            "--agent-kind",
+            "claude-code",
+            "--session",
+            "wanted",
+            "--format",
+            "json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    document = json.loads(result.output)
+    assert [finding["rule_id"] for finding in document["findings"]] == [
+        "stacktrace-credential-egress"
+    ]
+
+
+def test_daemon_commands_are_visible_but_run_is_internal() -> None:
+    root_help = CliRunner().invoke(main, ["--help"])
+    daemon_help = CliRunner().invoke(main, ["daemon", "--help"])
+    subscribe_help = CliRunner().invoke(main, ["daemon", "subscribe", "--help"])
+    findings_help = CliRunner().invoke(main, ["findings", "--help"])
+
+    assert "daemon" in root_help.output
+    assert "status" in daemon_help.output
+    assert "subscribe" in daemon_help.output
+    assert "\n  run " not in daemon_help.output
+    assert "--agent-kind" in subscribe_help.output
+    assert "--agent-kind" in findings_help.output
+
+
+def test_findings_explains_a_persisted_credential_finding(monkeypatch, tmp_path: Path) -> None:
+    state_path = tmp_path / "state.json"
+    monkeypatch.setenv("STACKTRACE_DAEMON_STATE", str(state_path))
+    store = FindingStore(state_path)
+    store.record(
+        SessionKey("claude-code", "wanted"),
+        TranscriptFingerprint(size=1, mtime_ns=1),
+        (
+            {
+                "rule_id": "stacktrace-credential-egress",
+                "severity": "high",
+                "confidence": "high",
+                "title": "do not render this untrusted title",
+                "session": {"session_id": "claude-code:wanted"},
+                "evidence": [
+                    {
+                        "span": "claude-code:wanted:u1:0",
+                        "kind": "jwt",
+                        "detail": "at offset 0 in the arguments of an MCP connector",
+                    }
+                ],
+            },
+        ),
+    )
+    before = state_path.read_bytes()
+
+    result = CliRunner().invoke(
+        main, ["findings", "--agent-kind", "claude-code", "--session", "wanted"]
+    )
+
+    assert result.exit_code == 0
+    assert "Credential-shaped material appeared in an outbound tool call" in result.output
+    assert "Confidence: high" in result.output
+    assert "jwt" in result.output
+    assert "at offset 0 in the arguments of an MCP connector" in result.output
+    assert "claude-code:wanted:u1:0" in result.output
+    assert "rotate" in result.output
+    assert "not retained" in result.output
+    assert "do not render" not in result.output
+    assert ": Finding" not in result.output
+    assert state_path.read_bytes() == before
+
+
+@pytest.mark.parametrize("rule_id", sorted(RULE_IDS))
+def test_every_current_rule_has_readable_notification_and_findings_output(
+    rule_id: str, monkeypatch, tmp_path: Path
+) -> None:
+    path = tmp_path / "state.json"
+    monkeypatch.setenv("STACKTRACE_DAEMON_STATE", str(path))
+    (notification,) = FindingStore(path).record(
+        SessionKey("claude-code", "wanted"),
+        TranscriptFingerprint(size=1, mtime_ns=1),
+        (
+            {
+                "rule_id": rule_id,
+                "severity": "high",
+                "confidence": "high",
+                "title": "UNTRUSTED-TITLE",
+                "remediation": "UNTRUSTED-REMEDIATION",
+                "session": {"session_id": "claude-code:wanted"},
+                "evidence": [
+                    {
+                        "span": "claude-code:wanted:u1:0",
+                        "kind": "quota_exhausted"
+                        if rule_id == "stacktrace-agent-blocked"
+                        else "jwt",
+                        "detail": "RETAINED-DESCRIPTOR",
+                    }
+                ],
+            },
+        ),
+    )
+    result = CliRunner().invoke(
+        main, ["findings", "--agent-kind", "claude-code", "--session", "wanted"]
+    )
+
+    assert result.exit_code == 0
+    assert "A finding was recorded" not in notification.title
+    assert "A finding was recorded" not in result.output
+    assert "Next step:" in result.output
+    assert "RETAINED-DESCRIPTOR" in result.output
+    assert "RETAINED-DESCRIPTOR" not in notification.body + notification.title
+    assert "UNTRUSTED" not in result.output + notification.title + notification.body
+    if rule_id == "stacktrace-agent-blocked":
+        assert "spend limit" in result.output
+    elif rule_id == "stacktrace-deceptive-completion":
+        assert "success claim conflicts with verification evidence" in result.output
+
+
+def test_empty_findings_output_is_unchanged(monkeypatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("STACKTRACE_DAEMON_STATE", str(tmp_path / "missing.json"))
+    result = CliRunner().invoke(
+        main, ["findings", "--agent-kind", "claude-code", "--session", "empty"]
+    )
+    assert result.exit_code == 0
+    assert result.output == "No Stacktrace findings for this session.\n"
+
+
+def test_importing_the_root_cli_does_not_load_the_unix_daemon_runtime() -> None:
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            (
+                "import sys; import stacktrace_cli.cli; "
+                "assert 'stacktrace_cli.daemon.runtime' not in sys.modules"
+            ),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 0, result.stderr

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/tests/daemon/test_store.py

@@ -24,7 +24,7 @@ def _finding(
     }
 
 
-def test_record_persists_every_finding_and_enqueues_only_high_confidence_high_severity(
+def test_record_persists_every_finding_and_enqueues_high_confidence_medium_and_above(
     tmp_path: Path,
 ) -> None:
     store = FindingStore(tmp_path / "state.json")
@@ -42,11 +42,27 @@ def test_record_persists_every_finding_and_enqueues_only_high_confidence_high_se
                 confidence="high",
                 span="claude-code:s1:u2:0",
             ),
+            _finding(
+                "s1",
+                rule_id="stacktrace-deceptive-completion",
+                severity="low",
+                confidence="high",
+                span="claude-code:s1:u3:0",
+            ),
+            _finding(
+                "s1",
+                severity="high",
+                confidence="low",
+                span="claude-code:s1:u4:0",
+            ),
         ),
     )
 
-    assert len(store.findings(session)) == 2
-    assert [notification.rule_id for notification in created] == ["stacktrace-credential-egress"]
+    assert len(store.findings(session)) == 4
+    assert [notification.rule_id for notification in created] == [
+        "stacktrace-credential-egress",
+        "stacktrace-agent-blocked",
+    ]
     assert store.pending(session) == created
     assert store.fingerprint(session) == TranscriptFingerprint(size=100, mtime_ns=200)
 
@@ -67,6 +83,9 @@ def test_notification_text_is_owned_by_stacktrace_not_the_finding_title(tmp_path
     )
 
     rendered = f"{notification.title}\n{notification.body}"
+    assert "Credential-shaped material appeared in an outbound tool call" in rendered
+    assert "stacktrace-credential-egress" in rendered
+    assert "/stacktrace:findings" in rendered
     assert "SECRET-123" not in rendered
     stored = store.findings(session)
     assert "SECRET-123" not in repr(stored)
@@ -143,7 +162,7 @@ def test_an_existing_finding_becomes_notifiable_when_its_grade_increases(tmp_pat
         store.record(
             session,
             TranscriptFingerprint(size=1, mtime_ns=1),
-            (_finding("s1", severity="medium"),),
+            (_finding("s1", severity="low"),),
         )
         == ()
     )
@@ -151,11 +170,11 @@ def test_an_existing_finding_becomes_notifiable_when_its_grade_increases(tmp_pat
     created = store.record(
         session,
         TranscriptFingerprint(size=2, mtime_ns=2),
-        (_finding("s1", severity="high"),),
+        (_finding("s1", severity="medium"),),
     )
 
     assert len(created) == 1
-    assert store.findings(session)[0]["severity"] == "high"
+    assert store.findings(session)[0]["severity"] == "medium"
 
 
 def test_failed_persistence_does_not_advance_in_memory_state(

{stacktrace_cli-0.4.1 → stacktrace_cli-0.5.0}/uv.lock

@@ -885,7 +885,7 @@ wheels = [
 
 [[package]]
 name = "stacktrace-cli"
-version = "0.4.1"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },