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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.6.0
+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.0 → 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.0 → 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",
@@ -181,6 +188,13 @@ EXPORTS: dict[str, str] = {
             "resolve",
             "subagent_paths",
         ),
+        "cc_transcript.codex": (
+            "CodexPendingItem",
+            "CodexRollout",
+            "CodexSessionInfo",
+            "CodexUsage",
+            "Lifecycle",
+        ),
         "cc_transcript.activity": (
             "Edit",
             "SessionActivity",

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

@@ -27,6 +27,14 @@ from cc_transcript.builders import (
     keep_only as keep_only,
 )
 
+from cc_transcript.codex import (
+    CodexPendingItem as CodexPendingItem,
+    CodexRollout as CodexRollout,
+    CodexSessionInfo as CodexSessionInfo,
+    CodexUsage as CodexUsage,
+    Lifecycle as Lifecycle,
+)
+
 from cc_transcript.command import (
     Command as Command,
     CommandLine as CommandLine,
@@ -225,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,
@@ -239,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,
@@ -258,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,
@@ -287,6 +302,7 @@ __all__ = [
     "ASSISTANTS",
     "Action",
     "ApiError",
+    "ApplyPatchCall",
     "AskUserQuestionResult",
     "AssistantEvent",
     "AsyncHookResponse",
@@ -302,6 +318,11 @@ __all__ = [
     "CacheCreation",
     "CandidatePair",
     "CcVersion",
+    "CodeModeCall",
+    "CodexPendingItem",
+    "CodexRollout",
+    "CodexSessionInfo",
+    "CodexUsage",
     "Command",
     "CommandLine",
     "CommandLineQuery",
@@ -342,6 +363,7 @@ __all__ = [
     "HydratedWindow",
     "InitInfo",
     "JUNK_USER_MESSAGE_RE",
+    "Lifecycle",
     "McpServer",
     "ModeEvent",
     "ModelPricing",
@@ -360,6 +382,7 @@ __all__ = [
     "OtherResult",
     "OtherSystemDetail",
     "PRICING",
+    "PatchEdit",
     "Plugin",
     "PreservedMessages",
     "PreservedSegment",
@@ -417,6 +440,7 @@ __all__ = [
     "TurnDuration",
     "TurnRef",
     "USERS",
+    "UpdatePlanCall",
     "Usage",
     "UserClassifier",
     "UserEvent",
@@ -426,6 +450,7 @@ __all__ = [
     "WorkflowCall",
     "WriteCall",
     "WriteResult",
+    "WriteStdinCall",
     "annotate_spec",
     "apply_spec",
     "assistant_line",
@@ -446,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.0 → 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,18 @@ __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",
     "command_parse",
     "command_prefixes",
     "context_capture_window",
@@ -116,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",
@@ -130,6 +145,7 @@ __all__ = [
     "mcp_access",
     "mcp_parts",
     "mine_events",
+    "mining_sample_refs",
     "nlp_analyze",
     "noise_spec_json",
     "notifications_from_events",
@@ -175,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"""
@@ -382,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"""
@@ -430,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: ...
@@ -1228,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"""
@@ -1516,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:
@@ -1810,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"""
@@ -1941,15 +2001,14 @@ class Transcript:
     The parsed events of a single transcript file, backed by the native parse
     output; ``events`` materializes lazy views on access.
 
-    One parse owns one ``Arc<Vec<Entry>>`` that every event and nested view shares,
-    so retaining any single view keeps that whole parse's entries alive; keeping one
-    event from each of several parses retains all of their entries. The live
-    :class:`~watch.WatchEvent` stream is exempt — its tailer builds a
-    one-entry Arc per yielded event, so a held watch event pins only itself.
+    One parse owns one ``Arc<Vec<Entry>>`` shared by every view, so retaining any
+    view keeps the whole parse's entries alive; the live
+    :class:`~watch.WatchEvent` stream is exempt (one-entry Arc each).
 
     Attributes:
         path: The transcript's path on disk; None for a bytes parse.
         mtime: The transcript's modification time when parsed.
+        provider: The transcript's source provider: "claude" or "codex".
         events: The parsed events, in file order.
     """
     @property
@@ -1957,6 +2016,8 @@ class Transcript:
     @property
     def mtime(self) -> builtins.float: ...
     @property
+    def provider(self) -> typing.Literal["claude", "codex"]: ...
+    @property
     def events(self) -> EventList: ...
 
 @typing.final
@@ -1981,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"""
@@ -2178,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:
@@ -2193,6 +2288,14 @@ 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]: ...
+
+def codex_session_info(path: builtins.str) -> dict[str, typing.Any]: ...
+
 def command_parse(command: builtins.str) -> dict[str, typing.Any]: ...
 
 def command_prefixes(commands: typing.Sequence[builtins.str]) -> builtins.list[builtins.list[builtins.str]]: ...
@@ -2217,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]:
@@ -2229,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.
@@ -2243,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]]: ...
@@ -2300,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.0 → 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,
                     )