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

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

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

{cc_transcript-14.17.0 → 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",

{cc_transcript-14.17.0 → 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,
@@ -305,6 +306,7 @@ EXPORTS: dict[str, str]
 __all__ = [
     "ASSISTANTS",
     "Action",
+    "ActivityLift",
     "ApiError",
     "ApplyPatchCall",
     "AskUserQuestionResult",

{cc_transcript-14.17.0 → 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.17.0 → 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.17.0 → cc_transcript-14.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.17.0" # 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"

{cc_transcript-14.17.0 → cc_transcript-14.18.0}/rust/crates/core/benches/parse.rs

@@ -6,9 +6,12 @@ use std::path::{Path, PathBuf};
 
 use criterion::{criterion_group, criterion_main, Criterion, Throughput};
 
-use cc_transcript_core::activity::{lift_session, session_activity, ActivityOpts};
+use cc_transcript_core::activity::{
+    lift_session, lift_session_index, lift_session_index_tail, session_activity, ActivityOpts,
+};
 use cc_transcript_core::filter::{compile_spec, spec_keep, SIGNAL_SPEC_JSON};
 use cc_transcript_core::parse::parse_bytes;
+use cc_transcript_core::types::Entry;
 
 fn corpus_dir() -> PathBuf {
     std::env::var_os("CC_BENCH_CORPUS")
@@ -80,6 +83,12 @@ fn bench_activity(c: &mut Criterion) {
     group.bench_function("full_lift", |b| {
         b.iter(|| lift_session(&session_id, &entries))
     });
+    let refs: Vec<&Entry> = entries.iter().collect();
+    group.bench_function("lift_index", |b| b.iter(|| lift_session_index(&refs, None)));
+    let appended = &refs[refs.len().saturating_sub(8)..];
+    group.bench_function("lift_index_tail_8", |b| {
+        b.iter(|| lift_session_index_tail(appended, None, true))
+    });
     group.finish();
 }
 

{cc_transcript-14.17.0 → cc_transcript-14.18.0}/rust/crates/core/src/activity.rs

@@ -500,17 +500,17 @@ struct Segment {
     end: usize,
 }
 
+fn opens(entry: &Entry, index: usize, openers: Option<&[bool]>) -> bool {
+    matches!(entry, Entry::User(user) if openers.map_or_else(|| opens_turn(user), |flags| flags[index]))
+}
+
 // activity.py from_events segmentation: a turn-opening user entry starts a contiguous
 // segment, else folds into the current one; `Some(openers)` replaces that per-entry decision.
 fn segments(entries: &[&Entry], openers: Option<&[bool]>) -> Vec<Segment> {
     let mut segments: Vec<Segment> = Vec::new();
     for (index, &entry) in entries.iter().enumerate() {
-        let opens = openers.map_or_else(
-            || matches!(entry, Entry::User(user) if opens_turn(user)),
-            |flags| flags[index],
-        );
         match entry {
-            Entry::User(user) if opens => segments.push(Segment {
+            Entry::User(user) if opens(entry, index, openers) => segments.push(Segment {
                 prompt: user.content.text(),
                 start: index,
                 end: index + 1,
@@ -711,7 +711,42 @@ pub fn lift_session_index<'a>(
     entries: &[&'a Entry],
     openers: Option<&[bool]>,
 ) -> Vec<TurnIndex<'a>> {
-    let result_pos: HashMap<&'a str, usize> = entries
+    turn_indexes(entries, openers, &result_positions(entries))
+}
+
+/// The tail of an incremental lift (activity.py ActivityLift.extend): skeletons over the
+/// appended entries alone, `continued` when the first is the rest of the prior open turn,
+/// and every tool result the tail carries as `(tool_use_id, position)` for re-pairing.
+#[derive(Debug, PartialEq, Eq)]
+pub struct LiftTail<'a> {
+    pub turns: Vec<TurnIndex<'a>>,
+    pub continued: bool,
+    pub results: Vec<(&'a str, usize)>,
+}
+
+/// `lift_session_index` over the entries appended since a prior lift whose last turn
+/// is open when `open_turn`. Turn boundaries never look ahead, so prior turns are final.
+pub fn lift_session_index_tail<'a>(
+    entries: &[&'a Entry],
+    openers: Option<&[bool]>,
+    open_turn: bool,
+) -> LiftTail<'a> {
+    let result_pos = result_positions(entries);
+    let mut results: Vec<(&'a str, usize)> =
+        result_pos.iter().map(|(&id, &pos)| (id, pos)).collect();
+    results.sort_unstable_by_key(|&(_, pos)| pos);
+    LiftTail {
+        turns: turn_indexes(entries, openers, &result_pos),
+        continued: open_turn
+            && entries
+                .first()
+                .is_some_and(|&entry| !opens(entry, 0, openers)),
+        results,
+    }
+}
+
+fn result_positions<'a>(entries: &[&'a Entry]) -> HashMap<&'a str, usize> {
+    entries
         .iter()
         .enumerate()
         .filter_map(|(index, &entry)| match entry {
@@ -722,7 +757,14 @@ pub fn lift_session_index<'a>(
             user.tool_results()
                 .map(move |block| (block.tool_use_id.as_str(), index))
         })
-        .collect();
+        .collect()
+}
+
+fn turn_indexes<'a>(
+    entries: &[&'a Entry],
+    openers: Option<&[bool]>,
+    result_pos: &HashMap<&'a str, usize>,
+) -> Vec<TurnIndex<'a>> {
     segments(entries, openers)
         .into_iter()
         .map(|segment| {
@@ -1553,6 +1595,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn tail_continues_an_open_turn_only_through_a_non_opener() {
+        let entries = vec![
+            tool_use("Bash", "t1", r#"{"command":"ls"}"#),
+            tool_result("t1"),
+            user("next ask"),
+        ];
+        let refs: Vec<&Entry> = entries.iter().collect();
+
+        let continued = lift_session_index_tail(&refs, None, true);
+        assert!(continued.continued);
+        assert_eq!(continued.turns, lift_session_index(&refs, None));
+        assert_eq!(continued.results, [("t1", 1)]);
+
+        assert!(!lift_session_index_tail(&refs, None, false).continued);
+        assert!(!lift_session_index_tail(&refs[2..], None, true).continued);
+        assert!(!lift_session_index_tail(&[], None, true).continued);
+        assert!(lift_session_index_tail(&refs, Some(&[false, false, false]), true).continued);
+        assert!(
+            lift_session_index_tail(&refs, Some(&[true, false, false]), true).continued,
+            "a flag on a non-user entry opens nothing, exactly as segments() ignores it"
+        );
+        assert!(lift_session_index_tail(&refs[2..], Some(&[false]), true).continued);
+        assert!(!lift_session_index_tail(&refs[2..], Some(&[true]), true).continued);
+    }
+
+    #[test]
+    fn tail_results_keep_the_last_position_per_id_in_tail_order() {
+        let entries = vec![
+            tool_result("t2"),
+            tool_result("t1"),
+            user("interrupting ask"),
+            tool_result("t2"),
+        ];
+        let refs: Vec<&Entry> = entries.iter().collect();
+        assert_eq!(
+            lift_session_index_tail(&refs, None, true).results,
+            [("t1", 1), ("t2", 3)]
+        );
+    }
+
     #[test]
     fn hunk_overlap_matches_reference() {
         let hunk = |old: &str, new: &str| Hunk {

{cc_transcript-14.17.0 → cc_transcript-14.18.0}/rust/crates/py/src/python.rs

@@ -15,8 +15,8 @@ use crate::views::print::print_result_view;
 use crate::views::transcript::TranscriptView;
 use crate::{command, lexicon, mining, score};
 use cc_transcript_core::activity::{
-    hunk_overlap, lift_session, lift_session_index, overlap_between, parse_show_hunks,
-    result_index, ActivityOpts, Hunk, SessionActivity,
+    hunk_overlap, lift_session, lift_session_index, lift_session_index_tail, overlap_between,
+    parse_show_hunks, result_index, ActivityOpts, Hunk, SessionActivity, TurnIndex,
 };
 use cc_transcript_core::buckets;
 use cc_transcript_core::command::CommandLine;
@@ -310,28 +310,73 @@ fn activity_lift_from_events<'py>(
         .collect::<PyResult<Vec<_>>>()?;
     lift_session_index(&entries, opener_flags.as_deref())
         .iter()
-        .map(|turn| {
-            let td = PyDict::new(py);
-            td.set_item("prompt", &turn.prompt)?;
-            td.set_item("start", turn.start)?;
-            td.set_item("end", turn.end)?;
-            td.set_item("started_idx", turn.started_idx)?;
-            td.set_item("ended_idx", turn.ended_idx)?;
-            let tool_uses = turn
-                .tool_uses
+        .map(|turn| turn_index_dict(py, turn))
+        .collect()
+}
+
+// activity.ActivityLift.extend: the tail skeleton over the appended events alone, plus
+// whether its first turn continues the open one and every result the tail carries.
+#[pyo3_stub_gen::derive::gen_stub_pyfunction]
+#[pyfunction]
+#[pyo3(signature = (events, opener_flags=None, open_turn=false))]
+#[gen_stub(override_return_type(type_repr = "dict[str, typing.Any]", imports = ("typing",)))]
+fn activity_lift_tail<'py>(
+    py: Python<'py>,
+    #[gen_stub(override_type(type_repr = "list[cc_transcript.models.TranscriptEvent]", imports = ("cc_transcript.models",)))]
+    events: Vec<Bound<'py, PyAny>>,
+    opener_flags: Option<Vec<bool>>,
+    open_turn: bool,
+) -> PyResult<Bound<'py, PyDict>> {
+    if let Some(flags) = &opener_flags {
+        if flags.len() != events.len() {
+            return Err(PyValueError::new_err(format!(
+                "activity_lift_tail() got {} opener_flags for {} events",
+                flags.len(),
+                events.len()
+            )));
+        }
+    }
+    let entries = events
+        .iter()
+        .map(|event| mining::view_entry(event, "activity_lift_tail"))
+        .collect::<PyResult<Vec<_>>>()?;
+    let tail = lift_session_index_tail(&entries, opener_flags.as_deref(), open_turn);
+    let dict = PyDict::new(py);
+    dict.set_item(
+        "turns",
+        PyList::new(
+            py,
+            tail.turns
                 .iter()
-                .map(|use_| {
-                    let ud = PyDict::new(py);
-                    ud.set_item("event_idx", use_.event_idx)?;
-                    ud.set_item("tool_use_id", use_.tool_use_id)?;
-                    ud.set_item("result_event_idx", use_.result_event_idx)?;
-                    Ok(ud)
-                })
-                .collect::<PyResult<Vec<_>>>()?;
-            td.set_item("tool_uses", PyList::new(py, tool_uses)?)?;
-            Ok(td)
+                .map(|turn| turn_index_dict(py, turn))
+                .collect::<PyResult<Vec<_>>>()?,
+        )?,
+    )?;
+    dict.set_item("continued", tail.continued)?;
+    dict.set_item("results", tail.results)?;
+    Ok(dict)
+}
+
+fn turn_index_dict<'py>(py: Python<'py>, turn: &TurnIndex<'_>) -> PyResult<Bound<'py, PyDict>> {
+    let td = PyDict::new(py);
+    td.set_item("prompt", &turn.prompt)?;
+    td.set_item("start", turn.start)?;
+    td.set_item("end", turn.end)?;
+    td.set_item("started_idx", turn.started_idx)?;
+    td.set_item("ended_idx", turn.ended_idx)?;
+    let tool_uses = turn
+        .tool_uses
+        .iter()
+        .map(|use_| {
+            let ud = PyDict::new(py);
+            ud.set_item("event_idx", use_.event_idx)?;
+            ud.set_item("tool_use_id", use_.tool_use_id)?;
+            ud.set_item("result_event_idx", use_.result_event_idx)?;
+            Ok(ud)
         })
-        .collect()
+        .collect::<PyResult<Vec<_>>>()?;
+    td.set_item("tool_uses", PyList::new(py, tool_uses)?)?;
+    Ok(td)
 }
 
 #[pyo3_stub_gen::derive::gen_stub_pyfunction]
@@ -1023,6 +1068,7 @@ fn _native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(cli_main, m)?)?;
     m.add_function(wrap_pyfunction!(activity_lift, m)?)?;
     m.add_function(wrap_pyfunction!(activity_lift_from_events, m)?)?;
+    m.add_function(wrap_pyfunction!(activity_lift_tail, m)?)?;
     m.add_function(wrap_pyfunction!(activity_hunk_overlap, m)?)?;
     m.add_function(wrap_pyfunction!(activity_overlap_between, m)?)?;
     m.add_function(wrap_pyfunction!(activity_parse_show_hunks, m)?)?;