cc-transcript 14.6.1__tar.gz → 14.7.0__tar.gz

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.6.1
+Version: 14.7.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -118,7 +118,7 @@ transcript = parse(discover()[0], drop=NOISE_SPEC)
 print(len(transcript.events), "events after the noise drop")
 ```
 
-`discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
+`discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. `parse` also reads OpenAI Codex CLI rollouts — hand it a path from `~/.codex/sessions` and the same typed events come back. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
 
 ## More in the docs
 
@@ -127,6 +127,7 @@ print(len(transcript.events), "events after the noise drop")
 - [Sentiment scoring](https://yasyf.github.io/cc-transcript/docs/guide/scoring-sentiment.html) buckets conversations and scores them around any inference engine.
 - [Feedback mining](https://yasyf.github.io/cc-transcript/docs/guide/mining-feedback.html) runs detectors, confidence calibration, and LLM verdict passes over your corpus.
 - [The Rust engine](https://yasyf.github.io/cc-transcript/docs/guide/rust-engine.html) is the implementation — parsing, filtering, scoring, and mining — its correctness pinned by hand-owned literals and golden fixtures.
+- [Codex rollouts](https://yasyf.github.io/cc-transcript/docs/guide/codex-rollouts.html) make the parser two-provider: OpenAI Codex CLI sessions lower into the same typed events, with rollout discovery, subagent joins, and per-session lifecycle and token totals. `list --provider codex` finds them from the shell.
 - [API reference](https://yasyf.github.io/cc-transcript/reference/index.html) documents the complete typed surface, from `TranscriptEvent` to `SessionActivity`.
 
 Read the [docs](https://yasyf.github.io/cc-transcript/) for the full guide. Licensed under [PolyForm Noncommercial 1.0.0](https://github.com/yasyf/cc-transcript/blob/main/LICENSE).

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/README.md

@@ -82,7 +82,7 @@ transcript = parse(discover()[0], drop=NOISE_SPEC)
 print(len(transcript.events), "events after the noise drop")
 ```
 
-`discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
+`discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. `parse` also reads OpenAI Codex CLI rollouts — hand it a path from `~/.codex/sessions` and the same typed events come back. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
 
 ## More in the docs
 
@@ -91,6 +91,7 @@ print(len(transcript.events), "events after the noise drop")
 - [Sentiment scoring](https://yasyf.github.io/cc-transcript/docs/guide/scoring-sentiment.html) buckets conversations and scores them around any inference engine.
 - [Feedback mining](https://yasyf.github.io/cc-transcript/docs/guide/mining-feedback.html) runs detectors, confidence calibration, and LLM verdict passes over your corpus.
 - [The Rust engine](https://yasyf.github.io/cc-transcript/docs/guide/rust-engine.html) is the implementation — parsing, filtering, scoring, and mining — its correctness pinned by hand-owned literals and golden fixtures.
+- [Codex rollouts](https://yasyf.github.io/cc-transcript/docs/guide/codex-rollouts.html) make the parser two-provider: OpenAI Codex CLI sessions lower into the same typed events, with rollout discovery, subagent joins, and per-session lifecycle and token totals. `list --provider codex` finds them from the shell.
 - [API reference](https://yasyf.github.io/cc-transcript/reference/index.html) documents the complete typed surface, from `TranscriptEvent` to `SessionActivity`.
 
 Read the [docs](https://yasyf.github.io/cc-transcript/) for the full guide. Licensed under [PolyForm Noncommercial 1.0.0](https://github.com/yasyf/cc-transcript/blob/main/LICENSE).

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/__init__.py

@@ -34,9 +34,11 @@ EXPORTS: dict[str, str] = {
         ),
         "cc_transcript.tools": (
             "TOOL_ALIASES",
+            "ApplyPatchCall",
             "AskUserQuestionResult",
             "BashCall",
             "BashResult",
+            "CodeModeCall",
             "EditCall",
             "EditResult",
             "EditSpan",
@@ -48,6 +50,7 @@ EXPORTS: dict[str, str] = {
             "NotebookEditCall",
             "OtherCall",
             "OtherResult",
+            "PatchEdit",
             "QuestionAnnotation",
             "ReadCall",
             "ReadResult",
@@ -66,11 +69,15 @@ EXPORTS: dict[str, str] = {
             "ToolResult",
             "ToolResultBase",
             "ToolResultError",
+            "UpdatePlanCall",
             "WorkflowCall",
             "WriteCall",
             "WriteResult",
+            "WriteStdinCall",
+            "edits_of",
             "expand_tool_names",
             "file_path_of",
+            "file_paths_of",
             "hunks_of",
             "matches_names",
             "mcp_access",

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/__init__.pyi

@@ -233,9 +233,11 @@ from cc_transcript.synthetic import (
 )
 
 from cc_transcript.tools import (
+    ApplyPatchCall as ApplyPatchCall,
     AskUserQuestionResult as AskUserQuestionResult,
     BashCall as BashCall,
     BashResult as BashResult,
+    CodeModeCall as CodeModeCall,
     EditCall as EditCall,
     EditResult as EditResult,
     EditSpan as EditSpan,
@@ -247,6 +249,7 @@ from cc_transcript.tools import (
     NotebookEditCall as NotebookEditCall,
     OtherCall as OtherCall,
     OtherResult as OtherResult,
+    PatchEdit as PatchEdit,
     QuestionAnnotation as QuestionAnnotation,
     ReadCall as ReadCall,
     ReadResult as ReadResult,
@@ -266,11 +269,15 @@ from cc_transcript.tools import (
     ToolResult as ToolResult,
     ToolResultBase as ToolResultBase,
     ToolResultError as ToolResultError,
+    UpdatePlanCall as UpdatePlanCall,
     WorkflowCall as WorkflowCall,
     WriteCall as WriteCall,
     WriteResult as WriteResult,
+    WriteStdinCall as WriteStdinCall,
+    edits_of as edits_of,
     expand_tool_names as expand_tool_names,
     file_path_of as file_path_of,
+    file_paths_of as file_paths_of,
     hunks_of as hunks_of,
     matches_names as matches_names,
     mcp_access as mcp_access,
@@ -295,6 +302,7 @@ __all__ = [
     "ASSISTANTS",
     "Action",
     "ApiError",
+    "ApplyPatchCall",
     "AskUserQuestionResult",
     "AssistantEvent",
     "AsyncHookResponse",
@@ -310,6 +318,7 @@ __all__ = [
     "CacheCreation",
     "CandidatePair",
     "CcVersion",
+    "CodeModeCall",
     "CodexPendingItem",
     "CodexRollout",
     "CodexSessionInfo",
@@ -373,6 +382,7 @@ __all__ = [
     "OtherResult",
     "OtherSystemDetail",
     "PRICING",
+    "PatchEdit",
     "Plugin",
     "PreservedMessages",
     "PreservedSegment",
@@ -430,6 +440,7 @@ __all__ = [
     "TurnDuration",
     "TurnRef",
     "USERS",
+    "UpdatePlanCall",
     "Usage",
     "UserClassifier",
     "UserEvent",
@@ -439,6 +450,7 @@ __all__ = [
     "WorkflowCall",
     "WriteCall",
     "WriteResult",
+    "WriteStdinCall",
     "annotate_spec",
     "apply_spec",
     "assistant_line",
@@ -459,9 +471,11 @@ __all__ = [
     "drop_short",
     "drop_sidechain",
     "drop_synthetic",
+    "edits_of",
     "expand_tool_names",
     "export_activity",
     "file_path_of",
+    "file_paths_of",
     "find_in",
     "git_corrections",
     "harvest_pairs",

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/_native.pyi

@@ -14,6 +14,7 @@ import pathlib
 import typing
 __all__ = [
     "ApiError",
+    "ApplyPatchCall",
     "AskUserQuestionResult",
     "AssistantEvent",
     "AsyncHookResponse",
@@ -22,6 +23,7 @@ __all__ = [
     "BashCall",
     "BashResult",
     "CacheCreation",
+    "CodeModeCall",
     "Command",
     "CommandLine",
     "CommandLineQuery",
@@ -57,6 +59,7 @@ __all__ = [
     "OtherResult",
     "OtherSystemDetail",
     "ParseStream",
+    "PatchEdit",
     "Plugin",
     "PreservedMessages",
     "PreservedSegment",
@@ -92,6 +95,7 @@ __all__ = [
     "ToolUseBlock",
     "Transcript",
     "TurnDuration",
+    "UpdatePlanCall",
     "Usage",
     "UserEvent",
     "WatchTailer",
@@ -99,11 +103,15 @@ __all__ = [
     "WorkflowCall",
     "WriteCall",
     "WriteResult",
+    "WriteStdinCall",
     "activity_hunk_overlap",
     "activity_lift",
     "activity_lift_from_events",
+    "activity_overlap_between",
+    "activity_parse_show_hunks",
     "bucket_events_from_events",
     "cli_main",
+    "codex_children_of",
     "codex_discover",
     "codex_resolve",
     "codex_session_info",
@@ -119,12 +127,16 @@ __all__ = [
     "discovery_is_subagent_path",
     "discovery_subagent_paths",
     "discovery_subagent_transcripts",
+    "edits_of",
     "embedded_literals",
     "expand_tool_names",
     "file_path_of",
+    "file_paths_of",
     "hunks_of",
     "ids_canonical_json",
     "ids_tool_digest",
+    "judge_exact_upper_bound",
+    "judge_sample_audit",
     "lexicon_has_hit",
     "lexicon_overrides",
     "lexicon_polarity",
@@ -133,6 +145,7 @@ __all__ = [
     "mcp_access",
     "mcp_parts",
     "mine_events",
+    "mining_sample_refs",
     "nlp_analyze",
     "noise_spec_json",
     "notifications_from_events",
@@ -178,6 +191,17 @@ class ApiError:
     @property
     def details(self) -> typing.Optional[builtins.str]: ...
 
+@typing.final
+class ApplyPatchCall(ToolCallBase):
+    r"""
+    A codex apply_patch call: one :class:`PatchEdit` per file in the envelope.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def edits(self) -> tuple[PatchEdit, ...]: ...
+
 @typing.final
 class AskUserQuestionResult(ToolResultBase):
     r"""
@@ -385,6 +409,18 @@ class CacheCreation:
     @property
     def ephemeral_1h_input_tokens(self) -> builtins.int: ...
 
+@typing.final
+class CodeModeCall(ToolCallBase):
+    r"""
+    A codex code-mode ``exec`` call whose ``source`` is a free-form program, kept
+    verbatim — never JSON-decoded.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def source(self) -> builtins.str: ...
+
 @typing.final
 class Command:
     r"""
@@ -433,6 +469,7 @@ class Command:
     @classmethod
     def parse(cls, raw: builtins.str) -> typing.Optional[Command]: ...
     def runs(self, *argv: typing.Any) -> builtins.bool: ...
+    def split_options(self, value_flags: typing.Sequence[builtins.str]) -> tuple[tuple[Word, ...], tuple[Word, ...]]: ...
     def matches(self, pattern: builtins.str) -> builtins.bool: ...
     def has_arg(self, *patterns: typing.Any) -> builtins.bool: ...
     def __str__(self) -> builtins.str: ...
@@ -1231,6 +1268,23 @@ class ParseStream:
     def recv(self) -> Transcript | None: ...
     def recv_many(self, max: builtins.int) -> list[Transcript]: ...
 
+@typing.final
+class PatchEdit:
+    r"""
+    One file's edit within a codex apply_patch envelope: its ``file_path``, ``kind``
+    (``"add"``/``"update"``/``"delete"``), rename ``move_path``, and before/after
+    ``hunks`` (empty for a deletion, one addition hunk for an add).
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def file_path(self) -> builtins.str: ...
+    @property
+    def kind(self) -> typing.Literal["add", "update", "delete"]: ...
+    @property
+    def move_path(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def hunks(self) -> tuple[Hunk, ...]: ...
+
 @typing.final
 class Plugin:
     r"""
@@ -1519,6 +1573,8 @@ class RustFeedbackStore:
     def record_verdict(self, dedup_key: builtins.str, role: builtins.str, prompt_version: builtins.int, model: builtins.str, category: builtins.str, accepted: builtins.bool, summary: builtins.str, confidence: builtins.float, rationale: builtins.str, canonical_key: typing.Optional[builtins.str], fidelity: builtins.str, judged_at: builtins.str) -> asyncio.Future[bool]: ...
     def unjudged(self, role: builtins.str, prompt_version: builtins.int, refresh_summary: builtins.bool = False, limit: typing.Optional[builtins.int] = None, offset: typing.Optional[builtins.int] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
     def judged(self, role: builtins.str, prompt_version: builtins.int) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def suggest_canonical_keys(self, query: typing.Sequence[builtins.int], prompt_version: builtins.int, k: builtins.int) -> asyncio.Future[list[tuple[str, float, list[str]]]]: ...
+    def near_duplicate_keys(self, prompt_version: builtins.int, threshold: builtins.float) -> asyncio.Future[list[tuple[str, str, float]]]: ...
 
 @typing.final
 class ServerToolUse:
@@ -1813,13 +1869,14 @@ class ToolCallBase:
     Attributes:
         name: The tool name exactly as invoked (aliases are not normalized —
             the digest must match what the hook saw).
-        raw: The verbatim input mapping; the only digest substrate.
+        raw: The verbatim input value — a mapping for structured calls, a plain
+            string for Codex calls, or None when absent. The only digest substrate.
     """
     __match_args__: typing.ClassVar[tuple[str, ...]]
     @property
     def name(self) -> builtins.str: ...
     @property
-    def raw(self) -> collections.abc.Mapping[str, typing.Any]: ...
+    def raw(self) -> collections.abc.Mapping[str, typing.Any] | str | None: ...
     @property
     def digest(self) -> ids.ToolDigest:
         r"""
@@ -1985,6 +2042,19 @@ class TurnDuration:
     @property
     def pending_background_agent_count(self) -> typing.Optional[builtins.int]: ...
 
+@typing.final
+class UpdatePlanCall(ToolCallBase):
+    r"""
+    A codex update_plan call: the plan-step array and its optional narration.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def plan(self) -> list[typing.Any] | None: ...
+    @property
+    def explanation(self) -> typing.Optional[builtins.str]: ...
+
 @typing.final
 class Usage:
     r"""
@@ -2182,12 +2252,33 @@ class WriteResult(ToolResultBase):
     @property
     def user_modified(self) -> bool: ...
 
+@typing.final
+class WriteStdinCall(ToolCallBase):
+    r"""
+    A codex write_stdin call: the text written to a session's stdin and its target.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def chars(self) -> typing.Any | None: ...
+    @property
+    def session_id(self) -> builtins.int: ...
+    @property
+    def yield_time_ms(self) -> typing.Optional[builtins.int]: ...
+    @property
+    def max_output_tokens(self) -> typing.Optional[builtins.int]: ...
+
 def activity_hunk_overlap(a_old: builtins.str, a_new: builtins.str, b_old: builtins.str, b_new: builtins.str) -> builtins.float: ...
 
 def activity_lift(path: builtins.str, max_events: builtins.int) -> dict[str, typing.Any]: ...
 
 def activity_lift_from_events(events: list[models.TranscriptEvent], opener_flags: typing.Optional[typing.Sequence[builtins.bool]] = None) -> list[dict[str, typing.Any]]: ...
 
+def activity_overlap_between(incorrect: typing.Sequence[tuple[builtins.str, builtins.str]], correction: typing.Sequence[tuple[builtins.str, builtins.str]]) -> builtins.float: ...
+
+def activity_parse_show_hunks(diff: builtins.str) -> builtins.list[tuple[builtins.str, builtins.str]]: ...
+
 def bucket_events_from_events(events: list[models.TranscriptEvent]) -> list[dict[str, typing.Any]]: ...
 
 def cli_main() -> builtins.int:
@@ -2197,6 +2288,8 @@ def cli_main() -> builtins.int:
     run, and the exit code returned verbatim for the wrapper's `sys.exit`.
     """
 
+def codex_children_of(session_id: builtins.str, root: typing.Optional[builtins.str] = None) -> builtins.list[tuple[pathlib.Path, builtins.str, builtins.bool]]: ...
+
 def codex_discover(root: typing.Optional[builtins.str | os.PathLike | pathlib.Path] = None) -> builtins.list[tuple[pathlib.Path, builtins.str, builtins.bool]]: ...
 
 def codex_resolve(session_id: builtins.str, root: typing.Optional[builtins.str | os.PathLike | pathlib.Path] = None) -> typing.Optional[pathlib.Path]: ...
@@ -2227,6 +2320,12 @@ def discovery_subagent_paths(path: builtins.str | os.PathLike | pathlib.Path) ->
 
 def discovery_subagent_transcripts(path: builtins.str | os.PathLike | pathlib.Path) -> dict[str, pathlib.Path]: ...
 
+def edits_of(call: tools.ToolCall | tools.FallbackCall) -> tuple[tuple[str, tuple[Hunk, ...]], ...]:
+    r"""
+    Every ``(file_path, hunks)`` a call lowers to: one entry per patched file for
+    apply_patch (empty hunks for a deletion), else the singular 0/1-element projection.
+    """
+
 def embedded_literals() -> dict[str, str | float | int | list[str]]: ...
 
 def expand_tool_names(spec: builtins.str) -> frozenset[str]:
@@ -2239,6 +2338,12 @@ def file_path_of(call: tools.ToolCall | tools.FallbackCall) -> typing.Optional[b
     The file a call targets, when it targets one.
     """
 
+def file_paths_of(call: tools.ToolCall | tools.FallbackCall) -> tuple[str, ...]:
+    r"""
+    Every file a call targets: one entry per patched file for apply_patch, else the
+    singular projection as a 0/1-element tuple.
+    """
+
 def hunks_of(call: tools.ToolCall | tools.FallbackCall) -> tuple[Hunk, ...]:
     r"""
     Lower an edit-shaped call to before/after hunks; ``()`` for the rest.
@@ -2253,6 +2358,19 @@ def ids_canonical_json(value_json: builtins.str) -> builtins.str: ...
 
 def ids_tool_digest(name: builtins.str, input_json: builtins.str) -> builtins.str: ...
 
+def judge_exact_upper_bound(hits: builtins.int, n: builtins.int, alpha: builtins.float) -> builtins.float:
+    r"""
+    The exact (Clopper-Pearson) one-sided upper confidence bound
+    (judge/verdicts.py exact_upper_bound).
+    """
+
+def judge_sample_audit(rows: typing.Sequence[tuple[builtins.str, builtins.str, builtins.float, builtins.bool]], accepts: builtins.int, rejects: builtins.int, seed: builtins.str, quotas: typing.Sequence[tuple[builtins.str, typing.Optional[builtins.int]]], remainder_kind: builtins.str, oversample_share: builtins.float) -> tuple[builtins.list[builtins.int], builtins.list[builtins.int]]:
+    r"""
+    The seeded stratified audit draw over pre-coerced judged rows
+    (judge/verdicts.py sample_audit): returns `(core, oversample)` as row indexes
+    into `rows`.
+    """
+
 def lexicon_has_hit(text: builtins.str, want_negative: builtins.bool) -> builtins.bool: ...
 
 def lexicon_overrides() -> builtins.list[tuple[builtins.str, builtins.int]]: ...
@@ -2310,6 +2428,13 @@ def mcp_parts(name: builtins.str) -> tuple[str, str] | None:
 
 def mine_events(events: list[models.TranscriptEvent], spec_json: builtins.str, callable_formats: typing.Sequence[tuple[builtins.str, typing.Any, typing.Any]]) -> list[dict[str, typing.Any]]: ...
 
+def mining_sample_refs(data: bytes, n: builtins.int, exclude: typing.Sequence[tuple[builtins.str, builtins.str]], exclusion_radius: builtins.int, seed: builtins.str) -> builtins.list[tuple[builtins.int, builtins.str, builtins.str]]:
+    r"""
+    The seeded negative-window draw over a transcript's completed turns
+    (mining/sampling.py sample_windows candidate build + draw): returns each drawn
+    anchor as `(turn_index, session_id, event_uuid)`, sorted by turn index.
+    """
+
 def nlp_analyze(text: builtins.str) -> builtins.list[tuple[builtins.str, builtins.str, builtins.str, builtins.str, builtins.int, builtins.int, builtins.int, builtins.bool]]:
     r"""
     Analyze `text` with the embedded UDPipe model. Returns, per token,

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/activity.py

@@ -22,7 +22,7 @@ from cc_transcript.filterspec import event_meta
 from cc_transcript.ids import EventRef
 from cc_transcript.models import AssistantEvent, ToolResultBlock, ToolUseBlock, UserEvent
 from cc_transcript.parser import parse
-from cc_transcript.tools import file_path_of, hunks_of, parse_tool_call, parse_tool_result
+from cc_transcript.tools import edits_of, parse_tool_call, parse_tool_result
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -63,6 +63,8 @@ class ToolUse:
         result: The matching result block, or None when none ever arrived.
         result_ts: The timestamp of the user entry carrying the result, or
             None when no result ever arrived.
+        edits: The call's lowered ``(file_path, hunks)`` entries, one per
+            edited file.
         turn_index: The index of the turn the call fired in.
         ts: The timestamp of the assistant entry carrying the call.
     """
@@ -71,6 +73,7 @@ class ToolUse:
     call: ToolCall | FallbackCall
     result: ToolResultBlock | None
     result_ts: datetime | None
+    edits: tuple[tuple[str, tuple[Hunk, ...]], ...]
     turn_index: int
     ts: datetime
 
@@ -139,11 +142,12 @@ class Turn:
 
     @property
     def edits(self) -> tuple[Edit, ...]:
-        """The turn's file modifications: tool uses with hunks and a file path."""
+        """The turn's file modifications: one entry per edited file (every file of an
+        apply_patch), in order."""
         return tuple(
             Edit(file_path=path, hunks=hunks, tool=use.call.name, ref=use.ref, turn_index=use.turn_index, ts=use.ts)
             for use in self.tool_uses
-            if (hunks := hunks_of(use.call)) and (path := file_path_of(use.call)) is not None
+            for path, hunks in use.edits
         )
 
 
@@ -210,12 +214,14 @@ class SessionActivity:
                         if isinstance(candidate, ToolResultBlock) and candidate.tool_use_id == use["tool_use_id"]
                     )
                     result_ts = result_event.meta.timestamp
+                call = parse_tool_call(block.name, block.input, on_error="other")
                 tool_uses.append(
                     ToolUse(
                         ref=EventRef(session_id, event.meta.uuid, block.id),
-                        call=parse_tool_call(block.name, block.input, on_error="other"),
+                        call=call,
                         result=result,
                         result_ts=result_ts,
+                        edits=edits_of(call),
                         turn_index=index,
                         ts=event.meta.timestamp,
                     )

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/codex.py

@@ -158,6 +158,29 @@ def discover(root: Path | None = None) -> tuple[CodexRollout, ...]:
     return tuple(CodexRollout(*rollout) for rollout in _native.codex_discover(sessions_root(root)))
 
 
+def children_of(
+    session_id: SessionId, *, root: Path | None = None
+) -> tuple[CodexRollout, ...]:
+    """Finds the direct child rollouts spawned by ``session_id``.
+
+    Compressed rollouts are excluded because their session metadata cannot yet be
+    inspected. Results are ordered newest first.
+
+    Args:
+        session_id: The parent rollout's thread id.
+        root: The sessions root; when None, :func:`sessions_root`.
+
+    Returns:
+        The direct child rollouts, newest first; ``()`` when there are none.
+    """
+    from cc_transcript import _native
+
+    return tuple(
+        CodexRollout(*rollout)
+        for rollout in _native.codex_children_of(session_id, str(sessions_root(root)))
+    )
+
+
 def find_transcript(session_id: SessionId, root: Path | None = None) -> Path | None:
     """Locates ``session_id``'s rollout under the codex sessions tree.
 

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/evidence.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING
 
-from cc_transcript.activity import hunk_overlap
+from cc_transcript import _native
 from cc_transcript.corrections import Correction
 from cc_transcript.ids import tool_digest
 from cc_transcript.models import AssistantEvent, ToolUseBlock
@@ -165,22 +165,29 @@ def harvest_pairs(
 
 
 def overlap_between(incorrect: tuple[Hunk, ...], correction: tuple[Hunk, ...]) -> float:
-    return max((hunk_overlap(a, b) for a in incorrect for b in correction), default=0.0)
+    return _native.activity_overlap_between(
+        [(h.old, h.new) for h in incorrect], [(h.old, h.new) for h in correction]
+    )
 
 
 def harvest_one(activity: SessionActivity, edit: Edit, *, lookahead_turns: int, repo: Path | None) -> CandidatePair:
     if matches := match_corrections(activity, edit, lookahead_turns=lookahead_turns):
         return matches[0]
-    if repo is not None and (fixes := git_corrections(repo, pickaxe_hunk(edit), path=edit.file_path, since=edit.ts)):
+    if (
+        repo is not None
+        and (hunk := pickaxe_hunk(edit)) is not None
+        and (fixes := git_corrections(repo, hunk, path=edit.file_path, since=edit.ts))
+    ):
         overlap, fix = max(((overlap_between(edit.hunks, fix.hunks), fix) for fix in fixes), key=lambda s: s[0])
         return CandidatePair(incorrect=edit, correction=fix, overlap=overlap)
     return CandidatePair(incorrect=edit, correction=None, overlap=0.0)
 
 
-def pickaxe_hunk(edit: Edit) -> Hunk:
+def pickaxe_hunk(edit: Edit) -> Hunk | None:
     return max(
         edit.hunks,
         key=lambda hunk: max((len(line.strip()) for line in hunk.new.splitlines() if line.strip()), default=0),
+        default=None,
     )
 
 
@@ -280,14 +287,4 @@ def correction_columns(
 
 
 def parse_show_hunks(diff: str) -> tuple[Hunk, ...]:
-    sections: list[tuple[list[str], list[str]]] = []
-    for line in diff.splitlines():
-        if line.startswith("@@"):
-            sections.append(([], []))
-        elif not sections or line.startswith(("---", "+++")):
-            continue
-        elif line.startswith("-"):
-            sections[-1][0].append(line[1:])
-        elif line.startswith("+"):
-            sections[-1][1].append(line[1:])
-    return tuple(Hunk("\n".join(old), "\n".join(new)) for old, new in sections)
+    return tuple(Hunk(old, new) for old, new in _native.activity_parse_show_hunks(diff))

{cc_transcript-14.6.1 → cc_transcript-14.7.0}/cc_transcript/judge/similar.py

@@ -288,19 +288,10 @@ async def suggest_canonical_keys(store: FeedbackStore, text: str, *, prompt_vers
     await prepare_connection(store)
     embedder = await asyncio.to_thread(default_embedder)
     query = serialize_vector(await asyncio.to_thread(embedder, text))
-    ranked: dict[str, list[tuple[float, str]]] = {}
-    for row in await store.sql(
-        "SELECT e.canonical_key AS ck, e.evidence_text AS ev, vec_distance_cosine(v.embedding, ?) AS dist "
-        "FROM verdict_vectors v JOIN verdict_evidence e ON e.vector_id = v.vector_id "
-        "WHERE e.prompt_version = ? ORDER BY dist",
-        [query, prompt_version],
-    ):
-        ranked.setdefault(str(row["ck"]), []).append((1.0 - float(row["dist"]), str(row["ev"])))
-    return sorted(
-        (Suggestion(ck, hits[0][0], tuple(ev for _, ev in hits[:3])) for ck, hits in ranked.items()),
-        key=lambda suggestion: suggestion.score,
-        reverse=True,
-    )[:k]
+    return [
+        Suggestion(ck, score, tuple(sentences))
+        for ck, score, sentences in await store.engine.suggest_canonical_keys(query, prompt_version, k)
+    ]
 
 
 async def near_duplicate_keys(store: FeedbackStore, *, prompt_version: int, threshold: float) -> list[KeyOverlap]:
@@ -325,26 +316,8 @@ async def near_duplicate_keys(store: FeedbackStore, *, prompt_version: int, thre
         ImportError: When the ``cc-transcript[judge]`` extra is not installed.
     """
     require_judge_extra()
-    import numpy as np
-
     await prepare_connection(store)
-    groups: dict[str, list[np.ndarray]] = {}
-    for row in await store.sql(
-        "SELECT e.canonical_key AS ck, v.embedding AS emb "
-        "FROM verdict_vectors v JOIN verdict_evidence e ON e.vector_id = v.vector_id "
-        "WHERE e.prompt_version = ?",
-        [prompt_version],
-    ):
-        groups.setdefault(str(row["ck"]), []).append(np.frombuffer(row["emb"], dtype=np.float32))
-    centroids = {ck: (mean := np.mean(vectors, axis=0)) / np.linalg.norm(mean) for ck, vectors in groups.items()}
-    keys = sorted(centroids)
-    return sorted(
-        (
-            KeyOverlap(key_a, key_b, similarity)
-            for i, key_a in enumerate(keys)
-            for key_b in keys[i + 1 :]
-            if (similarity := float(np.dot(centroids[key_a], centroids[key_b]))) > threshold
-        ),
-        key=lambda overlap: overlap.similarity,
-        reverse=True,
-    )
+    return [
+        KeyOverlap(key_a, key_b, similarity)
+        for key_a, key_b, similarity in await store.engine.near_duplicate_keys(prompt_version, threshold)
+    ]