cc-transcript 10.0.0__tar.gz → 10.2.0__tar.gz

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/Cargo.lock

@@ -72,7 +72,7 @@ dependencies = [
 
 [[package]]
 name = "cc_transcript_parser"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "chrono",
  "crossbeam-channel",
@@ -81,6 +81,7 @@ dependencies = [
  "num_cpus",
  "once_cell",
  "pyo3",
+ "pyo3-build-config",
  "rayon",
  "regex",
  "sonic-rs",
@@ -91,7 +92,7 @@ dependencies = [
 
 [[package]]
 name = "cc_transcript_swift"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "cc_transcript_parser",
  "swift-bridge",

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/PKG-INFO

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

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/cc_transcript/activity.py

@@ -39,10 +39,12 @@ UserClassifier = Callable[["UserEvent"], bool]
 def native_user_classifier(event: UserEvent) -> bool:
     """Whether a user event is a real prompt under native Claude Code semantics.
 
-    A prompt is non-meta, non-sidechain, not an interruption marker, and not
-    tool-result-only — it must carry real text.
+    A prompt is non-meta, non-sidechain, not a compact summary, not an
+    interruption marker, and not tool-result-only — it must carry real text.
     """
-    return not (event.meta.is_meta or event.meta.is_sidechain or event.interrupted) and bool(event.text.strip())
+    return not (
+        event.meta.is_meta or event.meta.is_sidechain or event.meta.is_compact_summary or event.interrupted
+    ) and bool(event.text.strip())
 
 
 @dataclass(frozen=True, slots=True)

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/cc_transcript/activity_probe.py

@@ -4,11 +4,14 @@
 to the Python reference. :func:`session_activity_probe` is the public dual-backend entry:
 it reads a ``.jsonl`` transcript, runs the oracle over its parsed events, and returns a
 :class:`SessionActivityProbe`; :func:`probe_events` is the Python reference the Rust probe
-stays identical to. The verdict spans ephemeral waits (waiting tools, backgrounded
-Agent/Task/Bash, subagentless Agent/Task) over the current turn plus pending async
-launches (async Agent/Task, live Workflow) session-wide, with completion read from
-queue-operation ``<tool-use-id>`` markers, and flags unanswered non-human-facing tool
-calls in the current turn as mid-tool.
+stays identical to. The verdict spans undelivered task notifications (the
+:class:`~cc_transcript.notifications.Notifications` queue replay), ephemeral waits
+(waiting tools, backgrounded Agent/Task/Bash, subagentless Agent/Task) over the current
+turn, and pending async launches (async Agent/Task, live Workflow) session-wide — a
+launch counts as completed only once its notification was delivered or drained, never
+when merely enqueued — and flags unanswered non-human-facing tool calls in the current
+turn as mid-tool. Compact-summary user lines do not open turns, deliberately leading
+captain-hook, which still lets compaction close the turn.
 """
 
 from __future__ import annotations
@@ -20,12 +23,12 @@ from typing import TYPE_CHECKING, Literal
 from cc_transcript.activity import native_user_classifier
 from cc_transcript.models import (
     AssistantEvent,
-    OtherEvent,
     SystemEvent,
     ToolResultBlock,
     ToolUseBlock,
     UserEvent,
 )
+from cc_transcript.notifications import Notifications
 from cc_transcript.parser import parse_events_from_bytes
 
 if TYPE_CHECKING:
@@ -81,11 +84,6 @@ class SessionActivityProbe:
     last_event_epoch: int | None
 
 
-def completed(completions: Sequence[str], tool_use_id: str) -> bool:
-    marker = f"<tool-use-id>{tool_use_id}</tool-use-id>"
-    return any(marker in content for content in completions)
-
-
 def ephemeral_wait(block: ToolUseBlock, waiting_tools: frozenset[str]) -> PendingKind | None:
     if block.name in waiting_tools:
         return "waiting_tool"
@@ -98,12 +96,12 @@ def ephemeral_wait(block: ToolUseBlock, waiting_tools: frozenset[str]) -> Pendin
 
 
 def pending_async(
-    block: ToolUseBlock, result: ToolResultBlock | None, completions: Sequence[str]
+    block: ToolUseBlock, result: ToolResultBlock | None, notifications: Notifications
 ) -> PendingKind | None:
     match block.name:
-        case "Agent" | "Task" if result is not None and result.is_async and not completed(completions, block.id):
+        case "Agent" | "Task" if result is not None and result.is_async and not notifications.completed(block.id):
             return "pending_async_task"
-        case "Workflow" if not completed(completions, block.id):
+        case "Workflow" if not notifications.completed(block.id):
             return "pending_async_workflow"
     return None
 
@@ -114,7 +112,11 @@ def probe_events(
     waiting_tools: frozenset[str] = DEFAULT_WAITING_TOOLS,
     human_facing_tools: frozenset[str] = DEFAULT_HUMAN_FACING_TOOLS,
 ) -> SessionActivityProbe:
-    """The Python reference oracle over parsed events, twin of the Rust probe."""
+    """The Python reference oracle over parsed events, twin of the Rust probe.
+
+    An undelivered task notification alone sets ``is_waiting`` with no pending
+    item — a resumed session's orphan has no launch to point at.
+    """
     results = {
         block.tool_use_id: block
         for event in events
@@ -122,12 +124,7 @@ def probe_events(
         for block in event.blocks
         if isinstance(block, ToolResultBlock)
     }
-    completions = [
-        content
-        for event in events
-        if isinstance(event, OtherEvent) and event.type == "queue-operation"
-        if isinstance(content := event.raw.get("content"), str)
-    ]
+    notifications = Notifications.from_events(events)
     turn_start = next(
         (
             index
@@ -137,7 +134,7 @@ def probe_events(
         0,
     )
 
-    is_waiting = False
+    is_waiting = notifications.has_pending
     mid_tool = False
     pending: list[PendingItem] = []
     seen: set[str] = set()
@@ -152,7 +149,7 @@ def probe_events(
                 continue
             in_current_turn = index >= turn_start
             waiting_kind = (ephemeral_wait(block, waiting_tools) if in_current_turn else None) or pending_async(
-                block, result, completions
+                block, result, notifications
             )
             unmatched = in_current_turn and result is None and block.name not in human_facing_tools
             is_waiting = is_waiting or waiting_kind is not None

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "10.0.0"
+version = "10.2.0"
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cc_transcript_parser"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2021"
 
 [lib]
@@ -20,7 +20,6 @@ python = [
     "dep:tree-sitter-bash",
 ]
 extension-module = ["python", "pyo3/extension-module"]
-swift = []
 
 [dependencies]
 pyo3 = { version = "0.28", features = ["abi3-py313", "chrono"], optional = true }
@@ -38,3 +37,6 @@ dirs = { version = "5", optional = true }
 # bash grammar), tree-sitter core 0.26 matches the wheel's tree-sitter 0.26.0.
 tree-sitter = { version = "0.26", optional = true }
 tree-sitter-bash = { version = "0.25", optional = true }
+
+[build-dependencies]
+pyo3-build-config = { version = "0.28", features = ["resolve-config"] }

cc_transcript-10.2.0/rust/build.rs

@@ -0,0 +1,20 @@
+// Local `cargo test` on the default (python) feature links a shared libpython
+// whose install name is `@rpath/libpython3.X.dylib`. The cargo test harness
+// carries no rpath to the interpreter's lib dir, so the binary aborts at load.
+// Emit that rpath, derived from the same interpreter pyo3 linked. Gated off when
+// `extension-module` is active, so the shipped wheel (which links no libpython
+// and resolves symbols from the host interpreter) keeps its exact build flags.
+fn main() {
+    let python = std::env::var_os("CARGO_FEATURE_PYTHON").is_some();
+    let extension_module = std::env::var_os("CARGO_FEATURE_EXTENSION_MODULE").is_some();
+    if !python || extension_module {
+        return;
+    }
+    println!("cargo:rerun-if-env-changed=PYO3_PYTHON");
+    println!("cargo:rerun-if-env-changed=PYO3_CONFIG_FILE");
+    let lib_dir = pyo3_build_config::get()
+        .lib_dir
+        .as_ref()
+        .expect("pyo3 linked a shared libpython but reported no lib_dir for the test rpath");
+    println!("cargo:rustc-link-arg=-Wl,-rpath,{lib_dir}");
+}

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/rust/src/activity.rs

@@ -1,7 +1,9 @@
 use std::collections::{HashMap, HashSet};
 
 use crate::types::{Entry, ToolResultBlock, ToolUseBlock, UserEntry};
-use crate::value::field_str;
+use crate::value::{field, field_str};
+
+const NOTIFICATION_MARKER: &str = "<task-notification>";
 
 pub struct ActivityOpts {
     pub waiting_tools: HashSet<String>,
@@ -59,9 +61,10 @@ pub struct SessionActivity {
 
 /// Whether a user entry opens a turn (activity.py ``native_user_classifier``):
 /// a real prompt — non-meta, non-sidechain, not an interruption marker, with
-/// non-blank text.
+/// non-blank text. Compact-summary exclusion deliberately leads captain-hook,
+/// which still lets compaction close the turn; convergence is a follow-up there.
 fn opens_turn(user: &UserEntry) -> bool {
-    !(user.meta.is_meta || user.meta.is_sidechain || user.interrupted())
+    !(user.meta.is_meta || user.meta.is_sidechain || user.meta.is_compact_summary || user.interrupted())
         && !user.content.text().trim().is_empty()
 }
 
@@ -90,51 +93,114 @@ fn ephemeral_wait(tool_use: &ToolUseBlock, waiting_tools: &HashSet<String>) -> O
 }
 
 /// conditions.py ``pending_async``: an async Agent/Task launch or a live
-/// Workflow with no completion notification yet.
+/// Workflow whose completion notification has not reached the agent.
 fn pending_async(
     tool_use: &ToolUseBlock,
     result: Option<&ToolResultBlock>,
-    completions: &[&str],
+    notifications: &Notifications,
 ) -> Option<PendingKind> {
     match tool_use.name.as_str() {
         "Agent" | "Task"
-            if result.is_some_and(|r| r.is_async) && !completed(completions, &tool_use.id) =>
+            if result.is_some_and(|r| r.is_async) && !notifications.completed(&tool_use.id) =>
         {
             Some(PendingKind::PendingAsyncTask)
         }
-        "Workflow" if !completed(completions, &tool_use.id) => Some(PendingKind::PendingAsyncWorkflow),
+        "Workflow" if !notifications.completed(&tool_use.id) => {
+            Some(PendingKind::PendingAsyncWorkflow)
+        }
         _ => None,
     }
 }
 
-fn completion_contents(entries: &[Entry]) -> Vec<&str> {
-    entries
-        .iter()
-        .filter_map(|entry| match entry {
-            Entry::Other(other) if other.ty == "queue-operation" => field_str(&other.raw, "content"),
-            _ => None,
-        })
-        .collect()
+/// notifications.py ``Notifications``: the harness delivery queue replayed
+/// from the transcript's ``queue-operation`` audit records.
+struct Notifications {
+    queued: Vec<String>,
+    delivered: Vec<String>,
+    enqueued: Vec<String>,
 }
 
-fn completed(contents: &[&str], id: &str) -> bool {
-    let marker = format!("<tool-use-id>{id}</tool-use-id>");
-    contents.iter().any(|content| content.contains(&marker))
+impl Notifications {
+    fn from_entries(entries: &[Entry]) -> Self {
+        let mut queued: Vec<String> = Vec::new();
+        let mut delivered: Vec<String> = Vec::new();
+        let mut enqueued: Vec<String> = Vec::new();
+        for entry in entries {
+            if let Entry::Other(other) = entry {
+                if other.ty == "queue-operation" {
+                    match field_str(&other.raw, "operation") {
+                        Some("enqueue") => {
+                            let content =
+                                field_str(&other.raw, "content").unwrap_or_default().to_string();
+                            enqueued.push(content.clone());
+                            queued.push(content);
+                        }
+                        Some("dequeue" | "remove") if !queued.is_empty() => {
+                            queued.remove(0);
+                        }
+                        Some("popAll") => {
+                            let content = field_str(&other.raw, "content").unwrap_or_default();
+                            queued.retain(|item| !content.contains(item.as_str()));
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            if let Some(text) = delivered_text(entry) {
+                delivered.push(text);
+            }
+        }
+        Self { queued, delivered, enqueued }
+    }
+
+    /// notifications.py ``Notifications.completed``: delivered, or enqueued at
+    /// some point yet no longer sitting undelivered in the queue.
+    fn completed(&self, tool_use_id: &str) -> bool {
+        let marker = format!("<tool-use-id>{tool_use_id}</tool-use-id>");
+        let holds = |texts: &[String]| texts.iter().any(|text| text.contains(&marker));
+        holds(&self.delivered) || (holds(&self.enqueued) && !holds(&self.queued))
+    }
+
+    /// notifications.py ``Notifications.has_pending``: any queued item is an
+    /// undelivered task notification.
+    fn has_pending(&self) -> bool {
+        self.queued.iter().any(|text| text.contains(NOTIFICATION_MARKER))
+    }
+}
+
+/// notifications.py ``delivered_text``: a user turn carrying a task
+/// notification, or a ``queued_command`` attachment replayed to the model.
+fn delivered_text(entry: &Entry) -> Option<String> {
+    match entry {
+        Entry::User(user) => {
+            let text = user.content.text();
+            text.contains(NOTIFICATION_MARKER).then_some(text)
+        }
+        Entry::Other(other) if other.ty == "attachment" => {
+            let attachment = field(&other.raw, "attachment")?;
+            (field_str(attachment, "type") == Some("queued_command"))
+                .then(|| field_str(attachment, "prompt").unwrap_or_default().to_string())
+        }
+        _ => None,
+    }
 }
 
 /// The session-activity oracle over parsed entries: captain-hook's
-/// ``is_waiting`` verdict over ephemeral waits and pending async launches,
-/// the mid-tool flag, and the contributing tool calls.
+/// ``is_waiting`` verdict (post-d2e07cc, minus its hook-side Stop-payload
+/// layer) over undelivered notifications, ephemeral waits, and pending async
+/// launches, plus the mid-tool flag and the contributing tool calls. An
+/// undelivered notification alone sets ``is_waiting`` with no pending item —
+/// a resumed session's orphan has no launch to point at.
 pub fn session_activity(entries: &[Entry], opts: &ActivityOpts) -> SessionActivity {
     let results: HashMap<&str, &ToolResultBlock> = entries
         .iter()
         .flat_map(Entry::tool_results)
         .map(|result| (result.tool_use_id.as_str(), result))
         .collect();
-    let completions = completion_contents(entries);
+    let notifications = Notifications::from_entries(entries);
     let turn_start = current_turn_start(entries);
 
-    let mut is_waiting = false;
+    let mut is_waiting = notifications.has_pending();
     let mut mid_tool = false;
     let mut pending: Vec<PendingItem> = Vec::new();
     let mut seen: HashSet<&str> = HashSet::new();
@@ -148,7 +214,7 @@ pub fn session_activity(entries: &[Entry], opts: &ActivityOpts) -> SessionActivi
             let waiting_kind = in_current_turn
                 .then(|| ephemeral_wait(tool_use, &opts.waiting_tools))
                 .flatten()
-                .or_else(|| pending_async(tool_use, result, &completions));
+                .or_else(|| pending_async(tool_use, result, &notifications));
             let unmatched = in_current_turn
                 && result.is_none()
                 && !opts.human_facing_tools.contains(&tool_use.name);
@@ -215,12 +281,27 @@ mod tests {
     }
 
     fn queue_op(content: &str) -> Entry {
+        queue_entry("enqueue", content)
+    }
+
+    fn queue_entry(operation: &str, content: &str) -> Entry {
         parse(&format!(
-            r#"{{"type":"queue-operation","operation":"enqueue","content":{}}}"#,
+            r#"{{"type":"queue-operation","operation":"{operation}","content":{}}}"#,
             sonic_rs::to_string(&content).unwrap()
         ))
     }
 
+    fn attachment(prompt: &str) -> Entry {
+        parse(&format!(
+            r#"{{"type":"attachment","attachment":{{"type":"queued_command","prompt":{}}}}}"#,
+            sonic_rs::to_string(&prompt).unwrap()
+        ))
+    }
+
+    fn delivered_notification(id: &str) -> Vec<Entry> {
+        vec![queue_op(&notification(id)), queue_entry("dequeue", ""), user(&notification(id))]
+    }
+
     fn notification(id: &str) -> String {
         format!(
             "<task-notification><task-id>t</task-id><tool-use-id>{id}</tool-use-id><status>completed</status></task-notification>"
@@ -252,18 +333,169 @@ mod tests {
     }
 
     #[test]
-    fn workflow_completion_marker_clears_waiting() {
+    fn workflow_delivered_notification_clears_waiting() {
+        let mut entries = vec![
+            user("run the workflow"),
+            tool_use("Workflow", "wf1", r#"{"script":"return 1"}"#),
+            tool_result("wf1"),
+        ];
+        entries.extend(delivered_notification("wf1"));
+        let activity = activity(&entries);
+        assert!(!activity.is_waiting);
+        assert!(activity.pending.is_empty());
+    }
+
+    #[test]
+    fn enqueued_undelivered_notification_keeps_waiting() {
+        let entries = vec![
+            user("run the workflow"),
+            tool_use("Workflow", "wf1", r#"{"script":"return 1"}"#),
+            tool_result("wf1"),
+            queue_op(&notification("wf1")),
+        ];
+        let activity = activity(&entries);
+        assert!(activity.is_waiting);
+        assert_eq!(
+            activity.pending,
+            [PendingItem {
+                tool_use_id: Some("wf1".to_string()),
+                name: "Workflow".to_string(),
+                kind: PendingKind::PendingAsyncWorkflow
+            }]
+        );
+    }
+
+    #[test]
+    fn removed_notification_counts_completed() {
         let entries = vec![
             user("run the workflow"),
             tool_use("Workflow", "wf1", r#"{"script":"return 1"}"#),
             tool_result("wf1"),
             queue_op(&notification("wf1")),
+            queue_entry("remove", ""),
         ];
         let activity = activity(&entries);
         assert!(!activity.is_waiting);
         assert!(activity.pending.is_empty());
     }
 
+    #[test]
+    fn popall_drains_command_but_not_notification() {
+        let notif = notification("wf1");
+        let entries = vec![
+            user("run the workflow"),
+            tool_use("Workflow", "wf1", r#"{"script":"return 1"}"#),
+            tool_result("wf1"),
+            queue_op(&notif),
+            queue_op("run the tests please"),
+            queue_entry("popAll", "run the tests please"),
+        ];
+        let notifications = Notifications::from_entries(&entries);
+        assert_eq!(
+            notifications.queued,
+            vec![notif],
+            "popAll drains the matching command yet leaves the notification queued"
+        );
+        assert!(notifications.has_pending());
+        let activity = activity(&entries);
+        assert!(activity.is_waiting);
+        assert_eq!(
+            activity.pending,
+            [PendingItem {
+                tool_use_id: Some("wf1".to_string()),
+                name: "Workflow".to_string(),
+                kind: PendingKind::PendingAsyncWorkflow
+            }]
+        );
+    }
+
+    #[test]
+    fn popall_drains_the_notification_completes() {
+        let notif = notification("wf1");
+        let entries = vec![
+            user("run the workflow"),
+            tool_use("Workflow", "wf1", r#"{"script":"return 1"}"#),
+            tool_result("wf1"),
+            queue_op(&notif),
+            queue_entry("popAll", &notif),
+        ];
+        let notifications = Notifications::from_entries(&entries);
+        assert!(
+            notifications.queued.is_empty(),
+            "popAll subtracts the notification itself out of the queue"
+        );
+        assert!(
+            notifications.completed("wf1"),
+            "an enqueued-then-drained notification counts as completed"
+        );
+        assert!(!notifications.has_pending());
+        let activity = activity(&entries);
+        assert!(!activity.is_waiting, "draining the notification closes the workflow's async wait");
+        assert!(!activity.mid_tool);
+        assert!(activity.pending.is_empty());
+    }
+
+    #[test]
+    fn orphan_undelivered_notification_is_waiting() {
+        let entries = vec![user("hi"), queue_op(&notification("tu_ghost"))];
+        let activity = activity(&entries);
+        assert!(activity.is_waiting, "a queued task notification holds the session on its own");
+        assert!(!activity.mid_tool);
+        assert!(activity.pending.is_empty());
+    }
+
+    #[test]
+    fn attachment_delivery_completes() {
+        let entries = vec![
+            user("go"),
+            tool_use("Agent", "a1", r#"{"subagent_type":"Explore","prompt":"look"}"#),
+            result_entry("a1", false, true),
+            attachment(&notification("a1")),
+        ];
+        let activity = activity(&entries);
+        assert!(!activity.is_waiting, "the queued_command attachment alone closes the async task");
+        assert!(!activity.mid_tool);
+        assert!(activity.pending.is_empty());
+        let expected = chrono::DateTime::parse_from_rfc3339("2026-01-02T03:04:07Z")
+            .unwrap()
+            .timestamp();
+        assert_eq!(activity.last_event_epoch, Some(expected));
+    }
+
+    #[test]
+    fn plain_user_delivery_completes() {
+        let entries = vec![
+            user("go"),
+            tool_use("Agent", "a1", r#"{"subagent_type":"Explore","prompt":"look"}"#),
+            result_entry("a1", false, true),
+            user(&notification("a1")),
+        ];
+        let activity = activity(&entries);
+        assert!(!activity.is_waiting, "a user turn carrying the notification closes the async task");
+        assert!(!activity.mid_tool);
+        assert!(activity.pending.is_empty());
+        let expected = chrono::DateTime::parse_from_rfc3339("2026-01-02T03:04:07Z")
+            .unwrap()
+            .timestamp();
+        assert_eq!(activity.last_event_epoch, Some(expected));
+    }
+
+    #[test]
+    fn compact_summary_user_does_not_open_turn() {
+        let entries = vec![
+            user("build it"),
+            tool_use("Bash", "b1", r#"{"command":"make","run_in_background":true}"#),
+            tool_result("b1"),
+            user_with("compact recap", r#""isCompactSummary":true,"#),
+        ];
+        let activity = activity(&entries);
+        assert!(
+            activity.is_waiting,
+            "auto-compaction must not retire a running background task"
+        );
+        assert_eq!(activity.pending[0].kind, PendingKind::Background);
+    }
+
     #[test]
     fn unrelated_completion_marker_keeps_waiting() {
         let entries = vec![
@@ -349,14 +581,14 @@ mod tests {
     }
 
     #[test]
-    fn async_agent_completion_marker_clears_waiting() {
-        let entries = vec![
+    fn async_agent_delivered_notification_clears_waiting() {
+        let mut entries = vec![
             user("go"),
             tool_use("Agent", "a1", r#"{"subagent_type":"Explore","prompt":"look"}"#),
             result_entry("a1", false, true),
             user("while that runs, plan"),
-            queue_op(&notification("a1")),
         ];
+        entries.extend(delivered_notification("a1"));
         assert!(!activity(&entries).is_waiting);
     }
 

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/rust/src/mining.rs

@@ -8,7 +8,7 @@ use regex::Regex;
 use sonic_rs::{Index, JsonContainerTrait, JsonValueTrait, Value};
 
 use crate::filter::compile_group_array;
-use crate::parse::{parse_entry, ParseError};
+use crate::parse::{parse_bytes, ParseError};
 use crate::protocol::{
     embedded_user_text, interrupt_marker, is_bare_interrupt_marker, ANSWERED_PREFIX, ANSWERED_TRAILER,
     DENIAL_PREFIX, INTERRUPT_MARKER_RE,
@@ -434,13 +434,7 @@ impl Events {
     /// non-object values (parser.py decode_line) so event indices agree with the
     /// Python reference; a malformed entry fails the mine, as in the reference.
     fn parse(raw: &[u8]) -> Result<Self, ParseError> {
-        let entries = raw
-            .split(|&b| b == b'\n')
-            .filter(|line| !line.iter().all(u8::is_ascii_whitespace))
-            .filter_map(|line| sonic_rs::from_slice::<Value>(line).ok())
-            .filter(|value| value.is_object())
-            .map(parse_entry)
-            .collect::<Result<Vec<_>, _>>()?;
+        let entries = parse_bytes(raw, |_| true)?;
         let texts = entries
             .iter()
             .map(|entry| match entry {

{cc_transcript-10.0.0 → cc_transcript-10.2.0}/rust/src/parse.rs

@@ -265,9 +265,10 @@ pub fn parse_entry(data: Value) -> Result<Entry, ParseError> {
     Ok(Entry::Other(OtherEntry { ty, raw: data }))
 }
 
-// Lines that are not valid JSON are skipped; a JSON line that fails the typed
-// parse (e.g. a missing required field) fails the whole file — whole-file
-// parity with PythonBackend, which parses every line before filtering.
+// Non-JSON lines and valid-JSON lines that are not objects (bare scalars or
+// arrays) are skipped; a JSON object that fails the typed parse (e.g. a missing
+// required field) fails the whole file — whole-file parity with PythonBackend,
+// which decodes every line, skips non-objects, then parses the rest.
 fn parse_line<F: Fn(&Entry) -> bool>(
     line: &[u8],
     lines: &mut Vec<Entry>,
@@ -277,6 +278,9 @@ fn parse_line<F: Fn(&Entry) -> bool>(
         return Ok(());
     }
     if let Ok(value) = sonic_rs::from_slice::<Value>(line) {
+        if !value.is_object() {
+            return Ok(());
+        }
         let entry = parse_entry(value)?;
         if keep(&entry) {
             lines.push(entry);
@@ -614,6 +618,15 @@ mod tests {
         assert_eq!(other.raw, parse(raw));
     }
 
+    #[test]
+    fn parse_bytes_skips_valid_json_non_object_lines() {
+        let real = format!(r#"{{"type":"user",{META},"message":{{"content":"hi"}}}}"#);
+        let bytes = format!("{real}\n42\n\"bare\"\n[1,2,3]\n{real}");
+        let entries = parse_bytes(bytes.as_bytes(), |_| true).unwrap();
+        assert_eq!(entries.len(), 2, "bare scalar and array lines are skipped");
+        assert!(entries.iter().all(|e| matches!(e, Entry::User(_))));
+    }
+
     #[test]
     fn print_envelope_requires_result_element() {
         assert!(matches!(