cc-transcript 10.3.0__tar.gz → 10.5.0__tar.gz

{cc_transcript-10.3.0 → cc_transcript-10.5.0}/PKG-INFO

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

{cc_transcript-10.3.0 → cc_transcript-10.5.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.3.0 → cc_transcript-10.5.0}/cc_transcript/activity_probe.py

@@ -10,8 +10,8 @@ stays identical to. The verdict spans undelivered task notifications (the
 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.
+turn as mid-tool. Compact-summary user lines do not open turns, matching captain-hook,
+which consumes this probe since the 10.2.0 shared-classifier fix.
 """
 
 from __future__ import annotations
@@ -30,6 +30,7 @@ from cc_transcript.models import (
 )
 from cc_transcript.notifications import Notifications
 from cc_transcript.parser import parse_events_from_bytes
+from cc_transcript.tools import expand_tool_names, matches_names
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -39,7 +40,10 @@ if TYPE_CHECKING:
     from cc_transcript.models import TranscriptEvent
 
 DEFAULT_WAITING_TOOLS = frozenset({"Monitor", "ScheduleWakeup", "SendMessage", "TeamCreate"})
-DEFAULT_HUMAN_FACING_TOOLS = frozenset({"AskUserQuestion", "ExitPlanMode"})
+DEFAULT_HUMAN_FACING_TOOLS = expand_tool_names("AskUserQuestion|ExitPlanMode")
+
+BACKGROUND_TOOLS = expand_tool_names("Agent|Task|Bash")
+TASK_TOOLS = expand_tool_names("Agent|Task")
 
 PendingKind = Literal[
     "waiting_tool",
@@ -85,13 +89,12 @@ class SessionActivityProbe:
 
 
 def ephemeral_wait(block: ToolUseBlock, waiting_tools: frozenset[str]) -> PendingKind | None:
-    if block.name in waiting_tools:
+    if matches_names(block.name, waiting_tools):
         return "waiting_tool"
-    match block.name:
-        case "Agent" | "Task" | "Bash" if block.input.get("run_in_background") is True:
-            return "background"
-        case "Agent" | "Task" if not isinstance(block.input.get("subagent_type"), str):
-            return "subagentless_task"
+    if matches_names(block.name, BACKGROUND_TOOLS) and block.input.get("run_in_background") is True:
+        return "background"
+    if matches_names(block.name, TASK_TOOLS) and not isinstance(block.input.get("subagent_type"), str):
+        return "subagentless_task"
     return None
 
 
@@ -151,7 +154,7 @@ def probe_events(
             waiting_kind = (ephemeral_wait(block, waiting_tools) if in_current_turn else None) or pending_async(
                 block, result, notifications
             )
-            unmatched = in_current_turn and result is None and block.name not in human_facing_tools
+            unmatched = in_current_turn and result is None and not matches_names(block.name, human_facing_tools)
             is_waiting = is_waiting or waiting_kind is not None
             mid_tool = mid_tool or unmatched
             kind = waiting_kind or ("mid_tool" if unmatched else None)

{cc_transcript-10.3.0 → cc_transcript-10.5.0}/cc_transcript/filterspec.py

@@ -419,6 +419,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 +555,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.3.0 → cc_transcript-10.5.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.3.0 → cc_transcript-10.5.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.3.0 → cc_transcript-10.5.0}/pyproject.toml

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

{cc_transcript-10.3.0 → cc_transcript-10.5.0}/rust/src/activity.rs

@@ -1,10 +1,19 @@
 use std::collections::{HashMap, HashSet};
 
-use crate::types::{Entry, ToolResultBlock, ToolUseBlock, UserEntry};
+use once_cell::sync::Lazy;
+
+use crate::types::{matches_names, Entry, ToolResultBlock, ToolUseBlock, UserEntry};
 use crate::value::{field, field_str};
 
 const NOTIFICATION_MARKER: &str = "<task-notification>";
 
+// tools.py expand_tool_names("Agent|Task|Bash") / ("Agent|Task"), pre-expanded
+// here because the alias table never crosses the language boundary.
+static BACKGROUND_TOOLS: Lazy<HashSet<String>> =
+    Lazy::new(|| HashSet::from(["Agent", "Task", "Bash", "Execute"].map(String::from)));
+static TASK_TOOLS: Lazy<HashSet<String>> =
+    Lazy::new(|| HashSet::from(["Agent", "Task"].map(String::from)));
+
 pub struct ActivityOpts {
     pub waiting_tools: HashSet<String>,
     pub human_facing_tools: HashSet<String>,
@@ -16,7 +25,11 @@ impl Default for ActivityOpts {
             waiting_tools: HashSet::from(
                 ["Monitor", "ScheduleWakeup", "SendMessage", "TeamCreate"].map(String::from),
             ),
-            human_facing_tools: HashSet::from(["AskUserQuestion", "ExitPlanMode"].map(String::from)),
+            // tools.py expand_tool_names("AskUserQuestion|ExitPlanMode"), pre-expanded
+            // here because the alias table never crosses the language boundary.
+            human_facing_tools: HashSet::from(
+                ["AskUserQuestion", "ExitPlanMode", "ExitSpecMode"].map(String::from),
+            ),
         }
     }
 }
@@ -60,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 deliberately leads captain-hook,
-/// which still lets compaction close the turn; convergence is a follow-up there.
+/// 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()
 }
 
@@ -78,18 +96,19 @@ fn current_turn_start(entries: &[Entry]) -> usize {
 }
 
 /// conditions.py ``ephemeral_wait``: a waiting tool, a backgrounded
-/// Agent/Task/Bash, or a subagentless Agent/Task.
+/// Agent/Task/Bash, or a subagentless Agent/Task — every name matched alias-
+/// and MCP-prefix-aware (tools.py matches_names).
 fn ephemeral_wait(tool_use: &ToolUseBlock, waiting_tools: &HashSet<String>) -> Option<PendingKind> {
-    if waiting_tools.contains(&tool_use.name) {
+    if matches_names(&tool_use.name, waiting_tools) {
         return Some(PendingKind::WaitingTool);
     }
-    match tool_use.name.as_str() {
-        "Agent" | "Task" | "Bash" if tool_use.run_in_background == Some(true) => {
-            Some(PendingKind::Background)
-        }
-        "Agent" | "Task" if tool_use.subagent_type.is_none() => Some(PendingKind::SubagentlessTask),
-        _ => None,
+    if matches_names(&tool_use.name, &BACKGROUND_TOOLS) && tool_use.run_in_background == Some(true) {
+        return Some(PendingKind::Background);
     }
+    if matches_names(&tool_use.name, &TASK_TOOLS) && tool_use.subagent_type.is_none() {
+        return Some(PendingKind::SubagentlessTask);
+    }
+    None
 }
 
 /// conditions.py ``pending_async``: an async Agent/Task launch or a live
@@ -217,7 +236,7 @@ pub fn session_activity(entries: &[Entry], opts: &ActivityOpts) -> SessionActivi
                 .or_else(|| pending_async(tool_use, result, &notifications));
             let unmatched = in_current_turn
                 && result.is_none()
-                && !opts.human_facing_tools.contains(&tool_use.name);
+                && !matches_names(&tool_use.name, &opts.human_facing_tools);
             is_waiting |= waiting_kind.is_some();
             mid_tool |= unmatched;
             let Some(kind) = waiting_kind.or(unmatched.then_some(PendingKind::MidTool)) else {
@@ -496,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![
@@ -545,6 +580,17 @@ mod tests {
         assert!(activity.pending.is_empty());
     }
 
+    #[test]
+    fn background_execute_alias_in_current_turn_is_waiting() {
+        let entries = vec![
+            user("build it"),
+            tool_use("Execute", "e1", r#"{"command":"make","run_in_background":true}"#),
+        ];
+        let activity = activity(&entries);
+        assert!(activity.is_waiting);
+        assert_eq!(activity.pending[0].kind, PendingKind::Background);
+    }
+
     #[test]
     fn subagentless_agent_is_waiting() {
         let entries = vec![
@@ -601,6 +647,17 @@ mod tests {
         assert_eq!(activity.pending[0].kind, PendingKind::WaitingTool);
     }
 
+    #[test]
+    fn mcp_prefixed_waiting_tool_is_waiting() {
+        let entries = vec![
+            user("ping the pool"),
+            tool_use("mcp__pool__SendMessage", "s1", r#"{"text":"hi"}"#),
+        ];
+        let activity = activity(&entries);
+        assert!(activity.is_waiting);
+        assert_eq!(activity.pending[0].kind, PendingKind::WaitingTool);
+    }
+
     #[test]
     fn pending_ask_user_question_is_quiet() {
         let entries = vec![
@@ -613,6 +670,18 @@ mod tests {
         assert!(activity.pending.is_empty());
     }
 
+    #[test]
+    fn mcp_prefixed_human_facing_tool_is_not_mid_tool() {
+        let entries = vec![
+            user("choose"),
+            tool_use("mcp__someserver__AskUserQuestion", "q1", r#"{"questions":[]}"#),
+        ];
+        let activity = activity(&entries);
+        assert!(!activity.is_waiting);
+        assert!(!activity.mid_tool);
+        assert!(activity.pending.is_empty());
+    }
+
     #[test]
     fn unmatched_bash_in_current_turn_is_mid_tool() {
         let entries = vec![user("list"), tool_use("Bash", "b1", r#"{"command":"ls"}"#)];

{cc_transcript-10.3.0 → cc_transcript-10.5.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.3.0 → cc_transcript-10.5.0}/rust/src/mining.rs

@@ -13,7 +13,9 @@ use crate::protocol::{
     embedded_user_text, interrupt_marker, is_bare_interrupt_marker, ANSWERED_PREFIX, ANSWERED_TRAILER,
     DENIAL_PREFIX, INTERRUPT_MARKER_RE,
 };
-use crate::types::{tool_use_index, Entry, EntryMeta, Question, ToolResultBlock, ToolUseBlock, UserEntry};
+use crate::types::{
+    matches_names, tool_use_index, Entry, EntryMeta, Question, ToolResultBlock, ToolUseBlock, UserEntry,
+};
 use crate::value::{field, field_bool, field_str};
 
 // Source kinds (mining/sourcekind.py).
@@ -478,18 +480,6 @@ impl Events {
     }
 }
 
-/// matches_names (tools.py matches_names): exact membership, or the ``<tool>``
-/// segment of an ``mcp__<server>__<tool>`` name split on the first two ``__``.
-/// Alias closure happens Python-side (tools.py expand_tool_names); the spec JSON
-/// arrives pre-expanded and the alias table never crosses the language boundary.
-fn matches_names(actual: &str, names: &HashSet<String>) -> bool {
-    names.contains(actual)
-        || actual
-            .strip_prefix("mcp__")
-            .and_then(|rest| rest.split_once("__"))
-            .is_some_and(|(_, tool)| names.contains(tool))
-}
-
 // ── text-shape helpers (mining/signals.py) ───────────────────────────────────
 
 /// marker_in (mining/signals.py marker_in): whether any tool-result block's

{cc_transcript-10.3.0 → cc_transcript-10.5.0}/rust/src/protocol.rs

@@ -12,6 +12,12 @@ 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)`.
+const AGENT_INJECTION_PATTERN: &str =
+    r"(?:<(?:teammate-message|scheduled-task)\b)|(?:^# Augment Agent\b)|(?:^\s*\[Role Reminder\b)";
+
 /// 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 +26,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 +110,22 @@ 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"));
+        // search() is unanchored: a mid-text teammate tag still matches.
+        assert!(is_agent_injection("as noted in the <teammate-message> above"));
+    }
+
+    #[test]
+    fn agent_injection_rejects_prose_and_head_anchored_mid_text() {
+        assert!(!is_agent_injection("remind me what the teammate coordinator does"));
+        // the head-anchored role-reminder group does not match mid-text.
+        assert!(!is_agent_injection("we discussed the [Role Reminder] banner mid-sentence"));
+        assert!(!is_agent_injection(""));
+    }
 }

{cc_transcript-10.3.0 → cc_transcript-10.5.0}/rust/src/types.rs

@@ -1,9 +1,9 @@
-use std::collections::HashMap;
+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)]
@@ -225,6 +229,18 @@ pub fn tool_use_index(entries: &[Entry]) -> HashMap<&str, &ToolUseBlock> {
         .collect()
 }
 
+/// matches_names (tools.py matches_names): exact membership, or the ``<tool>``
+/// segment of an ``mcp__<server>__<tool>`` name split on the first two ``__``.
+/// Alias closure happens Python-side (tools.py expand_tool_names); spec JSON
+/// arrives pre-expanded and the alias table never crosses the language boundary.
+pub(crate) fn matches_names(actual: &str, names: &HashSet<String>) -> bool {
+    names.contains(actual)
+        || actual
+            .strip_prefix("mcp__")
+            .and_then(|rest| rest.split_once("__"))
+            .is_some_and(|(_, tool)| names.contains(tool))
+}
+
 /// The space-joined text of the ``Text`` blocks — the ``text`` field of the
 /// Python ``AssistantEvent``/``PrintMessage``.
 pub fn joined_text(blocks: &[ContentBlock]) -> String {