cctx-cli 1.15.0__tar.gz → 1.16.0__tar.gz

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 <!-- version list -->
 
+## v1.16.0 (2026-06-20)
+
+### Features
+
+- Exploration thrash classifier — detect read-heavy circling without progress (#99)
+  ([#124](https://github.com/jacquardlabs/cctx/pull/124),
+  [`21f3374`](https://github.com/jacquardlabs/cctx/commit/21f3374bb0e2c60db0411213773ad9dffca7ec1f))
+
+
 ## v1.15.0 (2026-06-20)
 
 ### Features

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctx-cli
-Version: 1.15.0
+Version: 1.16.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.15.0 → cctx_cli-1.16.0}/cctx/__init__.py

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

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/cctx/diagnostician/__init__.py

@@ -18,6 +18,7 @@ from cctx.diagnostician.patterns import (
     cache_hygiene,
     compaction,
     dead_end,
+    exploration_thrash,
     fan_out,
     retry_loop,
     scope_creep,
@@ -156,6 +157,7 @@ def run(trace: SessionTrace) -> Diagnosis:
         *fan_out.classify(trace),
         *cache_hygiene.classify(trace),
         *compaction.classify(trace),
+        *exploration_thrash.classify(trace),
     ]
     findings.sort(key=lambda f: f.first_turn)
 

cctx_cli-1.16.0/cctx/diagnostician/patterns/exploration_thrash.py

@@ -0,0 +1,192 @@
+"""Exploration-thrash classifier.
+
+Detects when the assistant circles with repeated read/search tool calls
+instead of making progress — high ratio of read-only tools to write/execute
+tools in a window, or repeated identical discovery commands, with no file
+edits or test runs in N consecutive turns.
+
+Signals:
+  1. Sliding window of WINDOW_SIZE consecutive assistant turns where ≥ 80%
+     of tool calls are read-only and no Write/Edit appears.
+  2. Any (tool_name, key) read-only pair called ≥ REPEAT_THRESHOLD times
+     across the full session.
+"""
+from __future__ import annotations
+
+import json
+from collections import Counter
+from typing import TYPE_CHECKING
+
+from cctx.models import Confidence, Finding, FindingKind, Severity
+
+if TYPE_CHECKING:
+    from cctx.models import SessionTrace
+
+WINDOW_SIZE = 6
+READ_RATIO_THRESHOLD = 0.80
+REPEAT_THRESHOLD = 3
+
+_READ_TOOLS = frozenset({"Read", "Grep", "Glob"})
+_WRITE_TOOLS = frozenset({"Write", "Edit", "NotebookEdit"})
+
+_READ_BASH_PREFIXES = (
+    "ls",
+    "find",
+    "cat",
+    "head",
+    "tail",
+    "grep",
+    "rg",
+    "ag",
+    "wc",
+    "file",
+    "stat",
+    "echo",
+    "pwd",
+    "which",
+    "type",
+    "less",
+    "git log",
+    "git diff",
+    "git show",
+    "git status",
+    "git blame",
+)
+
+
+def _is_read_only(tool_name: str, tool_input: dict) -> bool:
+    if tool_name in _READ_TOOLS:
+        return True
+    if tool_name in _WRITE_TOOLS:
+        return False
+    if tool_name == "Bash":
+        cmd = tool_input.get("command", "").lstrip()
+        return any(cmd.startswith(p) for p in _READ_BASH_PREFIXES)
+    return False
+
+
+def _tool_key(tool_name: str, tool_input: dict) -> str:
+    """Canonical key for deduplication."""
+    match tool_name:
+        case "Bash":
+            return tool_input.get("command", "").strip()
+        case "Read" | "Write" | "Edit":
+            return tool_input.get("file_path", "")
+        case "Grep" | "Glob":
+            return tool_input.get("pattern", "")
+        case _:
+            return json.dumps(tool_input, sort_keys=True)
+
+
+def _classify_impl(trace: SessionTrace) -> list[Finding]:
+    # Only look at assistant turns with tool calls
+    active_turns = [
+        t for t in trace.turns
+        if t.role == "assistant" and t.tool_uses
+    ]
+
+    thrash_windows: list[dict] = []
+
+    # Sliding window detection — requires at least WINDOW_SIZE active turns
+    for i in range(max(0, len(active_turns) - WINDOW_SIZE + 1)):
+        window = active_turns[i : i + WINDOW_SIZE]
+        all_calls = [
+            (tu.tool_name, tu.tool_input)
+            for t in window
+            for tu in t.tool_uses
+        ]
+        if not all_calls:
+            continue
+        read_count = sum(
+            1 for name, inp in all_calls if _is_read_only(name, inp)
+        )
+        ratio = read_count / len(all_calls)
+        has_write = any(name in _WRITE_TOOLS for name, _ in all_calls)
+
+        if ratio >= READ_RATIO_THRESHOLD and not has_write:
+            # Avoid double-counting overlapping windows that cover the same turns
+            if (
+                thrash_windows
+                and thrash_windows[-1]["last_turn"] >= window[0].turn_number
+            ):
+                continue
+            thrash_windows.append({
+                "first_turn": window[0].turn_number,
+                "last_turn": window[-1].turn_number,
+                "read_ratio": round(ratio, 2),
+                "total_calls": len(all_calls),
+            })
+
+    # Repeated identical reads
+    read_call_counts: Counter[str] = Counter()
+    read_call_turns: dict[str, list[int]] = {}
+    for turn in trace.turns:
+        if turn.role != "assistant":
+            continue
+        for tu in turn.tool_uses:
+            if _is_read_only(tu.tool_name, tu.tool_input):
+                key = f"{tu.tool_name}:{_tool_key(tu.tool_name, tu.tool_input)}"
+                read_call_counts[key] += 1
+                read_call_turns.setdefault(key, []).append(turn.turn_number)
+
+    repeated_reads: list[dict] = []
+    for key, count in read_call_counts.items():
+        if count >= REPEAT_THRESHOLD:
+            tool_name, _, call_key = key.partition(":")
+            repeated_reads.append({
+                "tool_name": tool_name,
+                "key": call_key[:60],
+                "count": count,
+                "turns": read_call_turns[key],
+            })
+
+    if not thrash_windows and not repeated_reads:
+        return []
+
+    severity = Severity.HIGH if thrash_windows else Severity.MEDIUM
+    confidence = Confidence.MEDIUM
+
+    parts = []
+    if thrash_windows:
+        parts.append(
+            f"{len(thrash_windows)} exploration thrash window"
+            f"{'s' if len(thrash_windows) > 1 else ''} "
+            f"(turns {thrash_windows[0]['first_turn']}–{thrash_windows[-1]['last_turn']}, "
+            f"{thrash_windows[0]['read_ratio']:.0%} read-only)"
+        )
+    if repeated_reads:
+        worst = max(repeated_reads, key=lambda r: r["count"])
+        parts.append(
+            f"{worst['tool_name']}({worst['key']!r}) called {worst['count']}× identically"
+        )
+    summary = "; ".join(parts)
+
+    all_first = min(
+        [w["first_turn"] for w in thrash_windows]
+        + [r["turns"][0] for r in repeated_reads]
+    )
+    all_last = max(
+        [w["last_turn"] for w in thrash_windows]
+        + [r["turns"][-1] for r in repeated_reads]
+    )
+
+    return [Finding(
+        kind=FindingKind.EXPLORATION_THRASH,
+        severity=severity,
+        confidence=confidence,
+        first_turn=all_first,
+        last_turn=all_last,
+        evidence={
+            "thrash_windows": thrash_windows,
+            "repeated_reads": repeated_reads,
+        },
+        cost_usd=None,
+        summary=summary,
+    )]
+
+
+def classify(trace: SessionTrace) -> list[Finding]:
+    try:
+        return _classify_impl(trace)
+    except Exception:
+        return []

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/cctx/models.py

@@ -167,27 +167,29 @@ class SessionTrace:
 
 
 class FindingKind(str, Enum):
-    RETRY_LOOP    = "retry_loop"
-    SCOPE_CREEP   = "scope_creep"
-    STALE_CONTEXT = "stale_context"
-    TOOL_THRASH   = "tool_thrash"
-    DEAD_END      = "dead_end"
-    FANOUT_WASTE  = "fanout_waste"
-    PROJECT_PATTERN = "project_pattern"
-    CACHE_HYGIENE = "cache_hygiene"
-    COMPACTION    = "compaction"
+    RETRY_LOOP         = "retry_loop"
+    SCOPE_CREEP        = "scope_creep"
+    STALE_CONTEXT      = "stale_context"
+    TOOL_THRASH        = "tool_thrash"
+    DEAD_END           = "dead_end"
+    FANOUT_WASTE       = "fanout_waste"
+    PROJECT_PATTERN    = "project_pattern"
+    CACHE_HYGIENE      = "cache_hygiene"
+    COMPACTION         = "compaction"
+    EXPLORATION_THRASH = "exploration_thrash"
 
 
 KIND_LABEL: dict[FindingKind, str] = {
-    FindingKind.RETRY_LOOP:    "RETRY LOOP",
-    FindingKind.SCOPE_CREEP:   "SCOPE CREEP",
-    FindingKind.STALE_CONTEXT: "STALE CONTEXT",
-    FindingKind.TOOL_THRASH:   "TOOL THRASH",
-    FindingKind.DEAD_END:      "DEAD END",
-    FindingKind.FANOUT_WASTE:  "FANOUT WASTE",
-    FindingKind.PROJECT_PATTERN: "PROJECT PATTERN",
-    FindingKind.CACHE_HYGIENE: "CACHE HYGIENE",
-    FindingKind.COMPACTION:    "COMPACTION",
+    FindingKind.RETRY_LOOP:         "RETRY LOOP",
+    FindingKind.SCOPE_CREEP:        "SCOPE CREEP",
+    FindingKind.STALE_CONTEXT:      "STALE CONTEXT",
+    FindingKind.TOOL_THRASH:        "TOOL THRASH",
+    FindingKind.DEAD_END:           "DEAD END",
+    FindingKind.FANOUT_WASTE:       "FANOUT WASTE",
+    FindingKind.PROJECT_PATTERN:    "PROJECT PATTERN",
+    FindingKind.CACHE_HYGIENE:      "CACHE HYGIENE",
+    FindingKind.COMPACTION:         "COMPACTION",
+    FindingKind.EXPLORATION_THRASH: "EXPLORATION THRASH",
 }
 
 # Maps FindingKind to the exact ## heading emitted by its recommender patch
@@ -195,14 +197,15 @@ KIND_LABEL: dict[FindingKind, str] = {
 # harvest.py imports this (never reaches into recommender/) so emit/sync can
 # identify cctx-managed sections without depending on the patch generator.
 MANAGED_HEADINGS: dict[FindingKind, str] = {
-    FindingKind.RETRY_LOOP:    "## Retry discipline",
-    FindingKind.SCOPE_CREEP:   "## Scope discipline",
-    FindingKind.STALE_CONTEXT: "## Context hygiene",
-    FindingKind.TOOL_THRASH:   "## Tool-call discipline",
-    FindingKind.DEAD_END:      "## Exploration discipline",
-    FindingKind.FANOUT_WASTE:  "## Fan-out discipline",
-    FindingKind.CACHE_HYGIENE: "## Cache hygiene",
-    FindingKind.COMPACTION:    "## Compaction hygiene",
+    FindingKind.RETRY_LOOP:         "## Retry discipline",
+    FindingKind.SCOPE_CREEP:        "## Scope discipline",
+    FindingKind.STALE_CONTEXT:      "## Context hygiene",
+    FindingKind.TOOL_THRASH:        "## Tool-call discipline",
+    FindingKind.DEAD_END:           "## Exploration discipline",
+    FindingKind.FANOUT_WASTE:       "## Fan-out discipline",
+    FindingKind.CACHE_HYGIENE:      "## Cache hygiene",
+    FindingKind.COMPACTION:         "## Compaction hygiene",
+    FindingKind.EXPLORATION_THRASH: "## Exploration thrash",
 }
 
 # Project-specific patterns use a heading that embeds tool+key, so the managed

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/cctx/recommender/claude_md.py

@@ -85,16 +85,28 @@ _COMPACTION_DIFF = """\
 +tool outputs once you've extracted what you need, so compaction doesn't erase
 +work-in-progress state."""
 
+_EXPLORATION_THRASH_DIFF = """\
++## Exploration thrash
++
++Before opening another file or running another search, state the specific
++question this call must answer and how the answer changes the next step. If
++you have read 6+ files without writing anything, stop and synthesise what
++you know. Never call the same read or grep more than twice with identical
++arguments — if the first two didn't help, a third won't either."""
+
 _TEMPLATES: dict[FindingKind, tuple[str, str, str]] = {
     # kind → (description, diff_body, target_file)
-    FindingKind.RETRY_LOOP:    ("Add retry discipline rule", _RETRY_LOOP_DIFF, "CLAUDE.md"),
-    FindingKind.SCOPE_CREEP:   ("Add scope discipline rule", _SCOPE_CREEP_DIFF, "CLAUDE.md"),
+    FindingKind.RETRY_LOOP: ("Add retry discipline rule", _RETRY_LOOP_DIFF, "CLAUDE.md"),
+    FindingKind.SCOPE_CREEP: ("Add scope discipline rule", _SCOPE_CREEP_DIFF, "CLAUDE.md"),
     FindingKind.STALE_CONTEXT: ("Add context hygiene rule", _STALE_CONTEXT_DIFF, "CLAUDE.md"),
-    FindingKind.TOOL_THRASH:   ("Add tool-call discipline rule", _TOOL_THRASH_DIFF, "CLAUDE.md"),
-    FindingKind.DEAD_END:      ("Add exploration discipline rule", _DEAD_END_DIFF, "CLAUDE.md"),
-    FindingKind.FANOUT_WASTE:  ("Add fan-out discipline rule", _FANOUT_WASTE_DIFF, "CLAUDE.md"),
+    FindingKind.TOOL_THRASH: ("Add tool-call discipline rule", _TOOL_THRASH_DIFF, "CLAUDE.md"),
+    FindingKind.DEAD_END: ("Add exploration discipline rule", _DEAD_END_DIFF, "CLAUDE.md"),
+    FindingKind.FANOUT_WASTE: ("Add fan-out discipline rule", _FANOUT_WASTE_DIFF, "CLAUDE.md"),
     FindingKind.CACHE_HYGIENE: ("Add cache hygiene rule", _CACHE_HYGIENE_DIFF, "CLAUDE.md"),
-    FindingKind.COMPACTION:    ("Add compaction hygiene rule", _COMPACTION_DIFF, "CLAUDE.md"),
+    FindingKind.COMPACTION: ("Add compaction hygiene rule", _COMPACTION_DIFF, "CLAUDE.md"),
+    FindingKind.EXPLORATION_THRASH: (
+        "Add exploration thrash rule", _EXPLORATION_THRASH_DIFF, "CLAUDE.md"
+    ),
 }
 
 

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cctx-cli"
-version = "1.15.0"
+version = "1.16.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"

cctx_cli-1.16.0/tests/test_exploration_thrash_classifier.py

@@ -0,0 +1,272 @@
+"""Tests for exploration_thrash classifier (issue #99)."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from cctx.models import SessionTrace, ToolResult, ToolUse, Turn, Usage
+
+_TS = datetime(2026, 6, 10, tzinfo=timezone.utc)
+_USAGE = Usage(500, 100, 0, 0, 0, None)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _read_turn(n: int, path: str = "/foo.py") -> Turn:
+    tu = ToolUse(
+        tool_name="Read",
+        tool_use_id=f"r{n}",
+        tool_input={"file_path": path},
+    )
+    tr = ToolResult(
+        tool_name="Read",
+        tool_use_id=f"r{n}",
+        content="content",
+        structured=None,
+        is_error=False,
+    )
+    return Turn(
+        turn_number=n,
+        uuid=f"t{n}",
+        parent_uuid=None,
+        role="assistant",
+        text="",
+        thinking="",
+        tool_uses=[tu],
+        tool_results=[tr],
+        usage=_USAGE,
+        model=None,
+        stop_reason="tool_use",
+        timestamp=_TS,
+        duration_ms=None,
+    )
+
+
+def _write_turn(n: int, path: str = "/foo.py") -> Turn:
+    tu = ToolUse(
+        tool_name="Edit",
+        tool_use_id=f"w{n}",
+        tool_input={"file_path": path},
+    )
+    tr = ToolResult(
+        tool_name="Edit",
+        tool_use_id=f"w{n}",
+        content="ok",
+        structured=None,
+        is_error=False,
+    )
+    return Turn(
+        turn_number=n,
+        uuid=f"t{n}",
+        parent_uuid=None,
+        role="assistant",
+        text="",
+        thinking="",
+        tool_uses=[tu],
+        tool_results=[tr],
+        usage=_USAGE,
+        model=None,
+        stop_reason="tool_use",
+        timestamp=_TS,
+        duration_ms=None,
+    )
+
+
+def _grep_turn(n: int, pattern: str = "def foo") -> Turn:
+    tu = ToolUse(
+        tool_name="Grep",
+        tool_use_id=f"g{n}",
+        tool_input={"pattern": pattern},
+    )
+    tr = ToolResult(
+        tool_name="Grep",
+        tool_use_id=f"g{n}",
+        content="match",
+        structured=None,
+        is_error=False,
+    )
+    return Turn(
+        turn_number=n,
+        uuid=f"t{n}",
+        parent_uuid=None,
+        role="assistant",
+        text="",
+        thinking="",
+        tool_uses=[tu],
+        tool_results=[tr],
+        usage=_USAGE,
+        model=None,
+        stop_reason="tool_use",
+        timestamp=_TS,
+        duration_ms=None,
+    )
+
+
+def _trace(turns: list[Turn]) -> SessionTrace:
+    return SessionTrace(
+        session_id="test-session",
+        parent_session_id=None,
+        project_path="/test",
+        cwd="/test",
+        primary_model="claude-sonnet-4-6",
+        claude_code_version="1.0",
+        turns=turns,
+        subagents=[],
+        attachments=[],
+        raw_tool_result_files=[],
+        initial_context_tokens=0,
+        tool_names_loaded=[],
+        start_time=_TS,
+        end_time=_TS,
+        source_path=Path("/test/session.jsonl"),
+        subagent_meta={},
+        warnings=[],
+        subagent_parse_errors=[],
+    )
+
+
+# ---------------------------------------------------------------------------
+# Model smoke tests
+# ---------------------------------------------------------------------------
+
+
+def test_exploration_thrash_kind_exists():
+    from cctx.models import FindingKind
+    assert FindingKind.EXPLORATION_THRASH == "exploration_thrash"
+
+
+def test_exploration_thrash_kind_label():
+    from cctx.models import KIND_LABEL, FindingKind
+    assert KIND_LABEL[FindingKind.EXPLORATION_THRASH] == "EXPLORATION THRASH"
+
+
+def test_exploration_thrash_managed_heading():
+    from cctx.models import MANAGED_HEADINGS, FindingKind
+    assert MANAGED_HEADINGS[FindingKind.EXPLORATION_THRASH] == "## Exploration thrash"
+
+
+# ---------------------------------------------------------------------------
+# Classifier tests
+# ---------------------------------------------------------------------------
+
+
+def test_too_few_active_turns_no_window_finding():
+    """Fewer than WINDOW_SIZE (6) active tool turns with no repeated calls → no finding."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    # 5 turns each reading a distinct file — not enough for a window, no repeats
+    turns = [_read_turn(i, path=f"/file{i}.py") for i in range(1, 6)]
+    assert classify(_trace(turns)) == []
+
+
+def test_all_write_turns_no_finding():
+    """6 consecutive Edit turns → no finding (no read-only ratio exceeded)."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    turns = [_write_turn(i) for i in range(1, 7)]
+    assert classify(_trace(turns)) == []
+
+
+def test_six_read_turns_fires_high_severity():
+    """6 consecutive Read turns (100% read-only, no writes) → HIGH severity finding."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+    from cctx.models import FindingKind, Severity
+
+    turns = [_read_turn(i, path=f"/file{i}.py") for i in range(1, 7)]
+    findings = classify(_trace(turns))
+
+    assert len(findings) == 1
+    f = findings[0]
+    assert f.kind is FindingKind.EXPLORATION_THRASH
+    assert f.severity is Severity.HIGH
+    assert len(f.evidence["thrash_windows"]) == 1
+    assert f.evidence["thrash_windows"][0]["read_ratio"] == 1.0
+
+
+def test_three_reads_three_writes_no_finding():
+    """3 read turns then 3 write turns — no window is all-read."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    turns = [_read_turn(i, path=f"/file{i}.py") for i in range(1, 4)]
+    turns += [_write_turn(i) for i in range(4, 7)]
+    assert classify(_trace(turns)) == []
+
+
+def test_repeated_identical_grep_fires_medium():
+    """Same Grep pattern called 3× → MEDIUM severity (repeated_reads signal only)."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+    from cctx.models import FindingKind, Severity
+
+    # Only 3 active turns → below WINDOW_SIZE=6, so no thrash window
+    # but the repeat threshold should still trigger
+    turns = [_grep_turn(i, pattern="def authenticate") for i in range(1, 4)]
+    findings = classify(_trace(turns))
+
+    assert len(findings) == 1
+    f = findings[0]
+    assert f.kind is FindingKind.EXPLORATION_THRASH
+    assert f.severity is Severity.MEDIUM
+    assert f.evidence["thrash_windows"] == []
+    assert len(f.evidence["repeated_reads"]) == 1
+    assert f.evidence["repeated_reads"][0]["count"] == 3
+    assert f.evidence["repeated_reads"][0]["tool_name"] == "Grep"
+
+
+def test_window_with_one_write_among_reads_no_finding():
+    """6 turns where 1 is a write (17% write) — below 80% read threshold → no window finding."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    # 5 reads + 1 write = 83% read, but has_write is True → should NOT fire
+    turns = [_read_turn(i, path=f"/f{i}.py") for i in range(1, 6)]
+    turns.append(_write_turn(6))
+    assert classify(_trace(turns)) == []
+
+
+def test_summary_contains_ratio():
+    """Finding summary includes the read-only percentage."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    turns = [_read_turn(i, path=f"/file{i}.py") for i in range(1, 7)]
+    findings = classify(_trace(turns))
+
+    assert len(findings) == 1
+    assert "100%" in findings[0].summary
+
+
+def test_first_last_turn_span():
+    """first_turn and last_turn correctly span the thrash window."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    turns = [_read_turn(i, path=f"/file{i}.py") for i in range(1, 7)]
+    findings = classify(_trace(turns))
+
+    assert findings[0].first_turn == 1
+    assert findings[0].last_turn == 6
+
+
+def test_no_tool_calls_no_finding():
+    """Turns with no tool_uses are ignored; session with only text turns → no finding."""
+    from cctx.diagnostician.patterns.exploration_thrash import classify
+
+    def _text_turn(n: int) -> Turn:
+        return Turn(
+            turn_number=n,
+            uuid=f"t{n}",
+            parent_uuid=None,
+            role="assistant",
+            text="thinking...",
+            thinking="",
+            tool_uses=[],
+            tool_results=[],
+            usage=_USAGE,
+            model=None,
+            stop_reason="end_turn",
+            timestamp=_TS,
+            duration_ms=None,
+        )
+
+    turns = [_text_turn(i) for i in range(1, 10)]
+    assert classify(_trace(turns)) == []

{cctx_cli-1.15.0 → cctx_cli-1.16.0}/tests/test_harvest_emit.py

@@ -5,14 +5,15 @@ from __future__ import annotations
 def test_managed_headings_cover_the_diagnostic_kinds():
     from cctx.models import MANAGED_HEADINGS, FindingKind
     assert MANAGED_HEADINGS == {
-        FindingKind.RETRY_LOOP:    "## Retry discipline",
-        FindingKind.SCOPE_CREEP:   "## Scope discipline",
-        FindingKind.STALE_CONTEXT: "## Context hygiene",
-        FindingKind.TOOL_THRASH:   "## Tool-call discipline",
-        FindingKind.DEAD_END:      "## Exploration discipline",
-        FindingKind.FANOUT_WASTE:  "## Fan-out discipline",
-        FindingKind.CACHE_HYGIENE: "## Cache hygiene",
-        FindingKind.COMPACTION:    "## Compaction hygiene",
+        FindingKind.RETRY_LOOP:         "## Retry discipline",
+        FindingKind.SCOPE_CREEP:        "## Scope discipline",
+        FindingKind.STALE_CONTEXT:      "## Context hygiene",
+        FindingKind.TOOL_THRASH:        "## Tool-call discipline",
+        FindingKind.DEAD_END:           "## Exploration discipline",
+        FindingKind.FANOUT_WASTE:       "## Fan-out discipline",
+        FindingKind.CACHE_HYGIENE:      "## Cache hygiene",
+        FindingKind.COMPACTION:         "## Compaction hygiene",
+        FindingKind.EXPLORATION_THRASH: "## Exploration thrash",
     }