cc-transcript 14.16.1__tar.gz → 14.18.0__tar.gz

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/PKG-INFO

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

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/cc_transcript/__init__.py

@@ -197,6 +197,7 @@ EXPORTS: dict[str, str] = {
             "Lifecycle",
         ),
         "cc_transcript.activity": (
+            "ActivityLift",
             "Edit",
             "SessionActivity",
             "ToolUse",
@@ -240,6 +241,7 @@ EXPORTS: dict[str, str] = {
             "DeepSession",
             "DeepView",
             "FileRef",
+            "PredicateInputs",
             "Session",
             "SubagentIndex",
             "SubagentSession",

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/cc_transcript/__init__.pyi

@@ -2,6 +2,7 @@
 # isort: off
 
 from cc_transcript.activity import (
+    ActivityLift as ActivityLift,
     Edit as Edit,
     SessionActivity as SessionActivity,
     ToolUse as ToolUse,
@@ -207,6 +208,7 @@ from cc_transcript.query import (
     DeepSession as DeepSession,
     DeepView as DeepView,
     FileRef as FileRef,
+    PredicateInputs as PredicateInputs,
     Session as Session,
     SubagentIndex as SubagentIndex,
     SubagentSession as SubagentSession,
@@ -304,6 +306,7 @@ EXPORTS: dict[str, str]
 __all__ = [
     "ASSISTANTS",
     "Action",
+    "ActivityLift",
     "ApiError",
     "ApplyPatchCall",
     "AskUserQuestionResult",
@@ -390,6 +393,7 @@ __all__ = [
     "PRICING",
     "PatchEdit",
     "Plugin",
+    "PredicateInputs",
     "PreservedMessages",
     "PreservedSegment",
     "PrintMessage",

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/cc_transcript/_native.pyi

@@ -108,6 +108,7 @@ __all__ = [
     "activity_hunk_overlap",
     "activity_lift",
     "activity_lift_from_events",
+    "activity_lift_tail",
     "activity_overlap_between",
     "activity_parse_show_hunks",
     "bucket_events_from_events",
@@ -2295,6 +2296,8 @@ def activity_lift(path: builtins.str, max_events: builtins.int) -> dict[str, typ
 
 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_lift_tail(events: list[models.TranscriptEvent], opener_flags: typing.Optional[typing.Sequence[builtins.bool]] = None, open_turn: builtins.bool = False) -> 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]]: ...

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/cc_transcript/activity.py

@@ -13,8 +13,8 @@ products.
 from __future__ import annotations
 
 from collections.abc import Callable
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any
 
 from cc_transcript import _native
 from cc_transcript.discovery import TranscriptExpiredError, resolve
@@ -25,7 +25,7 @@ from cc_transcript.parser import parse
 from cc_transcript.tools import edits_of, parse_tool_call, parse_tool_result
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Mapping, Sequence
     from datetime import datetime
     from pathlib import Path
 
@@ -181,64 +181,10 @@ class SessionActivity:
         turn; everything else folds into the current one. Events before the
         first qualifying prompt form turn 0 with prompt ``""``.
         """
-        evs = list(events)
-        opener_flags = (
-            None
-            if user_classifier is native_user_classifier
-            else [bool(user_classifier(event)) if isinstance(event, UserEvent) else False for event in evs]
+        return cls(
+            session_id=session_id,
+            turns=ActivityLift(session_id, user_classifier=user_classifier).extend(events).turns,
         )
-        tool_blocks = {
-            event_idx: tuple(block for block in event.blocks if isinstance(block, ToolUseBlock))
-            for event_idx, event in enumerate(evs)
-            if isinstance(event, AssistantEvent)
-        }
-        tool_block_positions: dict[int, int] = {}
-        turns: list[Turn] = []
-        for index, skeleton in enumerate(_native.activity_lift_from_events(evs, opener_flags)):
-            tool_uses: list[ToolUse] = []
-            for use in skeleton["tool_uses"]:
-                event_idx = use["event_idx"]
-                event = evs[event_idx]
-                block_position = tool_block_positions.get(event_idx, 0)
-                block = tool_blocks[event_idx][block_position]
-                tool_block_positions[event_idx] = block_position + 1
-                result_event_idx = use["result_event_idx"]
-                if result_event_idx is None:
-                    result = None
-                    result_ts = None
-                else:
-                    result_event = evs[result_event_idx]
-                    result = next(
-                        candidate
-                        for candidate in reversed(result_event.blocks)
-                        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=call,
-                        result=result,
-                        result_ts=result_ts,
-                        edits=edits_of(call),
-                        turn_index=index,
-                        ts=event.meta.timestamp,
-                    )
-                )
-            started_idx = skeleton["started_idx"]
-            ended_idx = skeleton["ended_idx"]
-            turns.append(
-                Turn(
-                    index=index,
-                    prompt=skeleton["prompt"],
-                    started_at=None if started_idx is None else evs[started_idx].meta.timestamp,
-                    ended_at=None if ended_idx is None else evs[ended_idx].meta.timestamp,
-                    events=tuple(evs[skeleton["start"] : skeleton["end"]]),
-                    tool_uses=tuple(tool_uses),
-                )
-            )
-        return cls(session_id=session_id, turns=tuple(turns))
 
     @classmethod
     def from_session(
@@ -326,6 +272,174 @@ class SessionActivity:
         return tuple(same_turn + later)
 
 
+class ActivityLift:
+    """A session's lift that grows with its transcript.
+
+    Each :meth:`extend` folds the events appended since the previous call into
+    the activity lifted so far: closed turns are kept, the open turn grows by
+    the appended events alone, and a tool use whose result arrives in the tail
+    is re-paired wherever it sits. The result always equals
+    :meth:`SessionActivity.from_events` over every event fed so far. A step
+    costs the appended events, the tool uses they re-pair, and copies of the
+    turn tuple and of the open turn's event and tool-use tuples; it never
+    re-derives the session.
+
+    Feed only the events appended since the previous call: nothing checks
+    provenance, so events fed twice lift twice. A transcript rewritten in
+    place, rather than appended to, needs a new cursor.
+
+    The classifier is read once, at construction, and must be deterministic
+    and event-only: its answer for an event has to stay the same as later
+    events are appended, since turns lifted under it are never revisited.
+
+    Example:
+        >>> lift = ActivityLift(session_id)
+        >>> activity = lift.extend(events)
+        >>> lift.extend(appended) == SessionActivity.from_events(session_id, [*events, *appended])
+        True
+    """
+
+    __slots__ = ("_activity", "_results", "_session_id", "_user_classifier", "_uses")
+
+    def __init__(self, session_id: SessionId, *, user_classifier: UserClassifier = native_user_classifier) -> None:
+        self._session_id = session_id
+        self._user_classifier = user_classifier
+        self._activity = SessionActivity(session_id=session_id, turns=())
+        self._uses: dict[ToolUseId, tuple[tuple[int, int], ...]] = {}
+        self._results: dict[ToolUseId, UserEvent] = {}
+
+    @property
+    def session_id(self) -> SessionId:
+        """The session being lifted."""
+        return self._session_id
+
+    @property
+    def user_classifier(self) -> UserClassifier:
+        """Decides which user events open turns."""
+        return self._user_classifier
+
+    @property
+    def activity(self) -> SessionActivity:
+        """Everything lifted so far."""
+        return self._activity
+
+    def extend(self, events: Sequence[TranscriptEvent]) -> SessionActivity:
+        """Lifts ``events``, appended after everything fed so far, into :attr:`activity`."""
+        tail = list(events)
+        if not tail:
+            return self._activity
+        opener_flags = (
+            None
+            if self._user_classifier is native_user_classifier
+            else [bool(self._user_classifier(event)) if isinstance(event, UserEvent) else False for event in tail]
+        )
+        turns = list(self._activity.turns)
+        lifted = _native.activity_lift_tail(tail, opener_flags, open_turn=bool(turns))
+        first = len(turns) - 1 if lifted["continued"] else len(turns)
+        grown = [
+            lift_turn(self._session_id, first + offset, skeleton, tail, self._results)
+            for offset, skeleton in enumerate(lifted["turns"])
+        ]
+        if lifted["continued"]:
+            turns[-1] = continued(turns[-1], grown[0])
+            turns.extend(grown[1:])
+        else:
+            turns.extend(grown)
+        repairs: dict[int, dict[int, UserEvent]] = {}
+        for tool_use_id, result_idx in lifted["results"]:
+            for turn_index, position in self._uses.get(tool_use_id, ()):
+                repairs.setdefault(turn_index, {})[position] = tail[result_idx]
+            self._results[tool_use_id] = tail[result_idx]
+        for turn_index, at in repairs.items():
+            turns[turn_index] = repaired(turns[turn_index], at)
+        for turn in grown:
+            base = len(turns[turn.index].tool_uses) - len(turn.tool_uses)
+            for position, use in enumerate(turn.tool_uses, base):
+                self._uses[use.ref.tool_use_id] = (*self._uses.get(use.ref.tool_use_id, ()), (turn.index, position))
+        self._activity = SessionActivity(session_id=self._session_id, turns=tuple(turns))
+        return self._activity
+
+
+def lift_turn(
+    session_id: SessionId,
+    index: int,
+    skeleton: dict[str, Any],
+    evs: Sequence[TranscriptEvent],
+    prior_results: Mapping[ToolUseId, UserEvent],
+) -> Turn:
+    events = tuple(evs[skeleton["start"] : skeleton["end"]])
+    calls = [
+        (event, block)
+        for event in events
+        if isinstance(event, AssistantEvent)
+        for block in event.blocks
+        if isinstance(block, ToolUseBlock)
+    ]
+    started_idx = skeleton["started_idx"]
+    ended_idx = skeleton["ended_idx"]
+    return Turn(
+        index=index,
+        prompt=skeleton["prompt"],
+        started_at=None if started_idx is None else evs[started_idx].meta.timestamp,
+        ended_at=None if ended_idx is None else evs[ended_idx].meta.timestamp,
+        events=events,
+        tool_uses=tuple(
+            lift_tool_use(
+                session_id,
+                index,
+                event,
+                block,
+                prior_results.get(block.id) if (result_idx := use["result_event_idx"]) is None else evs[result_idx],
+            )
+            for (event, block), use in zip(calls, skeleton["tool_uses"], strict=True)
+        ),
+    )
+
+
+def lift_tool_use(
+    session_id: SessionId, turn_index: int, event: AssistantEvent, block: ToolUseBlock, result_event: UserEvent | None
+) -> ToolUse:
+    call = parse_tool_call(block.name, block.input, on_error="other")
+    return ToolUse(
+        ref=EventRef(session_id, event.meta.uuid, block.id),
+        call=call,
+        result=None if result_event is None else result_block(result_event, block.id),
+        result_ts=None if result_event is None else result_event.meta.timestamp,
+        edits=edits_of(call),
+        turn_index=turn_index,
+        ts=event.meta.timestamp,
+    )
+
+
+def result_block(event: UserEvent, tool_use_id: ToolUseId) -> ToolResultBlock:
+    return next(
+        candidate
+        for candidate in reversed(event.blocks)
+        if isinstance(candidate, ToolResultBlock) and candidate.tool_use_id == tool_use_id
+    )
+
+
+def continued(turn: Turn, tail: Turn) -> Turn:
+    return replace(
+        turn,
+        started_at=tail.started_at if turn.started_at is None else turn.started_at,
+        ended_at=turn.ended_at if tail.ended_at is None else tail.ended_at,
+        events=turn.events + tail.events,
+        tool_uses=turn.tool_uses + tail.tool_uses,
+    )
+
+
+def repaired(turn: Turn, at: Mapping[int, UserEvent]) -> Turn:
+    uses = list(turn.tool_uses)
+    for position, event in at.items():
+        uses[position] = replace(
+            uses[position],
+            result=result_block(event, uses[position].ref.tool_use_id),
+            result_ts=event.meta.timestamp,
+        )
+    return replace(turn, tool_uses=tuple(uses))
+
+
 def hunk_overlap(a: Hunk, b: Hunk) -> float:
     """The fraction of ``a.new``'s non-empty lines present in ``b.old``.
 

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/cc_transcript/query.py

@@ -106,6 +106,61 @@ no longer fits on every walk.
 """
 
 
+SIDECHAIN_INPUTS_LIMIT = 16384
+
+
+@dataclass(slots=True)
+class PredicateInputsCache:
+    held: OrderedDict[Path, tuple[LiftStamp, PredicateInputs]] = field(default_factory=OrderedDict)
+    guard: threading.Lock = field(default_factory=threading.Lock)
+
+    def get(self, path: Path, stamp: LiftStamp) -> PredicateInputs | None:
+        with self.guard:
+            match self.held.get(path):
+                case (held_stamp, inputs) if held_stamp == stamp:
+                    self.held.move_to_end(path)
+                    return inputs
+                case _:
+                    return None
+
+    def put(self, path: Path, stamp: LiftStamp, inputs: PredicateInputs) -> PredicateInputs:
+        with self.guard:
+            self.held[path] = (stamp, inputs)
+            self.held.move_to_end(path)
+            while len(self.held) > SIDECHAIN_INPUTS_LIMIT:
+                self.held.popitem(last=False)
+        return inputs
+
+    def clear(self) -> None:
+        with self.guard:
+            self.held.clear()
+
+    def __len__(self) -> int:
+        return len(self.held)
+
+
+SIDECHAIN_INPUTS = PredicateInputsCache()
+"""Each sidechain's :class:`PredicateInputs`, keyed by path and stamped like :data:`DEEP_LIFTS`.
+
+A lifted session costs about 2.3 times its source bytes, so a tree of a thousand sidechains
+cannot stay lifted; its :class:`PredicateInputs` are a few kilobytes each. A predicate lifts a
+sidechain only when its stamp moved, keeps those inputs, and lets the lift go, so a resident
+process re-answering the same predicates per event neither reparses nor holds the tree.
+"""
+
+
+SIDECHAIN_LISTINGS: OrderedDict[Path, tuple[tuple[int, int], tuple[tuple[Path, bool], ...]]] = OrderedDict()
+"""Each non-empty ``subagents`` listing and whether each file is a symlink, stamped ``(inode, mtime_ns)``.
+
+Adding, removing, renaming, or replacing a sidechain moves the directory's mtime, so an unchanged
+stamp proves the listing current. A walk then skips the directory read and resolves the directory
+once rather than every file; only a symlinked sidechain is resolved on every walk. An empty listing
+is never held, since the native lister reports an unreadable directory as empty.
+"""
+
+SIDECHAIN_LISTINGS_GUARD = threading.Lock()
+
+
 def is_failure(use: ToolUse) -> bool:
     return use.result is not None and use.result.is_error
 
@@ -256,8 +311,12 @@ class ToolCallQuery:
         callable predicate, or a value compared for equality.
         """
         return self.where(
-            lambda use: isinstance(use.call.raw, Mapping)
-            and all(key in use.call.raw and input_rule_matches(rule, use.call.raw[key]) for key, rule in rules.items())
+            lambda use: (
+                isinstance(use.call.raw, Mapping)
+                and all(
+                    key in use.call.raw and input_rule_matches(rule, use.call.raw[key]) for key, rule in rules.items()
+                )
+            )
         )
 
     def count(self) -> int:
@@ -488,9 +547,7 @@ class Session:
 
     def has_tool(self, name: str, *, subagents: bool = True) -> bool:
         """Whether any call in the window matches the pipe spec ``name``."""
-        return self.tool_calls.named(name).any() or (
-            subagents and any(deep.session.has_tool(name, subagents=False) for deep in self.walk())
-        )
+        return any_inputs(self, lambda inputs: inputs.has_tool(name), subagents=subagents)
 
     def has_command(self, *argv: str, subagents: bool = True) -> bool:
         """Whether any Bash command in the window runs ``argv``.
@@ -499,28 +556,36 @@ class Session:
         unwrapped argv, so ``has_command("git", "push")`` matches
         ``sudo git push -f`` and ``cd x && git push`` but not ``echo "git push"``.
         """
-        return any(cmd.runs(*argv) for line in self.command_lines() for cmd in line) or (
-            subagents and any(deep.session.has_command(*argv, subagents=False) for deep in self.walk())
-        )
+        return any_inputs(self, lambda inputs: inputs.has_command(argv), subagents=subagents)
 
     def has_edit_to(self, *globs: str, subagents: bool = True) -> bool:
         """Whether any edit-shaped call in the window targets a file matching any glob."""
-        return any(file.matches(*globs) for file in self.edited_files) or (
-            subagents and any(deep.session.has_edit_to(*globs, subagents=False) for deep in self.walk())
-        )
+        return any_inputs(self, lambda inputs: inputs.has_edit_to(globs), subagents=subagents)
 
     def has_read(self, pattern: str, *, subagents: bool = True) -> bool:
         """Whether any Read in the window targets a path containing ``pattern``."""
-        return any(pattern in str(file) for file in self.tool_calls.named("Read").files()) or (
-            subagents and any(deep.session.has_read(pattern, subagents=False) for deep in self.walk())
-        )
+        return any_inputs(self, lambda inputs: inputs.has_read(pattern), subagents=subagents)
 
     def has_skill(self, *names: str, subagents: bool = True) -> bool:
         """Whether any Skill invocation in the window names one of ``names``."""
-        return any(
-            isinstance(call := use.call, SkillCall) and call.skill in names
-            for use in self.tool_calls.named("Skill")
-        ) or (subagents and any(deep.session.has_skill(*names, subagents=False) for deep in self.walk()))
+        return any_inputs(self, lambda inputs: inputs.has_skill(names), subagents=subagents)
+
+    @cached_property
+    def predicate_inputs(self) -> PredicateInputs:
+        """What the ``has_*`` predicates read from this window."""
+        return PredicateInputs.of(self)
+
+    def deep_inputs(self) -> Iterator[PredicateInputs]:
+        """This window's :class:`PredicateInputs`, then those of every transcript :meth:`walk` reaches.
+
+        The walk order and dedupe match :meth:`walk`, but no reached transcript stays lifted: each
+        one's inputs are held per ``(size, mtime, inode)`` stamp, and a transcript is reparsed only
+        once its stamp moves. Prefer it to :meth:`walk` for any predicate these inputs can answer.
+        """
+        yield self.predicate_inputs
+        for path, depth, spawned_by in reachable_transcripts(self):
+            if (inputs := load_predicate_inputs(path, depth, spawned_by)) is not None:
+                yield inputs
 
     def has_override(self, token: str, *, invalidated_by: Sequence[str] = ("Edit", "Write")) -> bool:
         """Whether ``token`` appears in the window without a later invalidating call.
@@ -570,9 +635,7 @@ class Session:
 
     @cached_property
     def _command_lines(self) -> tuple[CommandLine, ...]:
-        from cc_transcript.command import parse_command_line
-
-        return tuple(parse_command_line(command) for command in self._commands)
+        return self.predicate_inputs.command_lines
 
     def __len__(self) -> int:
         return sum(len(turn.events) for turn in self.turns)
@@ -653,6 +716,83 @@ class DeepSession:
     spawned_by: ToolUseId | None
 
 
+@dataclass(frozen=True)  # non-slots: the cached_property below needs __dict__
+class PredicateInputs:
+    """The slice of one transcript window that the ``has_*`` predicates read.
+
+    Small enough to hold for every transcript in a tree of thousands, where a lifted
+    :class:`Session` is not. Calls whose result errored are left out, as
+    :class:`ToolCallQuery` hides them by default. Answers that do not depend on the MCP
+    tool registry are memoized, up to :attr:`MAX_ANSWERS` per instance.
+
+    Attributes:
+        calls: Each call's tool name and the file paths it targets, in order.
+        commands: The command string of every Bash call.
+        edited_files: The files modified by edit-shaped calls, one entry per edited file.
+        skills: The skill named by every Skill call.
+    """
+
+    calls: tuple[tuple[str, tuple[str, ...]], ...]
+    commands: tuple[str, ...]
+    edited_files: tuple[FileRef, ...]
+    skills: tuple[str, ...]
+    answers: dict[tuple[str, object], bool] = field(default_factory=dict, compare=False, repr=False)
+
+    MAX_ANSWERS: ClassVar[int] = 256
+
+    @classmethod
+    def of(cls, session: Session) -> PredicateInputs:
+        """Extracts the predicate inputs from ``session``'s window."""
+        calls = session.tool_calls
+        return cls(
+            calls=tuple((use.call.name, tuple(file_paths_of(use.call))) for use in calls.items),
+            commands=session.commands(),
+            edited_files=session.edited_files,
+            skills=tuple(call.skill for use in calls.named("Skill") if isinstance(call := use.call, SkillCall)),
+        )
+
+    @cached_property
+    def command_lines(self) -> tuple[CommandLine, ...]:
+        """:attr:`commands` parsed into :class:`~cc_transcript.command.CommandLine` objects."""
+        from cc_transcript.command import parse_command_line
+
+        return tuple(parse_command_line(command) for command in self.commands)
+
+    @cached_property
+    def tool_names(self) -> frozenset[str]:
+        """The distinct names in :attr:`calls`."""
+        return frozenset(name for name, _ in self.calls)
+
+    def files(self, spec: str) -> tuple[FileRef, ...]:
+        """The files targeted by calls matching the pipe spec ``spec``, one entry per path."""
+        matching = {name for name in self.tool_names if tool_name_matches(name, spec)}
+        return tuple(FileRef(path) for name, paths in self.calls if name in matching for path in paths)
+
+    def answer(self, query: tuple[str, object], compute: Callable[[], bool]) -> bool:
+        if (known := self.answers.get(query)) is None:
+            if len(self.answers) >= self.MAX_ANSWERS:
+                self.answers.clear()
+            known = self.answers[query] = compute()
+        return known
+
+    def has_tool(self, name: str) -> bool:
+        return any(tool_name_matches(tool, name) for tool in self.tool_names)
+
+    def has_command(self, argv: tuple[str, ...]) -> bool:
+        return self.answer(
+            ("command", argv), lambda: any(cmd.runs(*argv) for line in self.command_lines for cmd in line)
+        )
+
+    def has_edit_to(self, globs: tuple[str, ...]) -> bool:
+        return self.answer(("edit", globs), lambda: any(file.matches(*globs) for file in self.edited_files))
+
+    def has_read(self, pattern: str) -> bool:
+        return any(pattern in str(file) for file in self.files("Read"))
+
+    def has_skill(self, names: tuple[str, ...]) -> bool:
+        return self.answer(("skill", names), lambda: any(skill in names for skill in self.skills))
+
+
 @dataclass(frozen=True)  # non-slots: the cached_property below needs __dict__
 class DeepView:
     """The recursive union of a session and every transcript reachable from it.
@@ -714,26 +854,75 @@ def sidechain_sessions(path: Path | None) -> tuple[Session, ...]:
     return tuple(Session.from_path(entry) for entry in subagent_paths(path))
 
 
-def deep_sessions(root: Session) -> Iterator[DeepSession]:
+def any_inputs(session: Session, predicate: Callable[[PredicateInputs], bool], *, subagents: bool) -> bool:
+    return any(map(predicate, session.deep_inputs() if subagents else (session.predicate_inputs,)))
+
+
+def reachable_transcripts(root: Session) -> Iterator[tuple[Path, int, ToolUseId | None]]:
     seen: set[Path] = {root.path.resolve()} if root.path is not None else set()
     if root.path is not None:
-        yield from descend_sidechains(root.path, 1, seen)
+        yield from reachable_sidechains(root.path, 1, seen)
     for attachment in root.attachments:
-        yield from visit_transcript(attachment, 1, None, seen)
+        yield from reachable_from(attachment, attachment.resolve(), 1, None, seen)
 
 
-def descend_sidechains(parent: Path, depth: int, seen: set[Path]) -> Iterator[DeepSession]:
-    for child in subagent_paths(parent):
-        yield from visit_transcript(child, depth, ToolUseId(child.stem.removeprefix("agent-")), seen)
+def reachable_sidechains(parent: Path, depth: int, seen: set[Path]) -> Iterator[tuple[Path, int, ToolUseId | None]]:
+    for child, resolved in sidechain_listing(parent):
+        yield from reachable_from(child, resolved, depth, ToolUseId(child.stem.removeprefix("agent-")), seen)
 
 
-def visit_transcript(path: Path, depth: int, spawned_by: ToolUseId | None, seen: set[Path]) -> Iterator[DeepSession]:
-    if (resolved := path.resolve()) in seen:
+def reachable_from(
+    path: Path, resolved: Path, depth: int, spawned_by: ToolUseId | None, seen: set[Path]
+) -> Iterator[tuple[Path, int, ToolUseId | None]]:
+    if resolved in seen:
         return
     seen.add(resolved)
-    if (deep := load_deep_session(path, depth, spawned_by)) is not None:
-        yield deep
-    yield from descend_sidechains(path, depth + 1, seen)
+    yield path, depth, spawned_by
+    yield from reachable_sidechains(path, depth + 1, seen)
+
+
+def sidechain_listing(parent: Path) -> tuple[tuple[Path, Path], ...]:
+    directory = parent.parent / parent.stem / "subagents"
+    try:
+        stat = directory.stat()
+    except OSError:
+        return ()
+    stamp = (stat.st_ino, stat.st_mtime_ns)
+    with SIDECHAIN_LISTINGS_GUARD:
+        held = SIDECHAIN_LISTINGS.get(directory)
+    if held is not None and held[0] == stamp:
+        children = held[1]
+    else:
+        children = tuple((child, child.is_symlink()) for child in subagent_paths(parent))
+        if children:
+            with SIDECHAIN_LISTINGS_GUARD:
+                SIDECHAIN_LISTINGS[directory] = (stamp, children)
+                SIDECHAIN_LISTINGS.move_to_end(directory)
+                while len(SIDECHAIN_LISTINGS) > SIDECHAIN_INPUTS_LIMIT:
+                    SIDECHAIN_LISTINGS.popitem(last=False)
+    real = directory.resolve()
+    return tuple((child, child.resolve() if link else real / child.name) for child, link in children)
+
+
+def load_predicate_inputs(path: Path, depth: int, spawned_by: ToolUseId | None) -> PredicateInputs | None:
+    try:
+        stat = path.stat()
+    except OSError:
+        return None
+    stamp = (stat.st_size, stat.st_mtime_ns, stat.st_ino)
+    if (held := SIDECHAIN_INPUTS.get(path, stamp)) is not None:
+        return held
+    try:
+        deep = DEEP_LIFTS.get((path, depth, spawned_by), stamp) or lift_deep_session(path, depth, spawned_by)
+    except OSError:
+        return None
+    return SIDECHAIN_INPUTS.put(path, stamp, PredicateInputs.of(deep.session))
+
+
+def deep_sessions(root: Session) -> Iterator[DeepSession]:
+    for path, depth, spawned_by in reachable_transcripts(root):
+        if (deep := load_deep_session(path, depth, spawned_by)) is not None:
+            yield deep
 
 
 def lift_deep_session(path: Path, depth: int, spawned_by: ToolUseId | None) -> DeepSession:

{cc_transcript-14.16.1 → cc_transcript-14.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.16.1" # informational — releases stamp the version from the git tag
+version = "14.18.0" # 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"