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

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

@@ -2,6 +2,106 @@
 
 <!-- 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
+
+- Harvest — preview_patches dedup per (target, heading) not heading-only
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Harvest — shorten local-import comment under 100-char line limit
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+### Documentation
+
+- Harvest — correct misleading local-import comment
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Spec deviation note (sync returns patches) + PRODUCT.md cross-agent emit row
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+### Features
+
+- Cctx harvest --emit — cross-agent layer to AGENTS.md (#82)
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Cli — harvest --emit / --sync cross-agent emit
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Harvest — EMIT_TARGETS + retarget_patches (fan-out to AGENTS.md)
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Harvest — sync_managed_sections backfills CLAUDE.md into emit target
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Models — MANAGED_HEADINGS registry for cctx-owned CLAUDE.md sections
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+### Testing
+
+- Emit + sync idempotency through apply_patches
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- End-to-end fan-out to both targets; spec: reconcile sync error contract
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Lock MANAGED_HEADINGS registry to recommender templates
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+
 ## v1.5.1 (2026-06-10)
 
 ### Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctx-cli
-Version: 1.5.1
+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.5.1 → cctx_cli-1.7.0}/PRODUCT.md

@@ -76,6 +76,7 @@ Six commands (`ls`, `autopsy`, `harvest`, `watch`, `trace`, `export`). No comman
 | Memory-hygiene depth | `harvest --check` + `--check-severity` | v1.4.0 (M13) |
 | Live session badges | `cctx ls` | unreleased |
 | Live session detection, early idle exit | `cctx watch` | unreleased |
+| Cross-agent emit | `cctx harvest --emit agents [--sync]` | M15; mirror CLAUDE.md sections to AGENTS.md — unreleased |
 
 ### Pattern classifiers (v1.4.0)
 

{cctx_cli-1.5.1 → 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.5.1"
+__version__ = "1.7.0"

{cctx_cli-1.5.1 → cctx_cli-1.7.0}/cctx/cli.py

@@ -23,6 +23,7 @@ from cctx.agents import live_sessions as _live_sessions
 from cctx.diagnostician import aggregate
 from cctx.diagnostician.patterns import project_specific
 from cctx.discovery import complete_project as _complete_project
+from cctx.harvest import EMIT_TARGETS
 from cctx.models import KIND_LABEL, AggregateReport
 from cctx.parsers.claude_code import parse_session
 from cctx.recommender import claude_md
@@ -570,6 +571,22 @@ def trace(target: Path | None, latest: bool) -> None:
     show_default=True,
     help="Minimum severity that causes --check to exit 1.",
 )
+@click.option(
+    "--emit",
+    "emit_targets",
+    multiple=True,
+    type=click.Choice(list(EMIT_TARGETS)),
+    help="Also write applicable patches to another agent's instruction file "
+         "(e.g. AGENTS.md). Repeatable.",
+)
+@click.option(
+    "--sync",
+    "sync_mode",
+    is_flag=True,
+    default=False,
+    help="With --emit: also mirror already-harvested cctx-managed sections "
+         "from CLAUDE.md into the emit target.",
+)
 def harvest(
     target: Path,
     since: str | None,
@@ -578,9 +595,20 @@ def harvest(
     target_dir: Path | None,
     check_mode: bool,
     check_severity: str,
+    emit_targets: tuple[str, ...],
+    sync_mode: bool,
 ) -> None:
     """Apply autopsy patches to CLAUDE.md."""
-    from cctx.harvest import apply_patches, check_claude_md, preview_patches
+    from cctx.harvest import (
+        apply_patches,
+        check_claude_md,
+        preview_patches,
+        retarget_patches,
+        sync_managed_sections,
+    )
+
+    if sync_mode and not emit_targets:
+        raise click.UsageError("--sync requires --emit.")
 
     if check_mode:
         from cctx.harvest import CheckSeverity
@@ -626,6 +654,13 @@ def harvest(
         diagnosis = claude_md.generate(diagnosis)
         patches = diagnosis.patches
 
+    base = patches
+    for t in emit_targets:
+        emitted = retarget_patches(base, t)
+        if sync_mode:
+            emitted = emitted + sync_managed_sections(resolved_dir, t)
+        patches = patches + emitted
+
     if not patches:
         render_harvest_results([], dry_run=dry_run)
         return

{cctx_cli-1.5.1 → 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.5.1 → 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.5.1 → cctx_cli-1.7.0}/cctx/harvest.py

@@ -13,6 +13,7 @@ Layering rules (MUST respect):
 """
 from __future__ import annotations
 
+import dataclasses
 import re
 from collections import defaultdict
 from dataclasses import dataclass
@@ -20,6 +21,8 @@ from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from cctx.models import MANAGED_HEADING_PREFIX, MANAGED_HEADINGS
+
 if TYPE_CHECKING:
     from cctx.models import Patch
 
@@ -105,6 +108,70 @@ def _is_supported_target(patch: Patch) -> bool:
 # Public API
 # ---------------------------------------------------------------------------
 
+# Maps an --emit target name to the destination filename. Single place to add
+# future targets (Cursor, Windsurf, Copilot) when demand exists.
+EMIT_TARGETS: dict[str, str] = {
+    "agents": "AGENTS.md",
+}
+
+
+def retarget_patches(patches: list[Patch], emit_target: str) -> list[Patch]:
+    """Clone CLAUDE.md-targeted patches to the emit target's file.
+
+    Only patches whose target_file is exactly "CLAUDE.md" are emitted —
+    .claude/rules/ and .claude/skills/ patches are Claude Code-specific and do
+    not translate to other agents. Returns clones; inputs are unmodified.
+    """
+    dest = EMIT_TARGETS[emit_target]
+    return [
+        dataclasses.replace(p, target_file=dest)
+        for p in patches
+        if p.target_file == "CLAUDE.md"
+    ]
+
+
+# Reverse map: exact managed heading -> the FindingKind that owns it.
+_HEADING_TO_KIND = {heading: kind for kind, heading in MANAGED_HEADINGS.items()}
+
+
+def sync_managed_sections(target_dir: Path, emit_target: str) -> list[Patch]:
+    """Build synthetic patches mirroring CLAUDE.md's cctx-managed sections.
+
+    Reads CLAUDE.md in target_dir, keeps sections whose heading is an exact
+    MANAGED_HEADINGS value or starts with MANAGED_HEADING_PREFIX, and returns
+    one Patch per kept section targeting the emit file. Returns [] if CLAUDE.md
+    is absent. The CLI routes these through preview_patches / apply_patches, so
+    idempotency and dry-run come for free from the existing machinery.
+    """
+    from cctx.models import FindingKind, Patch  # runtime use (Patch is TYPE_CHECKING-only above)
+
+    claude_md = target_dir / "CLAUDE.md"
+    if not claude_md.exists():
+        return []
+
+    dest = EMIT_TARGETS[emit_target]
+    content = claude_md.read_text(encoding="utf-8")
+    patches: list[Patch] = []
+
+    for heading, body in _parse_sections(content):
+        is_fixed = heading in _HEADING_TO_KIND
+        is_prefixed = heading.startswith(MANAGED_HEADING_PREFIX)
+        if not (is_fixed or is_prefixed):
+            continue
+
+        kind = _HEADING_TO_KIND[heading] if is_fixed else FindingKind.PROJECT_PATTERN
+        diff_lines = [heading] + body.splitlines()
+        unified_diff = "\n".join(f"+{line}" for line in diff_lines)
+        patches.append(Patch(
+            target_file=dest,
+            description=heading,
+            unified_diff=unified_diff,
+            finding_kind=kind,
+            evidence_summary="synced from CLAUDE.md",
+        ))
+
+    return patches
+
 
 def apply_patch(patch: Patch, target_dir: Path) -> ApplyResult:
     """Apply one patch. Never raises — errors go into ApplyResult(status=ERROR)."""
@@ -161,8 +228,10 @@ def apply_patch(patch: Patch, target_dir: Path) -> ApplyResult:
 def preview_patches(patches: list[Patch], target_dir: Path) -> list[ApplyResult]:
     """Compute what would happen without writing. Returns APPLIED or SKIPPED."""
     results = []
-    # Track fingerprints already "seen" within this preview run (idempotency)
-    seen_fingerprints: set[str] = set()
+    # Track (target_path, fingerprint) pairs already "seen" within this preview
+    # run (idempotency). Keyed by file so the same heading in two different
+    # target files is correctly treated as two independent patches.
+    seen_fingerprints: set[tuple[Path, str]] = set()
 
     for patch in patches:
         target_path = target_dir / patch.target_file
@@ -181,7 +250,8 @@ def preview_patches(patches: list[Patch], target_dir: Path) -> list[ApplyResult]
 
         content = target_path.read_text(encoding="utf-8") if target_path.exists() else ""
 
-        if fp is not None and (_already_present(content, fp) or fp in seen_fingerprints):
+        already_seen = fp is not None and (target_path, fp) in seen_fingerprints
+        if fp is not None and (_already_present(content, fp) or already_seen):
             results.append(ApplyResult(
                 patch=patch,
                 status=ApplyStatus.SKIPPED,
@@ -190,7 +260,7 @@ def preview_patches(patches: list[Patch], target_dir: Path) -> list[ApplyResult]
             ))
         else:
             if fp is not None:
-                seen_fingerprints.add(fp)
+                seen_fingerprints.add((target_path, fp))
             results.append(ApplyResult(
                 patch=patch,
                 status=ApplyStatus.APPLIED,

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

@@ -184,6 +184,22 @@ KIND_LABEL: dict[FindingKind, str] = {
     FindingKind.PROJECT_PATTERN: "PROJECT PATTERN",
 }
 
+# Maps FindingKind to the exact ## heading emitted by its recommender patch
+# template. Single source of truth for "which CLAUDE.md sections cctx owns."
+# 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",
+}
+
+# Project-specific patterns use a heading that embeds tool+key, so the managed
+# section is identified by prefix rather than exact match.
+MANAGED_HEADING_PREFIX: str = "## Project-specific: "
+
 
 class Severity(str, Enum):
     HIGH   = "high"
@@ -217,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
@@ -226,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.5.1 → 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.5.1 → 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.5.1 → cctx_cli-1.7.0}/docs/superpowers/specs/2026-06-09-cross-agent-emit-design.md

@@ -88,12 +88,21 @@ Clones patches suitable for emission:
   reach here given the above filter, but stated explicitly for clarity).
 - Returns clones via `dataclasses.replace(patch, target_file=EMIT_TARGETS[emit_target])`.
 
-### `sync_managed_sections(target_dir, emit_target) -> list[ApplyResult]`
+### `sync_managed_sections(target_dir, emit_target) -> list[Patch]`
+
+> **Implementation deviation (2026-06-10):** This function returns
+> `list[Patch]` rather than applying patches inline (the original draft returned
+> `list[ApplyResult]` and called `apply_patch` itself). The CLI appends these
+> patches to the same list it routes through `preview_patches` / `apply_patches`.
+> Returning patches keeps `--dry-run` write-free by construction and matches the
+> codebase's "CLI decides preview vs. apply" layering — applying inline could not
+> preview, contradicting the `--dry-run` requirement and `test_dry_run_no_writes`.
 
 1. Reads `CLAUDE.md` from `target_dir`. Returns empty list if absent.
 2. Calls `_parse_sections(content)` (already in `harvest.py`).
 3. Keeps sections whose heading is exactly in `MANAGED_HEADINGS.values()` OR
-   starts with `MANAGED_HEADING_PREFIX`.
+   starts with `MANAGED_HEADING_PREFIX`. The leading `("(preamble)", …)` pair
+   matches neither branch and is skipped.
 4. For each kept section, constructs a synthetic `Patch` with:
    - `target_file = EMIT_TARGETS[emit_target]`
    - `unified_diff = "\n".join(f"+{line}" for line in [heading] + body.splitlines())`
@@ -102,8 +111,10 @@ Clones patches suitable for emission:
      `FindingKind.PROJECT_PATTERN` for `## Project-specific: …` prefixed headings
    - `description = heading`
    - `evidence_summary = "synced from CLAUDE.md"`
-5. Applies each synthetic patch via `apply_patch`, which handles idempotency
-   via `_already_present` (the `## Heading` line is the fingerprint).
+5. Returns the list of synthetic patches. The CLI routes them through the
+   existing `preview_patches` / `apply_patches` machinery, which handles
+   idempotency via `_already_present` (the `## Heading` line is the fingerprint)
+   and dry-run preview without writing.
 
 ---
 
@@ -143,8 +154,13 @@ under their full path.
 ## Error contract
 
 - Never raises. All failures return `ApplyResult(status=ERROR, message=...)`.
-- `--sync` with no CLAUDE.md: returns `[]` (not an error), logged as a
-  single `SKIPPED` line: "CLAUDE.md not found — nothing to sync."
+- `--sync` with no CLAUDE.md: `sync_managed_sections` returns `[]` (not an
+  error). Because it returns patches rather than applying inline (see the
+  deviation note above), there is no `SKIPPED` line for the missing file — the
+  empty result simply contributes nothing, and if no other patches exist the CLI
+  prints its standard "No patches to apply." message. (The original draft
+  emitted a "CLAUDE.md not found — nothing to sync." line; that belonged to the
+  inline-apply design and no longer applies.)
 - Emit target directory is created by `apply_patch`'s existing `parent.mkdir`.
 
 ---

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

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