cc-transcript 10.4.0__tar.gz → 10.6.0__tar.gz

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/PKG-INFO

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

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/cc_transcript/activity.py

@@ -40,10 +40,15 @@ 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 a compact summary, not an
-    interruption marker, and not tool-result-only — it must carry real text.
+    interruption marker, not an agent-injected relay banner, and not
+    tool-result-only — it must carry real text.
     """
     return not (
-        event.meta.is_meta or event.meta.is_sidechain or event.meta.is_compact_summary or event.interrupted
+        event.meta.is_meta
+        or event.meta.is_sidechain
+        or event.meta.is_compact_summary
+        or event.interrupted
+        or event.is_agent_injected
     ) and bool(event.text.strip())
 
 

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/cc_transcript/filterspec.py

@@ -59,11 +59,14 @@ STRUCTURAL_GROUPS: tuple[tuple[str, str], ...] = (
     ("hash_banner", r"(?:###\s+[\w][\w \-]{0,30}\s+){3,}###"),
 )
 
-# Agent-injected banners (teammate messages, scheduled tasks, foreign agents).
+# Agent-injected banners (teammate messages, scheduled tasks, foreign agents). Start-anchored
+# so a mid-text mention is not a banner; the follower class replaces \b and Reminder's "i" is
+# ASCII-pinned via (?-i:[Ii]) so Rust regex and Python re stay in parity across combining marks
+# and dotted/dotless-I folding. Mirror any change in rust/src/protocol.rs AGENT_INJECTION_PATTERN.
 AGENT_INJECTION_GROUPS: tuple[tuple[str, str], ...] = (
-    ("xml_tags_extra", r"<(?:teammate-message|scheduled-task)\b"),
-    ("augment_agent", r"^# Augment Agent\b"),
-    ("role_reminder", r"^\s*\[Role Reminder\b"),
+    ("xml_tags_extra", r"\A\s*<(?:teammate-message|scheduled-task)(?:[\s/>]|$)"),
+    ("augment_agent", r"\A\s*# Augment Agent(?:\s|$)"),
+    ("role_reminder", r"\A\s*\[Role Rem(?-i:[Ii])nder(?:[\s:\]]|$)"),
 )
 
 INTERRUPT_MARKER_GROUPS: tuple[tuple[str, str], ...] = (("interrupt", r"^\s*\[Request interrupted by user"),)
@@ -419,6 +422,10 @@ def is_bare_interrupt_marker(text: str) -> bool:
     return (marker := interrupt_marker(text)) is not None and not text.strip()[len(marker.strip()) :].strip()
 
 
+def is_agent_injection(text: str) -> bool:
+    return AGENT_INJECTION_RE.search(text) is not None
+
+
 def normalize_bare(text: str, strip_trailing: str = TRAILING_PUNCT) -> str:
     return text.strip().rstrip(strip_trailing).strip().lower()
 
@@ -551,5 +558,6 @@ def predicate_to_dict(predicate: Predicate) -> dict[str, Any]:
 
 
 STRUCTURAL_NOISE_RE = compile_groups(STRUCTURAL_NOISE_GROUPS, True)
+AGENT_INJECTION_RE = compile_groups(AGENT_INJECTION_GROUPS, True)
 INTERRUPT_MARKER_RE = compile_groups(INTERRUPT_MARKER_GROUPS, True)
 JUNK_USER_MESSAGE_RE = compile_groups(SENTIMENT_JUNK_GROUPS, True)

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/cc_transcript/models.py

@@ -160,12 +160,16 @@ class UserEvent:
         text: The joined text of the turn.
         blocks: The parsed content blocks, including tool results.
         interrupted: Whether the turn is a user interruption.
+        is_agent_injected: Whether the turn is an agent-injected relay banner —
+            a teammate-message digest, scheduled-task banner, or foreign-agent
+            header — rather than an authored prompt.
     """
 
     meta: EntryMeta
     text: str
     blocks: tuple[ContentBlock, ...]
     interrupted: bool
+    is_agent_injected: bool = False
 
 
 @dataclass(frozen=True, slots=True)

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/cc_transcript/parser.py

@@ -11,7 +11,7 @@ import anyio.to_thread
 import orjson
 
 from cc_transcript.backend import Backend, ParsedTranscript
-from cc_transcript.filterspec import apply_spec, interrupt_marker
+from cc_transcript.filterspec import apply_spec, interrupt_marker, is_agent_injection
 from cc_transcript.models import (
     AssistantEvent,
     CacheCreation,
@@ -158,6 +158,7 @@ def parse_event(data: Mapping[str, Any]) -> TranscriptEvent | None:
                 text=text,
                 blocks=blocks,
                 interrupted=interrupt_marker(text) is not None,
+                is_agent_injected=is_agent_injection(text),
             )
         case "assistant":
             text, blocks = parse_assistant_blocks(data["message"]["content"])

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/pyproject.toml

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

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/rust/src/activity.rs

@@ -73,11 +73,16 @@ 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. Compact-summary exclusion matches captain-hook, which
-/// consumes this probe since the 10.2.0 shared-classifier fix.
+/// a real prompt — non-meta, non-sidechain, not an interruption marker, not an
+/// agent-injected relay banner, with non-blank text. Compact-summary exclusion
+/// matches captain-hook, which consumes this probe since the 10.2.0
+/// shared-classifier fix.
 fn opens_turn(user: &UserEntry) -> bool {
-    !(user.meta.is_meta || user.meta.is_sidechain || user.meta.is_compact_summary || user.interrupted())
+    !(user.meta.is_meta
+        || user.meta.is_sidechain
+        || user.meta.is_compact_summary
+        || user.interrupted()
+        || user.is_agent_injected())
         && !user.content.text().trim().is_empty()
 }
 
@@ -510,6 +515,22 @@ mod tests {
         assert_eq!(activity.pending[0].kind, PendingKind::Background);
     }
 
+    #[test]
+    fn agent_injected_banner_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("<teammate-message from='mate'>ping</teammate-message>"),
+        ];
+        let activity = activity(&entries);
+        assert!(
+            activity.is_waiting,
+            "an agent-injected relay banner must not open a turn, so the background Bash stays current"
+        );
+        assert_eq!(activity.pending[0].kind, PendingKind::Background);
+    }
+
     #[test]
     fn unrelated_completion_marker_keeps_waiting() {
         let entries = vec![

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/rust/src/event.rs

@@ -12,7 +12,7 @@ use crate::model::{
     USER_EVENT_CLS,
 };
 use crate::parse::ParseError;
-use crate::protocol::interrupt_marker;
+use crate::protocol::{interrupt_marker, is_agent_injection};
 use crate::types::{
     joined_text, ContentBlock, Entry, EntryMeta, InitInfo, ModelUsage, PrintBody, PrintMessage,
     PrintResult, Usage, UserContent,
@@ -155,11 +155,13 @@ pub fn build_event<'py>(py: Python<'py>, entry: &Entry) -> PyResult<Bound<'py, P
         Entry::User(user) => {
             let text = user.content.text();
             let interrupted = interrupt_marker(&text).is_some();
+            let is_agent_injected = is_agent_injection(&text);
             models_type(py, &USER_EVENT_CLS, "UserEvent")?.call1((
                 build_meta(py, &user.meta)?,
                 text,
                 build_user_blocks(py, &user.content)?,
                 interrupted,
+                is_agent_injected,
             ))
         }
         Entry::Assistant(assistant) => {

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/rust/src/protocol.rs

@@ -12,6 +12,14 @@ pub const ANSWERED_PREFIX: &str = "Your questions have been answered: ";
 pub const ANSWERED_TRAILER: &str = ". You can now continue with these answers in mind.";
 const INTERRUPT_MARKER_PATTERN: &str = r"^\s*\[Request interrupted by user";
 
+// Agent-injected relay banners (filterspec.py AGENT_INJECTION_GROUPS): teammate-message
+// digests, scheduled-task banners, and foreign-agent headers. The alternation mirrors
+// compile_groups(AGENT_INJECTION_GROUPS): `(?:p1)|(?:p2)|(?:p3)`. Each alternative is
+// start-anchored (\A\s*), the trailing \b is an explicit follower class agreeing with
+// Python re across combining marks, and Reminder's "i" is ASCII-pinned via (?-i:[Ii]) so
+// dotted/dotless-I case folding stays in parity.
+const AGENT_INJECTION_PATTERN: &str = r"(?:\A\s*<(?:teammate-message|scheduled-task)(?:[\s/>]|$))|(?:\A\s*# Augment Agent(?:\s|$))|(?:\A\s*\[Role Rem(?-i:[Ii])nder(?:[\s:\]]|$))";
+
 /// The one interrupt-marker regex (filterspec.py INTERRUPT_MARKER_RE): the pattern
 /// compiled case-insensitively, anchored at the start of the haystack with leading
 /// whitespace tolerated. Shared with mining's structural fallback so both uses
@@ -20,6 +28,19 @@ pub static INTERRUPT_MARKER_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(&format!("(?i){INTERRUPT_MARKER_PATTERN}")).expect("interrupt regex")
 });
 
+/// The agent-injection regex (filterspec.py AGENT_INJECTION_RE): the group
+/// alternation compiled case-insensitively, matched with search semantics
+/// (filterspec.py is_agent_injection uses .search()).
+pub static AGENT_INJECTION_RE: Lazy<Regex> = Lazy::new(|| {
+    Regex::new(&format!("(?i){AGENT_INJECTION_PATTERN}")).expect("agent injection regex")
+});
+
+/// is_agent_injection (filterspec.py is_agent_injection): whether ``text`` is an
+/// agent-injected relay banner rather than an authored prompt.
+pub fn is_agent_injection(text: &str) -> bool {
+    AGENT_INJECTION_RE.is_match(text)
+}
+
 /// embedded_user_text (filterspec.py embedded_user_text): the verbatim instruction
 /// wrapped between the USER_SAID markers, or None.
 pub fn embedded_user_text(content: &str) -> Option<String> {
@@ -91,4 +112,28 @@ mod tests {
         assert!(is_bare_interrupt_marker("[Request interrupted by user]"));
         assert!(!is_bare_interrupt_marker("[Request interrupted by user] no do it differently"));
     }
+
+    #[test]
+    fn agent_injection_matches_relay_banners() {
+        assert!(is_agent_injection("<teammate-message from='r'>rebase</teammate-message>"));
+        assert!(is_agent_injection("<scheduled-task id='7'>run the suite</scheduled-task>"));
+        assert!(is_agent_injection("[Role Reminder: You are a Coordinator."));
+        assert!(is_agent_injection("# Augment Agent\nyou have these tools"));
+        // Leading whitespace before the marker is tolerated.
+        assert!(is_agent_injection("   <teammate-message from='mate'>ping</teammate-message>"));
+    }
+
+    #[test]
+    fn agent_injection_rejects_prose_and_mid_text_mentions() {
+        assert!(!is_agent_injection("remind me what the teammate coordinator does"));
+        // Start-anchored: a relay tag mentioned mid-text is authored, not injected.
+        assert!(!is_agent_injection("as noted in the <teammate-message> above"));
+        assert!(!is_agent_injection("Why did the transcript contain <teammate-message from=a>?"));
+        assert!(!is_agent_injection("we discussed the [Role Reminder] banner mid-sentence"));
+        // A combining mark (U+0301) after the tag name is not a portable word boundary; and
+        // dotless-I must not fold to ASCII "i" — Python re once matched both, Rust never did.
+        assert!(!is_agent_injection("<teammate-message\u{0301}>"));
+        assert!(!is_agent_injection("[Role Rem\u{0131}nder: dotless"));
+        assert!(!is_agent_injection(""));
+    }
 }

{cc_transcript-10.4.0 → cc_transcript-10.6.0}/rust/src/types.rs

@@ -3,7 +3,7 @@ use std::collections::{HashMap, HashSet};
 use chrono::{DateTime, FixedOffset};
 use sonic_rs::Value;
 
-use crate::protocol::interrupt_marker;
+use crate::protocol::{interrupt_marker, is_agent_injection};
 
 /// Envelope metadata shared by the conversational entry kinds (user, assistant,
 /// system). Mode and Other entries carry no envelope on disk.
@@ -116,6 +116,10 @@ impl UserEntry {
     pub fn interrupted(&self) -> bool {
         interrupt_marker(&self.content.text()).is_some()
     }
+
+    pub fn is_agent_injected(&self) -> bool {
+        is_agent_injection(&self.content.text())
+    }
 }
 
 #[derive(Debug)]