cctx-cli 1.6.0__tar.gz → 1.7.0__tar.gz

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 <!-- version list -->
 
+## v1.7.0 (2026-06-11)
+
+### Bug Fixes
+
+- Jsonl exporter — subagent_costs in dict literal; fix import sort
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+- Remove unused ToolResult import in test_diagnostician_subagents
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+### Documentation
+
+- Restore billing-rate explanation in _compute_own_cost
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+### Features
+
+- Diagnostician — inclusive cost + per-subagent attribution
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+- HTML report + JSON exporter — subagent_costs output
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+- Per-subagent cost attribution in autopsy (#88)
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+- SubagentAttribution model + Diagnosis.subagent_costs field
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+- Terminal renderer — subagent cost table in autopsy output
+  ([#109](https://github.com/jacquardlabs/cctx/pull/109),
+  [`d1bc0fa`](https://github.com/jacquardlabs/cctx/commit/d1bc0fa039070ecfa671f38f5c43c864ed17e61a))
+
+
 ## v1.6.0 (2026-06-10)
 
 ### Bug Fixes

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctx-cli
-Version: 1.6.0
+Version: 1.7.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.6.0 → cctx_cli-1.7.0}/cctx/__init__.py

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

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/cctx/diagnostician/__init__.py

@@ -1,9 +1,9 @@
 """Autopsy diagnostician — public entry point.
 
 run(trace) -> Diagnosis
-  Runs all three pattern classifiers, detects inflection turn,
-  patches cost attribution for stale_context findings, and returns
-  a Diagnosis with patches=[].
+  Runs all pattern classifiers, detects inflection turn,
+  patches stale_context cost attribution, and returns
+  a Diagnosis with patches=[] and subagent_costs populated.
 
 The Recommender (cctx.recommender.claude_md) populates patches.
 """
@@ -21,7 +21,7 @@ from cctx.diagnostician.patterns import (
     stale_context,
     tool_thrash,
 )
-from cctx.models import Diagnosis, Finding, FindingKind
+from cctx.models import Diagnosis, Finding, FindingKind, SubagentAttribution
 from cctx.pricing import price_per_tok as _price_per_tok
 
 if TYPE_CHECKING:
@@ -41,8 +41,8 @@ def _patch_costs(findings: list[Finding], model: str | None) -> list[Finding]:
     return result
 
 
-def _compute_total_cost(trace: SessionTrace, model: str | None) -> float:
-    """Approximate total session cost including cache reads and writes.
+def _compute_own_cost(trace: SessionTrace, model: str | None) -> float:
+    """Parent-turns-only cost — does not recurse into subagents.
 
     Billing rates relative to base input price:
       cache_read:  ×0.10  (read from prompt cache)
@@ -59,6 +59,50 @@ def _compute_total_cost(trace: SessionTrace, model: str | None) -> float:
     return round(total, 4)
 
 
+def _compute_inclusive_cost(trace: SessionTrace) -> float:
+    """Recursive cost: own turns + all subagent turns at every depth."""
+    own = _compute_own_cost(trace, trace.primary_model)
+    return own + sum(_compute_inclusive_cost(sa) for sa in trace.subagents)
+
+
+def _build_label_map(trace: SessionTrace) -> dict[str, str]:
+    """Map child session_id → display label from the parent's Agent ToolUse inputs."""
+    label_map: dict[str, str] = {}
+    for turn in trace.turns:
+        for tu in turn.tool_uses:
+            if tu.subagent_session_id:
+                ti = tu.tool_input
+                label_map[tu.subagent_session_id] = (
+                    ti.get("description")
+                    or (ti.get("prompt") or "")[:80]
+                    or tu.subagent_session_id[:12]
+                )
+    return label_map
+
+
+def _collect_attributions(
+    trace: SessionTrace,
+    depth: int = 1,
+    label_map: dict[str, str] | None = None,
+) -> list[SubagentAttribution]:
+    """Flat DFS list of SubagentAttribution, one per subagent at every depth."""
+    if label_map is None:
+        label_map = _build_label_map(trace)
+    result: list[SubagentAttribution] = []
+    for child in trace.subagents:
+        label = label_map.get(child.session_id, child.session_id[:12])
+        cost = _compute_inclusive_cost(child)
+        result.append(SubagentAttribution(
+            session_id=child.session_id,
+            label=label,
+            total_cost_usd=round(cost, 4),
+            depth=depth,
+            model=child.primary_model,
+        ))
+        result.extend(_collect_attributions(child, depth + 1, None))
+    return result
+
+
 def run(trace: SessionTrace) -> Diagnosis:
     """Diagnose a single SessionTrace. Returns Diagnosis with patches=[]."""
     findings: list[Finding] = [
@@ -73,11 +117,12 @@ def run(trace: SessionTrace) -> Diagnosis:
     inflection_turn = inflection.detect(findings)
     findings = _patch_costs(findings, trace.primary_model)
 
-    total_cost = _compute_total_cost(trace, trace.primary_model)
+    total_cost = round(_compute_inclusive_cost(trace), 4)
     waste_cost = sum(f.cost_usd for f in findings if f.cost_usd is not None)
-    # Waste cannot exceed total session cost — cap as a logical invariant.
     waste_cost = min(waste_cost, total_cost)
 
+    subagent_costs = _collect_attributions(trace)
+
     return Diagnosis(
         session_id=trace.session_id,
         findings=findings,
@@ -86,4 +131,5 @@ def run(trace: SessionTrace) -> Diagnosis:
         total_cost_usd=total_cost,
         waste_cost_usd=round(waste_cost, 4),
         analysed_at=datetime.now(UTC),
+        subagent_costs=subagent_costs,
     )

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/cctx/exporters/jsonl.py

@@ -50,6 +50,16 @@ def export_diagnosis(
         "patches": patches,
         "turn_count": len(trace.turns),
         "model": trace.primary_model,
+        "subagent_costs": [
+            {
+                "session_id": a.session_id,
+                "label":      a.label,
+                "cost_usd":   a.total_cost_usd,
+                "depth":      a.depth,
+                "model":      a.model,
+            }
+            for a in diagnosis.subagent_costs
+        ],
     }
     return json.dumps(obj)
 

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/cctx/models.py

@@ -233,6 +233,17 @@ class Patch:
     evidence_summary: str
 
 
+@dataclass
+class SubagentAttribution:
+    """Cost attribution for a single subagent session."""
+
+    session_id:     str
+    label:          str        # from Agent tool_input['description'], else prompt[:80]
+    total_cost_usd: float      # inclusive: this subagent + its own children
+    depth:          int        # 1 = direct child, 2 = grandchild, …
+    model:          str | None
+
+
 @dataclass
 class Diagnosis:
     session_id:      str
@@ -242,6 +253,7 @@ class Diagnosis:
     total_cost_usd:  float
     waste_cost_usd:  float
     analysed_at:     datetime
+    subagent_costs:  list[SubagentAttribution] = field(default_factory=list)
 
     @property
     def verdict(self) -> str:

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/cctx/renderers/templates/autopsy.html.j2

@@ -176,6 +176,21 @@ footer {
       <dt>Waste attributed</dt><dd>~${{ "%.2f"|format(diag.waste_cost_usd) }}</dd>
       {% if diag.inflection_turn is not none %}<dt>Inflection turn</dt><dd>{{ diag.inflection_turn }}</dd>{% endif %}
     </dl>
+    {% if diag.subagent_costs %}
+    <details class="subagent-costs">
+      <summary>Subagents: {{ diag.subagent_costs | selectattr("depth", "equalto", 1) | list | length }} — ${{ "%.3f" % (diag.subagent_costs | selectattr("depth", "equalto", 1) | map(attribute="total_cost_usd") | sum) }}</summary>
+      <table>
+        <tr><th>Label</th><th>Depth</th><th>Cost</th></tr>
+        {% for a in diag.subagent_costs %}
+        <tr>
+          <td>{{ a.label | truncate(80) }}</td>
+          <td>{{ a.depth }}</td>
+          <td>${{ "%.3f" % a.total_cost_usd }}</td>
+        </tr>
+        {% endfor %}
+      </table>
+    </details>
+    {% endif %}
     <p class="meta">Costs are estimates (~85–95% of actual billing; system framing not observable in JSONL)</p>
     <p class="meta">Analysed {{ diag.analysed_at.strftime("%Y-%m-%d %H:%M UTC") }}</p>
   </div>

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/cctx/renderers/terminal.py

@@ -52,7 +52,13 @@ def render_diagnosis(
     verdict = diagnosis.verdict
     verdict_style = "bold green" if not diagnosis.findings else "bold red"
     con.print(Text(f"Verdict: {verdict}", style=verdict_style))
+    subagent_sum = sum(a.total_cost_usd for a in diagnosis.subagent_costs if a.depth == 1)
+    n_sub = len([a for a in diagnosis.subagent_costs if a.depth == 1])
     cost_line = f"Session cost: ~${diagnosis.total_cost_usd:.2f}"
+    if n_sub:
+        cost_line += (
+            f" (includes {n_sub} subagent{'s' if n_sub != 1 else ''}: ~${subagent_sum:.2f})"
+        )
     if diagnosis.waste_cost_usd > 0:
         pct = (
             diagnosis.waste_cost_usd / diagnosis.total_cost_usd * 100
@@ -65,6 +71,22 @@ def render_diagnosis(
         "~85–95% of actual billing; system framing not observable in JSONL", style="dim"
     ))
 
+    if diagnosis.subagent_costs:
+        show_depth = any(a.depth > 1 for a in diagnosis.subagent_costs)
+        tbl = Table(show_header=True, header_style="bold", box=None, padding=(0, 1))
+        tbl.add_column("Subagent", no_wrap=False, max_width=48)
+        if show_depth:
+            tbl.add_column("Depth", justify="right", width=6)
+        tbl.add_column("Cost", justify="right", width=8)
+        for a in diagnosis.subagent_costs:
+            label = a.label if len(a.label) <= 45 else a.label[:44] + "…"
+            cost_cell = f"${a.total_cost_usd:.3f}"
+            if show_depth:
+                tbl.add_row(label, str(a.depth), cost_cell)
+            else:
+                tbl.add_row(label, cost_cell)
+        con.print(tbl)
+
     if not diagnosis.findings:
         con.print("\nNo findings — session looks clean.")
         return

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cctx-cli"
-version = "1.6.0"
+version = "1.7.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.6.0 → cctx_cli-1.7.0}/tests/exporters/test_jsonl.py

@@ -229,6 +229,43 @@ def test_write_produces_one_line_per_session() -> None:
     assert ids == {"sess-001", "sess-002"}
 
 
+def test_export_diagnosis_includes_subagent_costs() -> None:
+    """JSON export includes subagent_costs array with correct fields."""
+    import dataclasses
+    import json
+
+    from cctx.exporters.jsonl import export_diagnosis
+    from cctx.models import SubagentAttribution
+
+    diag = _make_diagnosis()
+    trace = _make_trace()
+    diag = dataclasses.replace(diag, subagent_costs=[
+        SubagentAttribution(
+            session_id="child-1",
+            label="My task",
+            total_cost_usd=0.020,
+            depth=1,
+            model="claude-sonnet-4",
+        )
+    ])
+    data = json.loads(export_diagnosis(diag, trace))
+    assert "subagent_costs" in data
+    assert len(data["subagent_costs"]) == 1
+    assert data["subagent_costs"][0]["session_id"] == "child-1"
+    assert data["subagent_costs"][0]["cost_usd"] == pytest.approx(0.020)
+    assert data["subagent_costs"][0]["depth"] == 1
+
+
+def test_export_diagnosis_subagent_costs_empty_by_default() -> None:
+    """JSON export has subagent_costs: [] when no subagents."""
+    from cctx.exporters.jsonl import export_diagnosis
+
+    diag = _make_diagnosis()
+    trace = _make_trace()
+    data = json.loads(export_diagnosis(diag, trace))
+    assert data["subagent_costs"] == []
+
+
 def test_write_empty_list_produces_no_output() -> None:
     """write() with an empty list produces no output."""
     from cctx.exporters.jsonl import write

{cctx_cli-1.6.0 → cctx_cli-1.7.0}/tests/renderers/test_report.py

@@ -266,6 +266,29 @@ def test_autopsy_html_flag_writes_file(tmp_path):
     assert session_id in content
 
 
+def test_html_includes_subagent_costs():
+    """HTML output contains subagent label and cost when subagent_costs present."""
+    import dataclasses
+
+    from cctx.models import SubagentAttribution
+    from cctx.renderers.report import render_html
+
+    diag = _make_diagnosis()
+    trace = _simple_trace()
+    diag = dataclasses.replace(diag, subagent_costs=[
+        SubagentAttribution(
+            session_id="child-1",
+            label="Analyze the database schema",
+            total_cost_usd=0.025,
+            depth=1,
+            model="claude-sonnet-4",
+        )
+    ])
+    html = render_html(diag, trace)
+    assert "Analyze the database schema" in html
+    assert "0.025" in html
+
+
 def test_autopsy_html_with_since_errors(tmp_path):
     """--html and --since together should error, not silently ignore --html."""
 

cctx_cli-1.7.0/tests/test_diagnostician_subagents.py

@@ -0,0 +1,298 @@
+"""Tests for per-subagent cost attribution (M16 #88)."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from cctx.models import Diagnosis, SessionTrace, ToolUse, Turn, Usage
+
+# ---------------------------------------------------------------------------
+# Helpers — synthetic trace builders (real fixtures have scrubbed tokens)
+# ---------------------------------------------------------------------------
+
+_TS = datetime(2026, 6, 10, tzinfo=timezone.utc)
+
+
+def _make_usage(input_tokens: int) -> Usage:
+    return Usage(
+        input_tokens=input_tokens,
+        output_tokens=50,
+        cache_creation_5m=0,
+        cache_creation_1h=0,
+        cache_read=0,
+        service_tier=None,
+    )
+
+
+def _make_trace(
+    session_id: str,
+    input_tokens: int,
+    *,
+    subagents: list[SessionTrace] | None = None,
+    model: str = "claude-sonnet-4",
+    tool_uses: list[ToolUse] | None = None,
+) -> SessionTrace:
+    turn = Turn(
+        turn_number=1,
+        uuid="u1",
+        parent_uuid=None,
+        role="assistant",
+        text="ok",
+        thinking="",
+        tool_uses=tool_uses or [],
+        tool_results=[],
+        usage=_make_usage(input_tokens),
+        model=model,
+        stop_reason="end_turn",
+        timestamp=_TS,
+        duration_ms=None,
+    )
+    return SessionTrace(
+        session_id=session_id,
+        parent_session_id=None,
+        project_path="/p",
+        cwd="/p",
+        primary_model=model,
+        claude_code_version=None,
+        turns=[turn],
+        subagents=subagents or [],
+        attachments=[],
+        raw_tool_result_files=[],
+        initial_context_tokens=0,
+        tool_names_loaded=[],
+        start_time=_TS,
+        end_time=_TS,
+        source_path=Path(f"/p/{session_id}.jsonl"),
+        subagent_meta={},
+        warnings=[],
+        subagent_parse_errors=[],
+    )
+
+
+def _agent_tu(
+    session_id: str,
+    *,
+    description: str = "",
+    prompt: str = "",
+) -> ToolUse:
+    """Construct an Agent ToolUse linked to a child session."""
+    ti: dict = {"prompt": prompt}
+    if description:
+        ti["description"] = description
+    return ToolUse(
+        tool_name="Agent",
+        tool_use_id=f"tu_{session_id}",
+        tool_input=ti,
+        subagent_session_id=session_id,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+def test_no_subagents_cost_unchanged():
+    """With no subagents, total_cost_usd equals parent-only cost and subagent_costs is empty."""
+    from cctx.diagnostician import run
+    trace = _make_trace("parent", input_tokens=5_000)
+    diag = run(trace)
+    assert diag.subagent_costs == []
+    # parent has 5000 input tokens at sonnet-4 price ($3/Mtok) = $0.0150
+    assert abs(diag.total_cost_usd - 0.0150) < 0.001
+
+
+def test_subagent_attribution_dataclass_exists():
+    from cctx.models import SubagentAttribution
+    a = SubagentAttribution(
+        session_id="child-1",
+        label="my label",
+        total_cost_usd=0.05,
+        depth=1,
+        model="claude-sonnet-4",
+    )
+    assert a.session_id == "child-1"
+    assert a.label == "my label"
+    assert a.depth == 1
+
+
+def test_one_subagent_cost_inclusive():
+    """total_cost_usd includes direct child's cost."""
+    from cctx.diagnostician import run
+    child = _make_trace("child-1", input_tokens=10_000)
+    parent = _make_trace("parent", input_tokens=5_000, subagents=[child])
+    diag = run(parent)
+    # parent: 5000 * 3/1e6 = 0.015; child: 10000 * 3/1e6 = 0.030; total = 0.045
+    assert abs(diag.total_cost_usd - 0.045) < 0.001
+    assert len(diag.subagent_costs) == 1
+    assert diag.subagent_costs[0].session_id == "child-1"
+
+
+def test_nested_subagents_cost_inclusive():
+    """total_cost_usd sums all levels (parent + child + grandchild)."""
+    from cctx.diagnostician import run
+    grandchild = _make_trace("grand", input_tokens=5_000)
+    child = _make_trace("child", input_tokens=10_000, subagents=[grandchild])
+    parent = _make_trace("parent", input_tokens=5_000, subagents=[child])
+    diag = run(parent)
+    # 5000 + 10000 + 5000 = 20000 tokens * 3/1e6 = 0.060
+    assert abs(diag.total_cost_usd - 0.060) < 0.001
+    assert len(diag.subagent_costs) == 2
+
+
+def test_attribution_depth_1():
+    """Direct child has depth == 1."""
+    from cctx.diagnostician import run
+    child = _make_trace("child-1", input_tokens=1_000)
+    parent = _make_trace("parent", input_tokens=1_000, subagents=[child])
+    diag = run(parent)
+    assert diag.subagent_costs[0].depth == 1
+
+
+def test_attribution_depth_2():
+    """Grandchild has depth == 2."""
+    from cctx.diagnostician import run
+    grandchild = _make_trace("grand", input_tokens=1_000)
+    child = _make_trace("child", input_tokens=1_000, subagents=[grandchild])
+    parent = _make_trace("parent", input_tokens=1_000, subagents=[child])
+    diag = run(parent)
+    depths = {a.session_id: a.depth for a in diag.subagent_costs}
+    assert depths["child"] == 1
+    assert depths["grand"] == 2
+
+
+def test_attribution_label_from_description():
+    """Label comes from Agent tool_input['description'] when present."""
+    from cctx.diagnostician import run
+    child = _make_trace("child-1", input_tokens=1_000)
+    tu = _agent_tu("child-1", description="Explore the codebase", prompt="Do something long")
+    parent = _make_trace("parent", input_tokens=1_000, subagents=[child], tool_uses=[tu])
+    diag = run(parent)
+    assert diag.subagent_costs[0].label == "Explore the codebase"
+
+
+def test_attribution_label_from_prompt_fallback():
+    """When no 'description', label is prompt[:80]."""
+    from cctx.diagnostician import run
+    child = _make_trace("child-1", input_tokens=1_000)
+    long_prompt = "A" * 200
+    tu = _agent_tu("child-1", prompt=long_prompt)
+    parent = _make_trace("parent", input_tokens=1_000, subagents=[child], tool_uses=[tu])
+    diag = run(parent)
+    assert diag.subagent_costs[0].label == long_prompt[:80]
+
+
+def test_attribution_label_orphan_fallback():
+    """Unlinked subagent (no matching ToolUse) gets session_id[:12] as label."""
+    from cctx.diagnostician import run
+    child = _make_trace("child-unlinked-session", input_tokens=1_000)
+    # Parent has no Agent ToolUse linking to this child
+    parent = _make_trace("parent", input_tokens=1_000, subagents=[child])
+    diag = run(parent)
+    assert diag.subagent_costs[0].label == "child-unlink"  # first 12 chars
+
+
+def test_subagent_cost_no_double_count():
+    """Two direct subagents: total equals parent + child1 + child2."""
+    from cctx.diagnostician import run
+    child1 = _make_trace("c1", input_tokens=10_000)
+    child2 = _make_trace("c2", input_tokens=20_000)
+    parent = _make_trace("parent", input_tokens=5_000, subagents=[child1, child2])
+    diag = run(parent)
+    expected = (5_000 + 10_000 + 20_000) * 3 / 1_000_000
+    assert abs(diag.total_cost_usd - expected) < 0.001
+    assert len(diag.subagent_costs) == 2
+
+
+def test_total_cost_not_less_than_depth1_sum():
+    """Invariant: total_cost >= sum of direct-child costs."""
+    from cctx.diagnostician import run
+    child1 = _make_trace("c1", input_tokens=10_000)
+    child2 = _make_trace("c2", input_tokens=20_000)
+    parent = _make_trace("parent", input_tokens=5_000, subagents=[child1, child2])
+    diag = run(parent)
+    depth1_sum = sum(a.total_cost_usd for a in diag.subagent_costs if a.depth == 1)
+    assert diag.total_cost_usd >= depth1_sum
+
+
+# ---------------------------------------------------------------------------
+# Renderer tests
+# ---------------------------------------------------------------------------
+
+def _make_diagnosis_with_subagents(n: int = 2) -> Diagnosis:
+    from cctx.models import Diagnosis, SubagentAttribution
+    attributions = [
+        SubagentAttribution(
+            session_id=f"child-{i}",
+            label=f"Task {i}: do something useful",
+            total_cost_usd=round(0.010 * (i + 1), 4),
+            depth=1,
+            model="claude-sonnet-4",
+        )
+        for i in range(n)
+    ]
+    return Diagnosis(
+        session_id="parent-session",
+        findings=[],
+        inflection_turn=None,
+        patches=[],
+        total_cost_usd=round(0.030 + sum(a.total_cost_usd for a in attributions), 4),
+        waste_cost_usd=0.0,
+        analysed_at=_TS,
+        subagent_costs=attributions,
+    )
+
+
+def test_render_diagnosis_shows_subagent_summary():
+    """Cost line mentions subagent count and sum when subagents present."""
+    from io import StringIO
+
+    from rich.console import Console
+
+    from cctx.renderers.terminal import render_diagnosis
+    buf = StringIO()
+    con = Console(file=buf, no_color=True, width=120)
+    diag = _make_diagnosis_with_subagents(2)
+    render_diagnosis(diag, console=con)
+    out = buf.getvalue()
+    assert "2 subagent" in out
+    assert "$0.03" in out  # subagent sum = 0.010 + 0.020 = 0.030
+
+
+def test_render_diagnosis_shows_subagent_table():
+    """Subagent table lists each agent's label and cost."""
+    from io import StringIO
+
+    from rich.console import Console
+
+    from cctx.renderers.terminal import render_diagnosis
+    buf = StringIO()
+    con = Console(file=buf, no_color=True, width=120)
+    diag = _make_diagnosis_with_subagents(2)
+    render_diagnosis(diag, console=con)
+    out = buf.getvalue()
+    assert "Task 0: do something useful" in out
+    assert "Task 1: do something useful" in out
+
+
+def test_render_diagnosis_no_subagents_no_table():
+    """When subagent_costs is empty, no subagent table is shown."""
+    from io import StringIO
+
+    from rich.console import Console
+
+    from cctx.models import Diagnosis
+    from cctx.renderers.terminal import render_diagnosis
+    buf = StringIO()
+    con = Console(file=buf, no_color=True, width=120)
+    diag = Diagnosis(
+        session_id="s1",
+        findings=[],
+        inflection_turn=None,
+        patches=[],
+        total_cost_usd=0.05,
+        waste_cost_usd=0.0,
+        analysed_at=_TS,
+    )
+    render_diagnosis(diag, console=con)
+    out = buf.getvalue()
+    assert "subagent" not in out.lower()