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

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

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

{cc_transcript-10.3.0 → cc_transcript-10.4.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.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "10.3.0"
+version = "10.4.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.4.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),
+            ),
         }
     }
 }
@@ -61,8 +74,8 @@ 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.
+/// 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.content.text().trim().is_empty()
@@ -78,18 +91,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 +231,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 {
@@ -545,6 +559,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 +626,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 +649,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.4.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.4.0}/rust/src/types.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use chrono::{DateTime, FixedOffset};
 use sonic_rs::Value;
@@ -225,6 +225,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 {