cctx-cli 1.0.0__tar.gz → 1.2.0__tar.gz

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/.github/workflows/publish.yml

@@ -46,18 +46,6 @@ jobs:
 
       - name: Publish
         uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
 
-  tag-action:
-    name: Tag floating action version
-    needs: [publish]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Push floating major tag
-        run: |
-          MAJOR=$(echo "${{ github.event.release.tag_name }}" | cut -d. -f1)
-          git tag -f "$MAJOR"
-          git push origin "$MAJOR" --force

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 <!-- version list -->
 
+## v1.2.0 (2026-05-17)
+
+### Features
+
+- --until DATE, autopsy --json, export --format json (M12 #77 #78 #79)
+  ([#84](https://github.com/jacquardlabs/cctx/pull/84),
+  [`803b5f1`](https://github.com/jacquardlabs/cctx/commit/803b5f190404679ddef4cbbec7478d04c57b8413))
+
+
+## v1.1.0 (2026-05-17)
+
+### Chores
+
+- Add skip-existing to pypi publish action
+  ([`23d7e16`](https://github.com/jacquardlabs/cctx/commit/23d7e16e18074da3c25899ba98298100ad3c1ad3))
+
+### Features
+
+- M9 polish — verdict headline, --top N, --turn N
+  ([#83](https://github.com/jacquardlabs/cctx/pull/83),
+  [`b0d2f27`](https://github.com/jacquardlabs/cctx/commit/b0d2f273a373c5a2f52c9de3a3fb2721da59c4f5))
+
+- M9 polish — verdict headline, --top N, and --turn N
+  ([#83](https://github.com/jacquardlabs/cctx/pull/83),
+  [`b0d2f27`](https://github.com/jacquardlabs/cctx/commit/b0d2f273a373c5a2f52c9de3a3fb2721da59c4f5))
+
+### Refactoring
+
+- Cache verdict, fix markup=False bug, use reverse=True
+  ([#83](https://github.com/jacquardlabs/cctx/pull/83),
+  [`b0d2f27`](https://github.com/jacquardlabs/cctx/commit/b0d2f273a373c5a2f52c9de3a3fb2721da59c4f5))
+
+
 ## v1.0.0 (2026-05-17)
 
 ### Continuous Integration

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctx-cli
-Version: 1.0.0
+Version: 1.2.0
 Summary: Diagnose Claude Code sessions — find what went wrong, what it cost, and what to add to CLAUDE.md
 Author: Jacquard Labs
 License-Expression: MIT

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/cctx/__init__.py

@@ -1,3 +1,3 @@
 """cctx: profile, debug, and optimize Claude Code and Agent SDK sessions."""
 
-__version__ = "1.0.0"
+__version__ = "1.2.0"

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/cctx/cli.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
+from typing import IO
 
 import rich_click as click
 
@@ -31,6 +32,7 @@ from cctx.renderers.terminal import (
     render_harvest_results,
     render_projects,
     render_sessions,
+    render_turn,
 )
 from cctx.tokenizer import tokenize_session
 
@@ -217,6 +219,14 @@ def ls(project: Path | None) -> None:
     type=str,
     help="Cross-session mode: 7, 7d, 2w, 2026-05-01, or 2026-05-01..2026-05-15.",
 )
+@click.option(
+    "--until",
+    "until_date",
+    default=None,
+    metavar="DATE",
+    type=str,
+    help="End date for --since window (YYYY-MM-DD). Requires --since.",
+)
 @click.option(
     "--latest",
     is_flag=True,
@@ -245,13 +255,40 @@ def ls(project: Path | None) -> None:
     default=False,
     help="Exit 1 if any findings are detected (single-session only).",
 )
+@click.option(
+    "--top",
+    "top_n",
+    default=None,
+    metavar="N",
+    type=click.IntRange(min=1),
+    help="Show only the top N patterns by session count (--since mode only).",
+)
+@click.option(
+    "--turn",
+    "turn_num",
+    default=None,
+    metavar="N",
+    type=click.IntRange(min=1),
+    help="Show details for turn N (single-session only).",
+)
+@click.option(
+    "--json",
+    "json_out",
+    is_flag=True,
+    default=False,
+    help="Output diagnosis as JSON to stdout (single-session only).",
+)
 def autopsy(
     target: Path | None,
     since: str | None,
+    until_date: str | None,
     latest: bool,
     html_out: Path | None,
     github_summary: bool,
     fail_on_findings: bool,
+    top_n: int | None,
+    turn_num: int | None,
+    json_out: bool,
 ) -> None:
     """Diagnose a session or project directory.
 
@@ -267,6 +304,14 @@ def autopsy(
         raise click.UsageError("--latest and --since are mutually exclusive.")
     if fail_on_findings and since is not None:
         raise click.UsageError("--fail-on-findings is not supported with --since.")
+    if top_n is not None and since is None:
+        raise click.UsageError("--top requires --since.")
+    if turn_num is not None and since is not None:
+        raise click.UsageError("--turn is not supported with --since.")
+    if until_date is not None and since is None:
+        raise click.UsageError("--until requires --since.")
+    if json_out and since is not None:
+        raise click.UsageError("--json is not supported with --since.")
 
     if target is None:
         if not latest:
@@ -303,8 +348,20 @@ def autopsy(
         # Cross-session path
         project_dir = target if target.is_dir() else target.parent
         start, end, label = parse_since(since)
+        if until_date is not None:
+            try:
+                end = datetime.fromisoformat(until_date.strip()).replace(
+                    tzinfo=UTC, hour=23, minute=59, second=59
+                )
+            except ValueError:
+                raise click.UsageError(
+                    f"Invalid --until date '{until_date}'. Expected YYYY-MM-DD."
+                ) from None
+            label = f"{label} until {until_date.strip()}"
         diagnoses = aggregate.run(project_dir, start, end)
         ev = evidence_mod.accumulate(diagnoses)
+        if top_n is not None:
+            ev = dict(sorted(ev.items(), key=lambda x: x[1].session_count, reverse=True)[:top_n])
         patches = claude_md.generate_from_evidence(ev)
         report = AggregateReport(
             period_label=label,
@@ -327,14 +384,21 @@ def autopsy(
         trace = tokenize_session(parse_session(target))
         diagnosis = diagnostician.run(trace)
         diagnosis = claude_md.generate(diagnosis)
-        if html_out is not None:
+        if json_out:
+            import json as _json
+
+            from cctx.exporters.jsonl import export_diagnosis as _export_diag
+            click.echo(_json.dumps(_json.loads(_export_diag(diagnosis, trace)), indent=2))
+        elif turn_num is not None:
+            render_turn(trace, diagnosis, turn_num)
+        elif html_out is not None:
             from cctx.renderers.report import render_html
             html_out.write_text(render_html(diagnosis, trace), encoding="utf-8")
             click.echo(f"HTML report written to {html_out}")
-        if github_summary:
+        elif github_summary:
             from cctx.renderers.github import write_github_summary
             write_github_summary(diagnosis)
-        if html_out is None and not github_summary:
+        else:
             render_diagnosis(diagnosis, session_path=target)
         if fail_on_findings and diagnosis.findings:
             raise SystemExit(1)
@@ -345,10 +409,10 @@ def autopsy(
 @click.option(
     "--format",
     "fmt",
-    type=click.Choice(["jsonl", "csv"]),
+    type=click.Choice(["jsonl", "csv", "json"]),
     default="jsonl",
     show_default=True,
-    help="Output format: jsonl (one object per session) or csv (one row per turn).",
+    help="Output format: jsonl (one object per session), csv (one row per turn), or json (array).",
 )
 @click.option(
     "--out",
@@ -370,6 +434,7 @@ def export(target: Path, fmt: str, out: Path | None, no_content: bool) -> None:
     import sys
 
     from cctx.exporters import csv as csv_mod
+    from cctx.exporters import json as json_mod
     from cctx.exporters import jsonl as jsonl_mod
 
     trace = tokenize_session(parse_session(target))
@@ -377,16 +442,19 @@ def export(target: Path, fmt: str, out: Path | None, no_content: bool) -> None:
     diagnosis = claude_md.generate(diagnosis)
     pairs = [(diagnosis, trace)]
 
+    def _write(fh: IO[str]) -> None:
+        if fmt == "jsonl":
+            jsonl_mod.write(pairs, fh, include_content=not no_content)
+        elif fmt == "json":
+            json_mod.write(pairs, fh, include_content=not no_content)
+        else:
+            csv_mod.write(pairs, fh)
+
     if out is not None:
         with open(out, "w", encoding="utf-8") as fh:
-            if fmt == "jsonl":
-                jsonl_mod.write(pairs, fh, include_content=not no_content)
-            else:
-                csv_mod.write(pairs, fh)
-    elif fmt == "jsonl":
-        jsonl_mod.write(pairs, sys.stdout, include_content=not no_content)
+            _write(fh)
     else:
-        csv_mod.write(pairs, sys.stdout)
+        _write(sys.stdout)
 
 
 @cli.command()

cctx_cli-1.2.0/cctx/exporters/json.py

@@ -0,0 +1,23 @@
+"""JSON exporter — full session array as pretty-printed JSON."""
+from __future__ import annotations
+
+import json
+from typing import IO, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cctx.models import Diagnosis, SessionTrace
+
+from cctx.exporters.jsonl import export_diagnosis
+
+
+def write(
+    diagnoses: list[tuple[Diagnosis, SessionTrace]],
+    out: IO[str],
+    *,
+    include_content: bool = True,
+) -> None:
+    objects = [
+        json.loads(export_diagnosis(diagnosis, trace, include_content=include_content))
+        for diagnosis, trace in diagnoses
+    ]
+    out.write(json.dumps(objects, indent=2) + "\n")

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/cctx/models.py

@@ -225,6 +225,13 @@ class Diagnosis:
     waste_cost_usd:  float
     analysed_at:     datetime
 
+    @property
+    def verdict(self) -> str:
+        if not self.findings:
+            return "clean session"
+        seen = dict.fromkeys(f.kind for f in self.findings)
+        return " + ".join(KIND_LABEL[k] for k in seen)
+
 
 @dataclass
 class KindEvidence:

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/cctx/renderers/terminal.py

@@ -24,7 +24,7 @@ from cctx.models import KIND_LABEL, FindingKind, Severity
 
 if TYPE_CHECKING:
     from cctx.discovery import ProjectInfo
-    from cctx.models import AggregateReport, Diagnosis
+    from cctx.models import AggregateReport, Diagnosis, SessionTrace
 
 _SEVERITY_STYLE = {
     Severity.HIGH:   "bold red",
@@ -49,6 +49,9 @@ def render_diagnosis(
 
     # Header
     con.print(Rule(f"cctx autopsy — session {diagnosis.session_id}"))
+    verdict = diagnosis.verdict
+    verdict_style = "bold green" if not diagnosis.findings else "bold red"
+    con.print(Text(f"Verdict: {verdict}", style=verdict_style))
     cost_line = f"Session cost: ~${diagnosis.total_cost_usd:.2f}"
     if diagnosis.waste_cost_usd > 0:
         pct = (
@@ -169,6 +172,56 @@ def render_aggregate_drilldown(
         con.print("No matching findings.")
 
 
+def render_turn(
+    trace: SessionTrace,
+    diagnosis: Diagnosis,
+    turn_num: int,
+    *,
+    console: Console | None = None,
+) -> None:
+    """Render details for a single turn N from a session."""
+    con = console or _default_console()
+
+    turn = next((t for t in trace.turns if t.turn_number == turn_num), None)
+    if turn is None:
+        con.print(Text(
+            f"Turn {turn_num} not found (session has {len(trace.turns)} turns).",
+            style="red",
+        ))
+        return
+
+    con.print(Rule(f"Turn {turn_num} — {turn.role} — {turn.timestamp.strftime('%H:%M:%S')}"))
+
+    text = turn.text
+    if text:
+        preview = text[:500]
+        if len(text) > 500:
+            preview += f"\n… [{len(text) - 500} more chars]"
+        con.print(preview)
+
+    for tu in turn.tool_uses:
+        con.print(Text(f"  tool_use: {tu.tool_name}", style="cyan"))
+
+    for tr in turn.tool_results:
+        style = "red" if tr.is_error else "dim"
+        content = tr.content
+        preview = content[:200] + ("…" if len(content) > 200 else "")
+        con.print(Text(f"  tool_result ({tr.tool_name}): {preview}", style=style))
+
+    # Findings that span this turn
+    touching = [
+        f for f in diagnosis.findings
+        if f.first_turn <= turn_num <= (f.last_turn or f.first_turn)
+    ]
+    if touching:
+        con.print()
+        con.print(Text("Findings active at this turn:", style="bold"))
+        for finding in touching:
+            style = _SEVERITY_STYLE.get(finding.severity, "")
+            label = _KIND_LABEL.get(finding.kind, finding.kind.value.upper())
+            con.print(Text(f"  [{label}]", style=style), finding.summary)
+
+
 def render_harvest_results(
     results: list,  # list[ApplyResult] — ApplyStatus is harvest-internal; imported lazily
     *,

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cctx-cli"
-version = "1.0.0"
+version = "1.2.0"
 description = "Diagnose Claude Code sessions — find what went wrong, what it cost, and what to add to CLAUDE.md"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -47,6 +47,7 @@ version_toml = ["pyproject.toml:project.version"]
 version_variables = ["cctx/__init__.py:__version__"]
 tag_format = "v{version}"
 commit_message = "chore(release): v{version} [skip ci]"
+major_on_zero = false
 build_command = "pip install build && python -m build"
 upload_to_vcs_release = true
 

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/tests/test_cli.py

@@ -309,3 +309,242 @@ def test_fail_on_findings_incompatible_with_since(runner):
         ["autopsy", str(FIXTURE_PATH.parent), "--since", "7", "--fail-on-findings"],
     )
     assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# --top N tests (#75)
+# ---------------------------------------------------------------------------
+
+
+def test_top_requires_since(runner, session_jsonl):
+    """--top without --since → non-zero exit (UsageError)."""
+    from cctx.cli import cli
+
+    result = runner.invoke(cli, ["autopsy", str(session_jsonl), "--top", "3"])
+    assert result.exit_code != 0
+    assert "since" in result.output.lower() or "Error" in result.output
+
+
+def test_top_with_since_accepted(runner, tmp_path):
+    """--top N with --since → exit 0."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+    session_id = "top-test-sess"
+    line = {
+        "type": "user", "uuid": f"{session_id}-u1", "parentUuid": None,
+        "isSidechain": False, "timestamp": "2026-05-14T10:00:00.000Z",
+        "sessionId": session_id, "version": "2.1.138",
+        "cwd": "/Users/test/Projects/demo", "gitBranch": "main",
+        "userType": "external", "entrypoint": "cli",
+        "message": {"role": "user", "content": "hello"},
+    }
+    (project_dir / f"{session_id}.jsonl").write_text(json.dumps(line) + "\n")
+
+    result = runner.invoke(
+        cli, ["autopsy", str(project_dir), "--since", "7", "--top", "2"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+
+
+# ---------------------------------------------------------------------------
+# --turn N tests (#76)
+# ---------------------------------------------------------------------------
+
+
+def test_turn_incompatible_with_since(runner, tmp_path):
+    """--turn N + --since → non-zero exit (UsageError)."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+    result = runner.invoke(
+        cli, ["autopsy", str(project_dir), "--since", "7", "--turn", "3"],
+    )
+    assert result.exit_code != 0
+    assert "since" in result.output.lower() or "Error" in result.output
+
+
+def test_turn_shows_turn_details(runner, session_jsonl):
+    """--turn 1 on a session with one turn prints turn details."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["autopsy", str(session_jsonl), "--turn", "1"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    assert "Turn 1" in result.output
+
+
+def test_turn_out_of_range_shows_not_found(runner, session_jsonl):
+    """--turn 999 on a one-turn session shows 'not found' message."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["autopsy", str(session_jsonl), "--turn", "999"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    assert "not found" in result.output.lower() or "999" in result.output
+
+
+# ---------------------------------------------------------------------------
+# --until DATE tests (#77)
+# ---------------------------------------------------------------------------
+
+
+def test_until_requires_since(runner, session_jsonl):
+    """--until without --since → non-zero exit (UsageError)."""
+    from cctx.cli import cli
+
+    result = runner.invoke(cli, ["autopsy", str(session_jsonl), "--until", "2026-05-15"])
+    assert result.exit_code != 0
+    assert "since" in result.output.lower() or "Error" in result.output
+
+
+def test_until_with_since_accepted(runner, tmp_path):
+    """--until DATE + --since → exit 0."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+    session_id = "until-test-sess"
+    line = {
+        "type": "user", "uuid": f"{session_id}-u1", "parentUuid": None,
+        "isSidechain": False, "timestamp": "2026-05-14T10:00:00.000Z",
+        "sessionId": session_id, "version": "2.1.138",
+        "cwd": "/Users/test/Projects/demo", "gitBranch": "main",
+        "userType": "external", "entrypoint": "cli",
+        "message": {"role": "user", "content": "hello"},
+    }
+    (project_dir / f"{session_id}.jsonl").write_text(json.dumps(line) + "\n")
+
+    result = runner.invoke(
+        cli,
+        ["autopsy", str(project_dir), "--since", "7", "--until", "2026-05-15"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+
+
+def test_until_invalid_date(runner, tmp_path):
+    """--until with a non-date string → non-zero exit."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+
+    result = runner.invoke(
+        cli, ["autopsy", str(project_dir), "--since", "7", "--until", "not-a-date"],
+    )
+    assert result.exit_code != 0
+
+
+def test_until_label_includes_date(runner, tmp_path):
+    """--until DATE appears in the period label in aggregate output."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+    session_id = "until-label-sess"
+    line = {
+        "type": "user", "uuid": f"{session_id}-u1", "parentUuid": None,
+        "isSidechain": False, "timestamp": "2026-05-10T10:00:00.000Z",
+        "sessionId": session_id, "version": "2.1.138",
+        "cwd": "/Users/test/Projects/demo", "gitBranch": "main",
+        "userType": "external", "entrypoint": "cli",
+        "message": {"role": "user", "content": "hello"},
+    }
+    (project_dir / f"{session_id}.jsonl").write_text(json.dumps(line) + "\n")
+
+    result = runner.invoke(
+        cli,
+        ["autopsy", str(project_dir), "--since", "30", "--until", "2026-05-15"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    assert "2026-05-15" in result.output
+
+
+# ---------------------------------------------------------------------------
+# autopsy --json tests (#78)
+# ---------------------------------------------------------------------------
+
+
+def test_autopsy_json_outputs_valid_json(runner, session_jsonl):
+    """--json flag produces valid JSON on stdout."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["autopsy", str(session_jsonl), "--json"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "session_id" in data
+    assert "findings" in data
+
+
+def test_autopsy_json_incompatible_with_since(runner, tmp_path):
+    """--json + --since → non-zero exit (UsageError)."""
+    from cctx.cli import cli
+
+    project_dir = tmp_path / "-Users-test-Projects-demo"
+    project_dir.mkdir()
+
+    result = runner.invoke(
+        cli, ["autopsy", str(project_dir), "--since", "7", "--json"],
+    )
+    assert result.exit_code != 0
+
+
+def test_autopsy_json_contains_cost(runner, session_jsonl):
+    """--json output includes cost fields."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["autopsy", str(session_jsonl), "--json"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "total_cost_usd" in data
+    assert "waste_cost_usd" in data
+
+
+# ---------------------------------------------------------------------------
+# export --format json tests (#79)
+# ---------------------------------------------------------------------------
+
+
+def test_export_json_produces_valid_json(runner, session_jsonl):
+    """export --format json produces a valid JSON array."""
+    from cctx.cli import cli
+
+    result = runner.invoke(
+        cli, ["export", str(session_jsonl), "--format", "json"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert len(data) == 1
+    assert "session_id" in data[0]
+
+
+def test_export_json_to_file(runner, session_jsonl, tmp_path):
+    """export --format json --out FILE writes a valid JSON file."""
+    from cctx.cli import cli
+
+    out_path = tmp_path / "out.json"
+    result = runner.invoke(
+        cli, ["export", str(session_jsonl), "--format", "json", "--out", str(out_path)],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    data = json.loads(out_path.read_text())
+    assert isinstance(data, list)
+    assert data[0]["session_id"] == "test-sess-01"

{cctx_cli-1.0.0 → cctx_cli-1.2.0}/tests/test_models.py

@@ -643,3 +643,57 @@ def test_aggregate_report_instantiates():
     )
     assert report.sessions_analysed == 12
     assert FindingKind.RETRY_LOOP in report.by_kind
+
+
+# ---------------------------------------------------------------------------
+# Diagnosis.verdict property (#74)
+# ---------------------------------------------------------------------------
+
+
+def _make_finding_of_kind(kind, first_turn=5):
+    from cctx.models import Confidence, Finding, Severity
+    return Finding(
+        kind=kind,
+        severity=Severity.MEDIUM,
+        confidence=Confidence.MEDIUM,
+        first_turn=first_turn,
+        last_turn=None,
+        evidence={},
+        cost_usd=None,
+        summary="test",
+    )
+
+
+def _make_diag(findings):
+    from cctx.models import Diagnosis
+    return Diagnosis(
+        session_id="abc",
+        findings=findings,
+        inflection_turn=None,
+        patches=[],
+        total_cost_usd=1.0,
+        waste_cost_usd=0.0,
+        analysed_at=_utcnow(),
+    )
+
+
+def test_verdict_clean_session():
+    d = _make_diag([])
+    assert d.verdict == "clean session"
+
+
+def test_verdict_single_finding():
+    from cctx.models import FindingKind
+    d = _make_diag([_make_finding_of_kind(FindingKind.RETRY_LOOP)])
+    assert d.verdict == "RETRY LOOP"
+
+
+def test_verdict_multiple_kinds_deduped_in_order():
+    from cctx.models import FindingKind
+    findings = [
+        _make_finding_of_kind(FindingKind.SCOPE_CREEP),
+        _make_finding_of_kind(FindingKind.RETRY_LOOP),
+        _make_finding_of_kind(FindingKind.SCOPE_CREEP),  # duplicate kind
+    ]
+    d = _make_diag(findings)
+    assert d.verdict == "SCOPE CREEP + RETRY LOOP"