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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.6.0
+Version: 14.6.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

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

@@ -181,6 +181,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.6.1}/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,
@@ -302,6 +310,10 @@ __all__ = [
     "CacheCreation",
     "CandidatePair",
     "CcVersion",
+    "CodexPendingItem",
+    "CodexRollout",
+    "CodexSessionInfo",
+    "CodexUsage",
     "Command",
     "CommandLine",
     "CommandLineQuery",
@@ -342,6 +354,7 @@ __all__ = [
     "HydratedWindow",
     "InitInfo",
     "JUNK_USER_MESSAGE_RE",
+    "Lifecycle",
     "McpServer",
     "ModeEvent",
     "ModelPricing",

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

@@ -104,6 +104,9 @@ __all__ = [
     "activity_lift_from_events",
     "bucket_events_from_events",
     "cli_main",
+    "codex_discover",
+    "codex_resolve",
+    "codex_session_info",
     "command_parse",
     "command_prefixes",
     "context_capture_window",
@@ -1941,15 +1944,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 +1959,8 @@ class Transcript:
     @property
     def mtime(self) -> builtins.float: ...
     @property
+    def provider(self) -> typing.Literal["claude", "codex"]: ...
+    @property
     def events(self) -> EventList: ...
 
 @typing.final
@@ -2193,6 +2197,12 @@ def cli_main() -> builtins.int:
     run, and the exit code returned verbatim for the wrapper's `sys.exit`.
     """
 
+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]]: ...

cc_transcript-14.6.1/cc_transcript/codex.py

@@ -0,0 +1,212 @@
+"""The codex session surface: discovery, resolution, and per-rollout session info.
+
+A sync facade over the native codex functions, mirroring
+:mod:`cc_transcript.discovery` for the ``~/.codex/sessions`` tree. The sessions-root
+default is a facade concern; the native side scans exactly the root it is handed.
+
+There is no parse function here: :func:`cc_transcript.parse` is already
+provider-transparent — it sniffs a codex rollout, lowers it into the native event
+model, and yields the same :class:`~cc_transcript.models.Transcript` view a Claude
+transcript produces, with ``provider == "codex"``. This module adds only the codex
+identity, lifecycle, and token-usage surface that the lowered event stream drops.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from cc_transcript.ids import SessionId
+
+SESSIONS_ROOT = Path.home() / ".codex" / "sessions"
+
+Lifecycle = Literal["uninitialized", "no_instrumentation", "open", "completed", "aborted"]
+"""A codex rollout's turn-lifecycle state.
+
+``uninitialized`` — no content at all; ``no_instrumentation`` — content but no
+``task_started``/``task_complete`` brackets; ``open`` — the latest turn is still
+running; ``completed`` — the latest turn finished; ``aborted`` — the latest turn was
+interrupted.
+"""
+
+
+@dataclass(frozen=True, slots=True)
+class CodexRollout:
+    """A rollout found in the codex sessions tree.
+
+    Attributes:
+        path: The rollout's path.
+        session_id: The session id encoded in the rollout filename.
+        compressed: Whether the rollout is a ``.jsonl.zst`` file.
+    """
+
+    path: Path
+    session_id: str
+    compressed: bool
+
+
+@dataclass(frozen=True, slots=True)
+class CodexUsage:
+    """Session-level token totals lowered from a codex rollout.
+
+    The totals are the last observed cumulative ``total_token_usage`` fields — codex
+    ``token_count`` events carry running totals, not per-turn deltas — so this is the
+    session's final accounting, not a sum.
+
+    Attributes:
+        input_tokens: Total input tokens, or None when never reported.
+        cached_input_tokens: Cached input tokens, or None when never reported.
+        output_tokens: Output tokens, or None when never reported.
+        reasoning_output_tokens: Reasoning output tokens, or None when never reported.
+        total_tokens: Total tokens, or None when never reported.
+        model_context_window: The model's context window, or None when never reported.
+        token_count_events: The number of ``token_count`` events observed.
+    """
+
+    input_tokens: int | None
+    cached_input_tokens: int | None
+    output_tokens: int | None
+    reasoning_output_tokens: int | None
+    total_tokens: int | None
+    model_context_window: int | None
+    token_count_events: int
+
+
+@dataclass(frozen=True, slots=True)
+class CodexPendingItem:
+    """A dangling tool call in the rollout's open turn.
+
+    Attributes:
+        tool_use_id: The call's ``call_id``.
+        name: The tool's name, such as ``exec``.
+        kind: How the call contributes to the verdict; always ``mid_tool`` for codex.
+    """
+
+    tool_use_id: str | None
+    name: str
+    kind: str
+
+
+@dataclass(frozen=True, slots=True)
+class CodexSessionInfo:
+    """The identity, lifecycle, and usage of one codex rollout.
+
+    Attributes:
+        rollout_thread_id: This rollout's own thread id (the session-meta ``id``).
+        session_id: The logical session id; a forked rollout inherits its origin's.
+        parent_thread_id: The spawning thread's id for a subagent rollout, else None.
+        forked_from_id: The origin thread's id when this rollout is a fork, else None.
+        cwd: The working directory recorded in the session meta.
+        originator: What launched the session, such as ``codex_exec``.
+        cli_version: The codex CLI version that wrote the rollout.
+        model_provider: The model provider, such as ``openai``.
+        lifecycle: The latest turn's lifecycle state.
+        turn_id: The latest turn's id, or None before any turn brackets.
+        pending: The dangling tool calls in an open turn, in document order.
+        last_event_epoch: The latest envelope timestamp as epoch seconds, or None.
+        usage: The session token totals, or None when no ``token_count`` event occurred.
+    """
+
+    rollout_thread_id: str | None
+    session_id: str | None
+    parent_thread_id: str | None
+    forked_from_id: str | None
+    cwd: str | None
+    originator: str | None
+    cli_version: str | None
+    model_provider: str | None
+    lifecycle: Lifecycle
+    turn_id: str | None
+    pending: tuple[CodexPendingItem, ...]
+    last_event_epoch: int | None
+    usage: CodexUsage | None
+
+
+def sessions_root(root: Path | None = None) -> Path:
+    """The codex sessions root, defaulting to ``~/.codex/sessions``.
+
+    Args:
+        root: An explicit root; when None, :data:`SESSIONS_ROOT`.
+
+    Returns:
+        The root that :func:`discover` and :func:`find_transcript` scan.
+    """
+    return root or SESSIONS_ROOT
+
+
+def discover(root: Path | None = None) -> tuple[CodexRollout, ...]:
+    """Every codex rollout under ``root``, newest first.
+
+    Rollouts live as ``rollout-<timestamp>-<session_id>.jsonl`` (or ``.jsonl.zst``)
+    files under the date-sharded sessions tree. Each result preserves its path,
+    session id, and compression state.
+
+    Args:
+        root: The sessions root; when None, :func:`sessions_root`.
+
+    Returns:
+        The rollouts, newest first; ``()`` when the root does not exist.
+
+    Example:
+        >>> for rollout in discover():
+        ...     print(rollout.session_id, rollout.path)
+    """
+    from cc_transcript import _native
+
+    return tuple(CodexRollout(*rollout) for rollout in _native.codex_discover(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.
+
+    Only uncompressed ``.jsonl`` rollouts resolve. Compressed rollouts appear in
+    ``discover()`` but do not resolve until zstd support lands. The newest wins among
+    same-id uncompressed rollouts.
+
+    Args:
+        session_id: The codex session id, as it appears in the rollout filename.
+        root: The sessions root; when None, :func:`sessions_root`.
+
+    Returns:
+        The rollout path, or None when no rollout carries that session id.
+    """
+    from cc_transcript import _native
+
+    return _native.codex_resolve(session_id, sessions_root(root))
+
+
+def session_info(path: Path) -> CodexSessionInfo:
+    """The identity, lifecycle, and token usage of the rollout at ``path``.
+
+    The native extension reads and folds the rollout in one pass, returning the
+    session identity, the turn lifecycle, any dangling calls, and the token totals.
+
+    Args:
+        path: The ``.jsonl`` rollout to inspect.
+
+    Returns:
+        The rollout's session info.
+    """
+    from cc_transcript import _native
+
+    payload = _native.codex_session_info(str(path))
+    identity = payload["identity"]
+    lifecycle = payload["lifecycle"]
+    usage = payload["usage"]
+    return CodexSessionInfo(
+        rollout_thread_id=identity["rollout_thread_id"],
+        session_id=identity["session_id"],
+        parent_thread_id=identity["parent_thread_id"],
+        forked_from_id=identity["forked_from_id"],
+        cwd=identity["cwd"],
+        originator=identity["originator"],
+        cli_version=identity["cli_version"],
+        model_provider=identity["model_provider"],
+        lifecycle=lifecycle["state"],
+        turn_id=lifecycle["turn_id"],
+        pending=tuple(CodexPendingItem(**item) for item in payload["pending"]),
+        last_event_epoch=payload["last_event_epoch"],
+        usage=CodexUsage(**usage) if usage is not None else None,
+    )

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/cc_transcript/discovery.py

@@ -96,7 +96,8 @@ def resolve(session_id: SessionId, *, root: Path | None = None) -> Path | None:
     A successful lookup is memoized in ``TRANSCRIPT_MEMO`` under
     ``(session_id, resolved root)`` and revalidated on the next hit, so a
     repeated probe skips the recursive scan while a pruned transcript still
-    forces a fresh one.
+    forces a fresh one. When the projects tree yields nothing, the codex
+    sessions tree is tried as a fallback, so a codex session id resolves too.
 
     Returns:
         The newest-mtime real path, or None when no transcript exists.
@@ -105,8 +106,11 @@ def resolve(session_id: SessionId, *, root: Path | None = None) -> Path | None:
     key = (session_id, base.resolve())
     if (cached := TRANSCRIPT_MEMO.get(key)) is not None and cached.exists():
         return cached
-    if (hit := _native.discovery_find_transcript(base, session_id)) is None:
-        return None
+    hit = _native.discovery_find_transcript(base, session_id)
+    if hit is None:
+        from cc_transcript import codex
+
+        return codex.find_transcript(session_id)
     TRANSCRIPT_MEMO[key] = hit
     return hit
 

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/cc_transcript/judge/verdicts.py

@@ -334,6 +334,7 @@ async def run_verdicts[V](
     """
     counts = {"judged": 0, "failed": 0}
     limiter = asyncio.Semaphore(concurrency)
+    persister = asyncio.Lock()
 
     async def worker(row: Mapping[str, object]) -> None:
         async with limiter:
@@ -342,7 +343,11 @@ async def run_verdicts[V](
             except JudgeError:
                 counts["failed"] += 1
                 return
-        await persist(row, verdict)
+        # The store's transaction is exclusive by contract; persists serialize on
+        # this lock so concurrent workers never race record_verdict into a
+        # TransactionConflictError. Judge concurrency is untouched.
+        async with persister:
+            await persist(row, verdict)
         counts["judged"] += 1
 
     async with asyncio.TaskGroup() as tg:

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.6.0" # informational — releases stamp the version from the git tag
+version = "14.6.1" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/rust/crates/core/src/codex/discovery.rs

@@ -46,12 +46,7 @@ pub fn resolve(session_id: &str, root: &Path) -> Option<PathBuf> {
     found
         .iter()
         .find(|rollout| rollout.session_id == session_id && !rollout.compressed)
-        .or_else(|| {
-            found
-                .iter()
-                .find(|rollout| rollout.session_id == session_id)
-        })
-        .map(|rollout| rollout.path.clone())
+        .and_then(|rollout| fs::canonicalize(&rollout.path).ok())
 }
 
 fn walk(dir: &Path, visit: &mut impl FnMut(&Path)) {
@@ -173,20 +168,43 @@ mod tests {
         );
         assert_eq!(
             resolve("019b7000-0000-7000-8000-000000000002", &root),
-            Some(twin.clone())
+            Some(fs::canonicalize(&twin).unwrap())
         );
         fs::remove_file(twin).unwrap();
-        assert_eq!(
-            resolve("019b7000-0000-7000-8000-000000000002", &root),
-            Some(twin_zst)
-        );
+        assert_eq!(resolve("019b7000-0000-7000-8000-000000000002", &root), None);
         assert_eq!(
             resolve("019b7000-0000-7000-8000-000000000001", &root),
-            Some(oldest)
+            Some(fs::canonicalize(oldest).unwrap())
         );
         assert_eq!(resolve("019b7000-0000-7000-8000-000000000099", &root), None);
         assert_eq!(sessions_root(Some(&root)), root);
         assert!(sessions_root(None).ends_with(".codex/sessions"));
         fs::remove_dir_all(&root).ok();
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn resolve_returns_canonical_path_through_symlinked_root() {
+        let base = std::env::temp_dir().join(format!(
+            "codex-discovery-symlink-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        fs::remove_dir_all(&base).ok();
+        fs::create_dir_all(&base).unwrap();
+        let root = base.join("sessions");
+        let rollout = touch(
+            &root,
+            "2026/01/02/rollout-2026-01-02T03-04-05-019b7000-0000-7000-8000-000000000003.jsonl",
+        );
+        let linked_root = base.join("linked-sessions");
+        std::os::unix::fs::symlink(&root, &linked_root).unwrap();
+
+        assert_eq!(
+            resolve("019b7000-0000-7000-8000-000000000003", &linked_root),
+            Some(fs::canonicalize(rollout).unwrap())
+        );
+
+        fs::remove_dir_all(&base).ok();
+    }
 }

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/rust/crates/core/src/codex/probe.rs

@@ -21,6 +21,27 @@ pub enum Lifecycle {
     },
 }
 
+impl Lifecycle {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Lifecycle::Uninitialized => "uninitialized",
+            Lifecycle::NoInstrumentation => "no_instrumentation",
+            Lifecycle::Open { .. } => "open",
+            Lifecycle::Completed { .. } => "completed",
+            Lifecycle::Aborted { .. } => "aborted",
+        }
+    }
+
+    pub fn turn_id(&self) -> Option<&str> {
+        match self {
+            Lifecycle::Open { turn_id }
+            | Lifecycle::Completed { turn_id }
+            | Lifecycle::Aborted { turn_id, .. } => turn_id.as_deref(),
+            Lifecycle::Uninitialized | Lifecycle::NoInstrumentation => None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum TurnState {
     Open,

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/rust/crates/core/src/gateway.rs

@@ -23,6 +23,15 @@ pub enum Provider {
     Codex,
 }
 
+impl Provider {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Provider::Claude => "claude",
+            Provider::Codex => "codex",
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ParsedTranscript {
     pub provider: Provider,

cc_transcript-14.6.1/rust/crates/py/src/codex.rs

@@ -0,0 +1,144 @@
+//! pyo3 exposure of the codex session surface: discovery, resolution, and the
+//! per-rollout session-info fold the Python `cc_transcript.codex` facade
+//! rehydrates. Paths cross as PathBuf, matching the CC discovery facade.
+
+use std::path::PathBuf;
+
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList};
+
+use cc_transcript_core::activity::PendingItem;
+use cc_transcript_core::codex::{
+    self, lower, parse_codex_bytes, session_probe, CodexItem, CodexSession, CodexUsageAggregate,
+    Lifecycle,
+};
+
+struct CodexInfo {
+    rollout_thread_id: Option<String>,
+    session_id: Option<String>,
+    parent_thread_id: Option<String>,
+    forked_from_id: Option<String>,
+    cwd: Option<String>,
+    originator: Option<String>,
+    cli_version: Option<String>,
+    model_provider: Option<String>,
+    lifecycle: Lifecycle,
+    pending: Vec<PendingItem>,
+    last_event_epoch: Option<i64>,
+    usage: CodexUsageAggregate,
+}
+
+fn session_meta_provider(session: &CodexSession) -> Option<String> {
+    session
+        .entries
+        .iter()
+        .find_map(|entry| match &entry.item {
+            CodexItem::SessionMeta(m) if m.id.as_deref().is_some_and(|id| !id.is_empty()) => {
+                Some(m)
+            }
+            _ => None,
+        })
+        .and_then(|m| m.model_provider.clone())
+}
+
+fn read_info(path: &str) -> std::io::Result<CodexInfo> {
+    let session = parse_codex_bytes(&std::fs::read(path)?);
+    let probe = session_probe(&session);
+    let usage = lower(&session).usage;
+    let model_provider = session_meta_provider(&session);
+    Ok(CodexInfo {
+        rollout_thread_id: session.rollout_thread_id,
+        session_id: session.session_id,
+        parent_thread_id: session.parent_thread_id,
+        forked_from_id: session.forked_from_id,
+        cwd: session.cwd,
+        originator: session.originator,
+        cli_version: session.cli_version,
+        model_provider,
+        lifecycle: probe.lifecycle,
+        pending: probe.pending,
+        last_event_epoch: probe.last_event_epoch,
+        usage,
+    })
+}
+
+fn identity_dict<'py>(py: Python<'py>, info: &CodexInfo) -> PyResult<Bound<'py, PyDict>> {
+    let dict = PyDict::new(py);
+    dict.set_item("rollout_thread_id", info.rollout_thread_id.as_deref())?;
+    dict.set_item("session_id", info.session_id.as_deref())?;
+    dict.set_item("parent_thread_id", info.parent_thread_id.as_deref())?;
+    dict.set_item("forked_from_id", info.forked_from_id.as_deref())?;
+    dict.set_item("cwd", info.cwd.as_deref())?;
+    dict.set_item("originator", info.originator.as_deref())?;
+    dict.set_item("cli_version", info.cli_version.as_deref())?;
+    dict.set_item("model_provider", info.model_provider.as_deref())?;
+    Ok(dict)
+}
+
+fn pending_list<'py>(py: Python<'py>, pending: &[PendingItem]) -> PyResult<Bound<'py, PyList>> {
+    PyList::new(
+        py,
+        pending
+            .iter()
+            .map(|item| {
+                let entry = PyDict::new(py);
+                entry.set_item("tool_use_id", item.tool_use_id.as_deref())?;
+                entry.set_item("name", &item.name)?;
+                entry.set_item("kind", item.kind.as_str())?;
+                Ok(entry)
+            })
+            .collect::<PyResult<Vec<_>>>()?,
+    )
+}
+
+fn usage_dict<'py>(
+    py: Python<'py>,
+    usage: &CodexUsageAggregate,
+) -> PyResult<Option<Bound<'py, PyDict>>> {
+    if usage.token_count_events == 0 {
+        return Ok(None);
+    }
+    let dict = PyDict::new(py);
+    dict.set_item("input_tokens", usage.input_tokens)?;
+    dict.set_item("cached_input_tokens", usage.cached_input_tokens)?;
+    dict.set_item("output_tokens", usage.output_tokens)?;
+    dict.set_item("reasoning_output_tokens", usage.reasoning_output_tokens)?;
+    dict.set_item("total_tokens", usage.total_tokens)?;
+    dict.set_item("model_context_window", usage.model_context_window)?;
+    dict.set_item("token_count_events", usage.token_count_events)?;
+    Ok(Some(dict))
+}
+
+#[pyo3_stub_gen::derive::gen_stub_pyfunction]
+#[pyfunction]
+#[gen_stub(override_return_type(type_repr = "dict[str, typing.Any]", imports = ("typing",)))]
+pub fn codex_session_info<'py>(py: Python<'py>, path: String) -> PyResult<Bound<'py, PyDict>> {
+    let info = py.detach(|| read_info(&path))?;
+    let out = PyDict::new(py);
+    out.set_item("identity", identity_dict(py, &info)?)?;
+    let lifecycle = PyDict::new(py);
+    lifecycle.set_item("state", info.lifecycle.as_str())?;
+    lifecycle.set_item("turn_id", info.lifecycle.turn_id())?;
+    out.set_item("lifecycle", lifecycle)?;
+    out.set_item("pending", pending_list(py, &info.pending)?)?;
+    out.set_item("last_event_epoch", info.last_event_epoch)?;
+    out.set_item("usage", usage_dict(py, &info.usage)?)?;
+    Ok(out)
+}
+
+#[pyo3_stub_gen::derive::gen_stub_pyfunction]
+#[pyfunction]
+#[pyo3(signature = (root=None))]
+pub fn codex_discover(root: Option<PathBuf>) -> Vec<(PathBuf, String, bool)> {
+    codex::discover(&codex::sessions_root(root.as_deref()))
+        .into_iter()
+        .map(|rollout| (rollout.path, rollout.session_id, rollout.compressed))
+        .collect()
+}
+
+#[pyo3_stub_gen::derive::gen_stub_pyfunction]
+#[pyfunction]
+#[pyo3(signature = (session_id, root=None))]
+pub fn codex_resolve(session_id: &str, root: Option<PathBuf>) -> Option<PathBuf> {
+    codex::resolve(session_id, &codex::sessions_root(root.as_deref()))
+}

{cc_transcript-14.6.0 → cc_transcript-14.6.1}/rust/crates/py/src/lib.rs

@@ -4,6 +4,7 @@ pub fn stub_info() -> pyo3_stub_gen::Result<pyo3_stub_gen::StubInfo> {
 }
 
 mod actor_bridge;
+mod codex;
 mod command;
 mod context;
 mod corrections;