cc-transcript 4.1.0__tar.gz → 6.0.0__tar.gz

{cc_transcript-4.1.0 → cc_transcript-6.0.0}/Cargo.lock

@@ -66,7 +66,7 @@ dependencies = [
 
 [[package]]
 name = "cc_transcript_parser"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "chrono",
  "crossbeam-channel",

cc_transcript-6.0.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: cc-transcript
+Version: 6.0.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Rust
+Classifier: Typing :: Typed
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: anyio>=4.4
+Requires-Dist: click>=8.1
+Requires-Dist: orjson>=3.10
+Requires-Dist: pytest>=8.0 ; extra == 'dev'
+Requires-Dist: ty>=0.0.44 ; extra == 'dev'
+Requires-Dist: ruff>=0.8 ; extra == 'dev'
+Requires-Dist: spawnllm>=0.4.0 ; extra == 'llm'
+Requires-Dist: spacy>=3.8 ; extra == 'sentiment'
+Requires-Dist: afinn>=0.1 ; extra == 'sentiment'
+Provides-Extra: dev
+Provides-Extra: llm
+Provides-Extra: sentiment
+License-File: LICENSE
+Summary: The Claude Code session-activity platform: a superset JSONL parser (Rust fast path, Python reference), typed tool calls with a cross-language content digest, turns/edits/evidence over one spine, context windows with labeled fidelity, unified decision and correction ledgers, LLM judging, and a transcript-investigation CLI.
+Keywords: claude-code,claude,anthropic,transcripts,jsonl,parser,cli,agents,sentiment,feedback-mining
+Author-email: Yasyf Mohamedali <yasyfm@gmail.com>
+License-Expression: PolyForm-Noncommercial-1.0.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/yasyf/cc-transcript/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://yasyf.github.io/cc-transcript/
+Project-URL: Homepage, https://github.com/yasyf/cc-transcript
+Project-URL: Issues, https://github.com/yasyf/cc-transcript/issues
+Project-URL: Repository, https://github.com/yasyf/cc-transcript
+
+# cc-transcript
+
+![cc-transcript banner](https://github.com/yasyf/cc-transcript/raw/main/docs/assets/readme-banner.webp)
+
+[![PyPI](https://img.shields.io/pypi/v/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
+[![Python](https://img.shields.io/pypi/pyversions/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
+[![Docs](https://img.shields.io/github/actions/workflow/status/yasyf/cc-transcript/docs.yml?branch=main&label=docs)](https://yasyf.github.io/cc-transcript/)
+[![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm--Noncommercial--1.0.0-blue.svg)](https://github.com/yasyf/cc-transcript/blob/main/LICENSE)
+
+A non-lossy parser for Claude Code's on-disk JSONL transcripts, plus a CLI to investigate sessions.
+
+`cc-transcript` parses Claude Code's JSONL transcripts into a typed superset event model — every entry type preserved, nothing dropped. The parser never silently discards sidechains, synthetic turns, tool results, or unrecognized entries; filtering is opt-in and lives in your code, not buried in the parser. It ships as a Python library, a `uvx`-runnable CLI, and a Claude Code plugin.
+
+## Install
+
+```bash
+uvx cc-transcript --help    # run the CLI
+```
+
+## Quickstart
+
+Discover the transcripts on disk, parse one, and walk the events:
+
+```python
+import anyio
+
+from cc_transcript import AssistantEvent, TranscriptDiscovery, UserEvent, parse_events_from_bytes
+
+path = anyio.run(TranscriptDiscovery.find_transcripts)[0]
+events = parse_events_from_bytes(path.read_bytes())
+
+for event in events:
+    match event:
+        case UserEvent(text=text):
+            print("user:", text[:80])
+        case AssistantEvent(model=model, text=text):
+            print(f"assistant ({model}):", text[:80])
+```
+
+Filtering is opt-in. Compose a spec from small builders and apply it — `build_spec` assembles clauses, `apply_spec` yields the survivors. `NOISE_SPEC` is a ready-made spec for universal structural noise (system reminders, local-command output, skill banners):
+
+```python
+from cc_transcript import apply_spec, build_spec, keep_only, drop_junk, drop_short
+
+spec = build_spec(keep_only("user", "assistant"), drop_junk("structural"), drop_short(2))
+clean = list(apply_spec(events, spec))
+```
+
+## CLI
+
+Every command runs as `uvx cc-transcript <command> ...`; see `--help` on any command for its flags.
+
+| Command  | What it does |
+| -------- | ------------ |
+| `list`   | Find transcripts on disk, newest first |
+| `stats`  | Summarize a session — counts, kinds, models, tools, token sizes, span |
+| `show`   | Render one compact line per event (`--signal` keeps the conversational spine) |
+| `grep`   | Search event content; hit indexes feed back into `show --range` |
+| `slice`  | Emit per-tool-call JSONL for a session UUID and time window (the bridge cc-review consumes) |
+| `digest` | Generate and check the cross-language fixture corpus for the tool-digest contract |
+
+The output is compact by design — one line per event, hard truncation — so an agent triages a session in a few hundred tokens instead of paging through megabytes of JSONL:
+
+```console
+$ uvx cc-transcript stats ~/.claude/projects/-Users-yasyf-Code-cc-transcript/4c77d556-8694-4613-8f50-253d905da68e.jsonl
+files        1
+events       181
+kinds        other 68 · assistant 53 · user 33 · mode 22 · system 5
+models       claude-fable-5 53
+tools        TaskCreate 10 · Agent 5 · Read 5 · TaskUpdate 5 · Bash 2 · ToolSearch 2 · AskUserQuestion 1 · ExitPlanMode 1
+text         14.8KB
+thinking     8.7KB
+tool io      89.0KB
+sessions     1
+span         2026-06-12 01:07:55 → 2026-06-12 02:28:03
+interrupts   0
+tool errors  0
+sidechain    0
+```
+
+## Claude Code plugin
+
+Install the bundled plugin from inside Claude Code:
+
+```
+/plugin marketplace add yasyf/cc-transcript
+/plugin install cc-transcript@cc-transcript
+```
+
+The plugin's skill teaches Claude to answer questions about its own history — "what did I ask yesterday", "find the session where we fixed the parser" — by funneling through the CLI's `list`, `stats`, `grep`, and `show` commands instead of reading raw JSONL.
+
+## How it works
+
+The event model is a superset: sidechains, `<synthetic>` turns, thinking blocks, and unrecognized entry types all survive parsing, so you decide what to drop via composable filter specs. Two engines sit behind one `Backend` protocol — `RustBackend` (PyO3 + rayon) is the default fast path, `PythonBackend` is the readable reference, parity-asserted against each other. On top of the spine, `SessionActivity` lifts events into turns and typed tool calls, `FileStateStore` tracks per-file mtimes in SQLite for incremental re-parses, and `cc_transcript.mining`/`judge`/`sentiment` extract feedback, run LLM verdict passes, and score conversational sentiment. The [docs site](https://yasyf.github.io/cc-transcript/) covers each of these in depth.
+
+## Docs
+
+Each section of [the docs site](https://yasyf.github.io/cc-transcript/) is a focused guide:
+
+- [Getting Started](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) — install, parse, filter, persist.
+- [Filtering events](https://yasyf.github.io/cc-transcript/docs/guide/filtering-events.html) — clauses, specs, and `NOISE_SPEC`.
+- [Scoring sentiment](https://yasyf.github.io/cc-transcript/docs/guide/scoring-sentiment.html) — the lexicon engine and score specs.
+- [Rust/Python backends & parity](https://yasyf.github.io/cc-transcript/docs/guide/backends-and-parity.html) — the `Backend` protocol and parity testing.
+- [Compose your own policy](https://yasyf.github.io/cc-transcript/docs/guide/compose-your-own-policy.html) — building a bespoke filtering policy.
+- [Mining feedback](https://yasyf.github.io/cc-transcript/docs/guide/mining-feedback.html) — detectors, confidence, candidates, and verdicts.
+- [The transcript CLI](https://yasyf.github.io/cc-transcript/docs/guide/transcript-cli.html) — `list`/`show`/`grep`/`stats` end to end.
+- [API reference](https://yasyf.github.io/cc-transcript/reference/index.html) — the complete typed surface.
+
+## License
+
+[PolyForm Noncommercial 1.0.0](LICENSE).
+

cc_transcript-6.0.0/README.md

@@ -0,0 +1,111 @@
+# cc-transcript
+
+![cc-transcript banner](https://github.com/yasyf/cc-transcript/raw/main/docs/assets/readme-banner.webp)
+
+[![PyPI](https://img.shields.io/pypi/v/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
+[![Python](https://img.shields.io/pypi/pyversions/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
+[![Docs](https://img.shields.io/github/actions/workflow/status/yasyf/cc-transcript/docs.yml?branch=main&label=docs)](https://yasyf.github.io/cc-transcript/)
+[![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm--Noncommercial--1.0.0-blue.svg)](https://github.com/yasyf/cc-transcript/blob/main/LICENSE)
+
+A non-lossy parser for Claude Code's on-disk JSONL transcripts, plus a CLI to investigate sessions.
+
+`cc-transcript` parses Claude Code's JSONL transcripts into a typed superset event model — every entry type preserved, nothing dropped. The parser never silently discards sidechains, synthetic turns, tool results, or unrecognized entries; filtering is opt-in and lives in your code, not buried in the parser. It ships as a Python library, a `uvx`-runnable CLI, and a Claude Code plugin.
+
+## Install
+
+```bash
+uvx cc-transcript --help    # run the CLI
+```
+
+## Quickstart
+
+Discover the transcripts on disk, parse one, and walk the events:
+
+```python
+import anyio
+
+from cc_transcript import AssistantEvent, TranscriptDiscovery, UserEvent, parse_events_from_bytes
+
+path = anyio.run(TranscriptDiscovery.find_transcripts)[0]
+events = parse_events_from_bytes(path.read_bytes())
+
+for event in events:
+    match event:
+        case UserEvent(text=text):
+            print("user:", text[:80])
+        case AssistantEvent(model=model, text=text):
+            print(f"assistant ({model}):", text[:80])
+```
+
+Filtering is opt-in. Compose a spec from small builders and apply it — `build_spec` assembles clauses, `apply_spec` yields the survivors. `NOISE_SPEC` is a ready-made spec for universal structural noise (system reminders, local-command output, skill banners):
+
+```python
+from cc_transcript import apply_spec, build_spec, keep_only, drop_junk, drop_short
+
+spec = build_spec(keep_only("user", "assistant"), drop_junk("structural"), drop_short(2))
+clean = list(apply_spec(events, spec))
+```
+
+## CLI
+
+Every command runs as `uvx cc-transcript <command> ...`; see `--help` on any command for its flags.
+
+| Command  | What it does |
+| -------- | ------------ |
+| `list`   | Find transcripts on disk, newest first |
+| `stats`  | Summarize a session — counts, kinds, models, tools, token sizes, span |
+| `show`   | Render one compact line per event (`--signal` keeps the conversational spine) |
+| `grep`   | Search event content; hit indexes feed back into `show --range` |
+| `slice`  | Emit per-tool-call JSONL for a session UUID and time window (the bridge cc-review consumes) |
+| `digest` | Generate and check the cross-language fixture corpus for the tool-digest contract |
+
+The output is compact by design — one line per event, hard truncation — so an agent triages a session in a few hundred tokens instead of paging through megabytes of JSONL:
+
+```console
+$ uvx cc-transcript stats ~/.claude/projects/-Users-yasyf-Code-cc-transcript/4c77d556-8694-4613-8f50-253d905da68e.jsonl
+files        1
+events       181
+kinds        other 68 · assistant 53 · user 33 · mode 22 · system 5
+models       claude-fable-5 53
+tools        TaskCreate 10 · Agent 5 · Read 5 · TaskUpdate 5 · Bash 2 · ToolSearch 2 · AskUserQuestion 1 · ExitPlanMode 1
+text         14.8KB
+thinking     8.7KB
+tool io      89.0KB
+sessions     1
+span         2026-06-12 01:07:55 → 2026-06-12 02:28:03
+interrupts   0
+tool errors  0
+sidechain    0
+```
+
+## Claude Code plugin
+
+Install the bundled plugin from inside Claude Code:
+
+```
+/plugin marketplace add yasyf/cc-transcript
+/plugin install cc-transcript@cc-transcript
+```
+
+The plugin's skill teaches Claude to answer questions about its own history — "what did I ask yesterday", "find the session where we fixed the parser" — by funneling through the CLI's `list`, `stats`, `grep`, and `show` commands instead of reading raw JSONL.
+
+## How it works
+
+The event model is a superset: sidechains, `<synthetic>` turns, thinking blocks, and unrecognized entry types all survive parsing, so you decide what to drop via composable filter specs. Two engines sit behind one `Backend` protocol — `RustBackend` (PyO3 + rayon) is the default fast path, `PythonBackend` is the readable reference, parity-asserted against each other. On top of the spine, `SessionActivity` lifts events into turns and typed tool calls, `FileStateStore` tracks per-file mtimes in SQLite for incremental re-parses, and `cc_transcript.mining`/`judge`/`sentiment` extract feedback, run LLM verdict passes, and score conversational sentiment. The [docs site](https://yasyf.github.io/cc-transcript/) covers each of these in depth.
+
+## Docs
+
+Each section of [the docs site](https://yasyf.github.io/cc-transcript/) is a focused guide:
+
+- [Getting Started](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) — install, parse, filter, persist.
+- [Filtering events](https://yasyf.github.io/cc-transcript/docs/guide/filtering-events.html) — clauses, specs, and `NOISE_SPEC`.
+- [Scoring sentiment](https://yasyf.github.io/cc-transcript/docs/guide/scoring-sentiment.html) — the lexicon engine and score specs.
+- [Rust/Python backends & parity](https://yasyf.github.io/cc-transcript/docs/guide/backends-and-parity.html) — the `Backend` protocol and parity testing.
+- [Compose your own policy](https://yasyf.github.io/cc-transcript/docs/guide/compose-your-own-policy.html) — building a bespoke filtering policy.
+- [Mining feedback](https://yasyf.github.io/cc-transcript/docs/guide/mining-feedback.html) — detectors, confidence, candidates, and verdicts.
+- [The transcript CLI](https://yasyf.github.io/cc-transcript/docs/guide/transcript-cli.html) — `list`/`show`/`grep`/`stats` end to end.
+- [API reference](https://yasyf.github.io/cc-transcript/reference/index.html) — the complete typed surface.
+
+## License
+
+[PolyForm Noncommercial 1.0.0](LICENSE).

{cc_transcript-4.1.0 → cc_transcript-6.0.0}/cc_transcript/__init__.py

@@ -57,19 +57,28 @@ EXPORTS: dict[str, str] = {
         ),
         "cc_transcript.models": (
             "AssistantEvent",
+            "CacheCreation",
             "CcVersion",
             "ContentBlock",
             "EntryMeta",
             "FallbackBlock",
+            "InitInfo",
+            "McpServer",
             "ModeEvent",
+            "ModelUsage",
             "OtherBlock",
             "OtherEvent",
+            "Plugin",
+            "PrintMessage",
+            "PrintResult",
+            "ServerToolUse",
             "SystemEvent",
             "TextBlock",
             "ThinkingBlock",
             "ToolResultBlock",
             "ToolUseBlock",
             "TranscriptEvent",
+            "Usage",
             "UserEvent",
         ),
         "cc_transcript.parser": (
@@ -77,6 +86,15 @@ EXPORTS: dict[str, str] = {
             "parse_event",
             "parse_events_async",
             "parse_events_from_bytes",
+            "parse_print_result",
+        ),
+        "cc_transcript.cost": (
+            "PRICING",
+            "CostBreakdown",
+            "ModelPricing",
+            "cost_of",
+            "cost_of_assistant",
+            "resolve_pricing",
         ),
         "cc_transcript.backend": ("Backend", "ParsedTranscript"),
         "cc_transcript.discovery": (
@@ -271,6 +289,24 @@ if TYPE_CHECKING:
     from cc_transcript.corrections import (
         Origin as Origin,
     )
+    from cc_transcript.cost import (
+        PRICING as PRICING,
+    )
+    from cc_transcript.cost import (
+        CostBreakdown as CostBreakdown,
+    )
+    from cc_transcript.cost import (
+        ModelPricing as ModelPricing,
+    )
+    from cc_transcript.cost import (
+        cost_of as cost_of,
+    )
+    from cc_transcript.cost import (
+        cost_of_assistant as cost_of_assistant,
+    )
+    from cc_transcript.cost import (
+        resolve_pricing as resolve_pricing,
+    )
     from cc_transcript.decisions import (
         DECISIONS_DDL as DECISIONS_DDL,
     )
@@ -415,6 +451,9 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         AssistantEvent as AssistantEvent,
     )
+    from cc_transcript.models import (
+        CacheCreation as CacheCreation,
+    )
     from cc_transcript.models import (
         CcVersion as CcVersion,
     )
@@ -427,15 +466,36 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         FallbackBlock as FallbackBlock,
     )
+    from cc_transcript.models import (
+        InitInfo as InitInfo,
+    )
+    from cc_transcript.models import (
+        McpServer as McpServer,
+    )
     from cc_transcript.models import (
         ModeEvent as ModeEvent,
     )
+    from cc_transcript.models import (
+        ModelUsage as ModelUsage,
+    )
     from cc_transcript.models import (
         OtherBlock as OtherBlock,
     )
     from cc_transcript.models import (
         OtherEvent as OtherEvent,
     )
+    from cc_transcript.models import (
+        Plugin as Plugin,
+    )
+    from cc_transcript.models import (
+        PrintMessage as PrintMessage,
+    )
+    from cc_transcript.models import (
+        PrintResult as PrintResult,
+    )
+    from cc_transcript.models import (
+        ServerToolUse as ServerToolUse,
+    )
     from cc_transcript.models import (
         SystemEvent as SystemEvent,
     )
@@ -454,6 +514,9 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         TranscriptEvent as TranscriptEvent,
     )
+    from cc_transcript.models import (
+        Usage as Usage,
+    )
     from cc_transcript.models import (
         UserEvent as UserEvent,
     )
@@ -469,6 +532,9 @@ if TYPE_CHECKING:
     from cc_transcript.parser import (
         parse_events_from_bytes as parse_events_from_bytes,
     )
+    from cc_transcript.parser import (
+        parse_print_result as parse_print_result,
+    )
     from cc_transcript.query import (
         FileRef as FileRef,
     )

{cc_transcript-4.1.0 → cc_transcript-6.0.0}/cc_transcript/__main__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from cc_transcript.cli import cli
 
 cli()

{cc_transcript-4.1.0 → cc_transcript-6.0.0}/cc_transcript/_parser_rs.pyi

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from cc_transcript.models import TranscriptEvent
+from cc_transcript.models import PrintResult, TranscriptEvent
 
 class ParseStream:
     """A streaming handle over a rayon-parsed batch of transcript files."""
@@ -18,6 +18,9 @@ def stream_parse(paths: list[tuple[str, float]], prefetch: int, spec_json: str |
     are dropped during parsing, before any Python object is built.
     """
 
+def parse_print_result(raw: bytes, /) -> PrintResult:
+    """Parses a 'claude -p --output-format json' result from raw JSON bytes."""
+
 def lexicon_available() -> bool:
     """Whether the UDPipe English model loaded (downloading + caching on first call)."""
 

{cc_transcript-4.1.0 → cc_transcript-6.0.0}/cc_transcript/corrections_cli.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 import json
 import time
 from dataclasses import asdict
-from typing import cast
 
 import click
 import orjson
@@ -54,7 +53,7 @@ def add(
     anchor: str,
     incorrect_file: str,
     ts_ms: int | None,
-    origin: str | None,
+    origin: Origin | None,
     incorrect_old: str,
     incorrect_new: str,
     incorrect_digest: str | None,
@@ -79,7 +78,7 @@ def add(
             incorrect_file=incorrect_file,
             incorrect_old=incorrect_old,
             incorrect_new=incorrect_new,
-            correction_origin=cast("Origin | None", origin),
+            correction_origin=origin,
             correction_file=correction_file,
             correction_old=correction_old,
             correction_new=correction_new,

cc_transcript-6.0.0/cc_transcript/cost.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from cc_transcript.models import AssistantEvent, Usage
+
+MTOK = 1_000_000
+
+
+@dataclass(frozen=True, slots=True)
+class ModelPricing:
+    """USD-per-million-token rates for a model family.
+
+    Standard service tier, standard (non-long-context) pricing — current Claude
+    4.x models serve their 1M context at standard rates with no long-context
+    premium. Override via the `pricing` argument to cost_of for other tiers.
+
+    Attributes:
+        input: USD per million uncached input tokens.
+        output: USD per million output tokens.
+        cache_read: USD per million tokens served from the cache.
+        cache_write_5m: USD per million tokens written to the 5-minute cache.
+        cache_write_1h: USD per million tokens written to the 1-hour cache.
+    """
+
+    input: float
+    output: float
+    cache_read: float
+    cache_write_5m: float
+    cache_write_1h: float
+
+
+@dataclass(frozen=True, slots=True)
+class CostBreakdown:
+    """The per-component and total USD cost of a single turn's token usage.
+
+    Attributes:
+        input_cost: USD cost of the uncached input tokens.
+        output_cost: USD cost of the output tokens.
+        cache_read_cost: USD cost of the cache-read tokens.
+        cache_write_cost: USD cost of the cache-creation tokens, summed across TTL buckets.
+        total: The sum of the four component costs.
+    """
+
+    input_cost: float
+    output_cost: float
+    cache_read_cost: float
+    cache_write_cost: float
+    total: float
+
+
+PRICING: Mapping[str, ModelPricing] = {
+    "fable": ModelPricing(input=10.0, output=50.0, cache_read=1.0, cache_write_5m=12.5, cache_write_1h=20.0),
+    "opus": ModelPricing(input=5.0, output=25.0, cache_read=0.5, cache_write_5m=6.25, cache_write_1h=10.0),
+    "sonnet": ModelPricing(input=3.0, output=15.0, cache_read=0.3, cache_write_5m=3.75, cache_write_1h=6.0),
+    "haiku": ModelPricing(input=1.0, output=5.0, cache_read=0.1, cache_write_5m=1.25, cache_write_1h=2.0),
+}
+
+
+def resolve_pricing(model: str, *, pricing: Mapping[str, ModelPricing] = PRICING) -> ModelPricing:
+    """Return the pricing row whose family key is a substring of `model`.
+
+    Family keys are mutually exclusive substrings, so at most one matches —
+    ``"claude-haiku-4-5-20251001"`` resolves to haiku, ``"claude-opus-4-8"`` to
+    opus, and a bare ``"sonnet"`` to sonnet.
+
+    Args:
+        model: The model id to resolve.
+        pricing: The family-keyed pricing table to search.
+
+    Raises:
+        KeyError: If no family key is a substring of `model`.
+
+    Example:
+        >>> resolve_pricing("claude-opus-4-8").input
+        5.0
+    """
+    for family, row in pricing.items():
+        if family in model:
+            return row
+    raise KeyError(f"no pricing for model: {model}")
+
+
+def cost_of(usage: Usage, model: str, *, pricing: Mapping[str, ModelPricing] = PRICING) -> CostBreakdown:
+    """Compute the USD cost of a turn's token usage under a model's rates.
+
+    The cache-creation split prefers the per-TTL ``usage.cache_creation`` when
+    present, falling back to the flat ``usage.cache_creation_input_tokens`` as
+    5-minute writes with no 1-hour share.
+
+    Args:
+        usage: The turn's token usage and cache accounting.
+        model: The model id whose rates apply.
+        pricing: The family-keyed pricing table to resolve against.
+
+    Returns:
+        The per-component and total cost.
+
+    Example:
+        >>> cost_of(usage, "claude-haiku-4-5-20251001").total
+        0.05759
+    """
+    row = resolve_pricing(model, pricing=pricing)
+    write_5m, write_1h = (
+        (usage.cache_creation.ephemeral_5m_input_tokens, usage.cache_creation.ephemeral_1h_input_tokens)
+        if usage.cache_creation is not None
+        else (usage.cache_creation_input_tokens, 0)
+    )
+    input_cost = usage.input_tokens / MTOK * row.input
+    output_cost = usage.output_tokens / MTOK * row.output
+    cache_read_cost = usage.cache_read_input_tokens / MTOK * row.cache_read
+    cache_write_cost = write_5m / MTOK * row.cache_write_5m + write_1h / MTOK * row.cache_write_1h
+    return CostBreakdown(
+        input_cost=input_cost,
+        output_cost=output_cost,
+        cache_read_cost=cache_read_cost,
+        cache_write_cost=cache_write_cost,
+        total=input_cost + output_cost + cache_read_cost + cache_write_cost,
+    )
+
+
+def cost_of_assistant(event: AssistantEvent, *, pricing: Mapping[str, ModelPricing] = PRICING) -> CostBreakdown | None:
+    """Compute the cost of an assistant turn, or None when it carries no usage.
+
+    Args:
+        event: The assistant turn whose usage is priced.
+        pricing: The family-keyed pricing table to resolve against.
+
+    Returns:
+        The cost breakdown, or None when ``event.usage`` is None.
+    """
+    if event.usage is None:
+        return None
+    return cost_of(event.usage, event.model, pricing=pricing)

{cc_transcript-4.1.0 → cc_transcript-6.0.0}/cc_transcript/filterspec.py

@@ -69,6 +69,12 @@ AGENT_INJECTION_GROUPS: tuple[tuple[str, str], ...] = (
 INTERRUPT_MARKER_GROUPS: tuple[tuple[str, str], ...] = (("interrupt", r"\[Request interrupted by user"),)
 STOP_HOOK_GROUPS: tuple[tuple[str, str], ...] = (("stop_hook", r"Stop hook feedback:"),)
 
+# Raw CC-injected protocol strings carried in tool-result content: the denial banner
+# and the markers that wrap the user's verbatim instruction in a rejected tool use.
+DENIAL_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected"
+USER_SAID_MARKER = "To tell you how to proceed, the user said:\n"
+USER_SAID_TRAILER = "Note: The user's next message"
+
 # Approve-and-advance directives: a user telling the agent to proceed/commit/push or
 # to resume killed work. They follow an assistant turn but advance it rather than
 # correcting it — the opposite of pushback — so a pushback consumer drops them. The
@@ -142,6 +148,11 @@ MILD_IMPATIENCE_GROUPS: tuple[tuple[str, str], ...] = (
     ),
 )
 
+# Hedging cues that soften a correction; a mining demote stage drops confidence on a hit.
+HEDGE_GROUPS: tuple[tuple[str, str], ...] = (
+    ("hedged", r"\b(?:maybe|perhaps|possibly|might|not sure|i think|i guess|if you (?:want|prefer)|up to you)\b"),
+)
+
 PORTABLE_GROUP_NAMES: frozenset[str] = frozenset(
     name
     for name, _ in (
@@ -152,6 +163,7 @@ PORTABLE_GROUP_NAMES: frozenset[str] = frozenset(
         *COMMAND_ECHO_GROUPS,
         *FRUSTRATION_GROUPS,
         *MILD_IMPATIENCE_GROUPS,
+        *HEDGE_GROUPS,
     )
 )