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

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

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

{cc_transcript-10.2.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.2.0 → cc_transcript-10.4.0}/cc_transcript/mining/signals.py

@@ -132,7 +132,7 @@ def last_edit_index(events: Sequence[TranscriptEvent], index: int, spec: MiningS
             i
             for i in range(index - 1, max(index - spec.reentry_lookback, 0) - 1, -1)
             if isinstance(event := events[i], AssistantEvent)
-            if any(isinstance(b, ToolUseBlock) and b.name in spec.edit_tools for b in event.blocks)
+            if any(isinstance(b, ToolUseBlock) and matches_names(b.name, spec.edit_tools) for b in event.blocks)
         ),
         None,
     )

{cc_transcript-10.2.0 → cc_transcript-10.4.0}/cc_transcript/tools.py

@@ -32,6 +32,14 @@ TOOL_ALIASES: dict[str, str] = {
 
 TOOL_ALIASES_REVERSE: dict[str, str] = {v: k for k, v in TOOL_ALIASES.items()}
 
+# cc-context routes real file edits through MCP tools whose bare names match no
+# builtin edit gate; alias its write surface to the builtins those gates watch so
+# an edit through the MCP can't slip past a Tool("Edit"/"Write"/"MultiEdit") guard.
+MCP_TOOL_ALIASES: dict[str, str] = {
+    "ccx_code_edit": "Edit",
+    "ccx_code_replace": "Write",
+}
+
 READ_VERBS = frozenset({"get", "list", "search", "read", "view", "fetch", "query", "describe", "show", "find"})
 
 
@@ -482,28 +490,34 @@ def file_path_of(call: ToolCall) -> str | None:
 
 
 def expand_tool_names(spec: str) -> frozenset[str]:
-    """Expand a pipe-separated tool spec to include both alias spellings."""
-    return frozenset(
-        (base := set(spec.split("|")))
-        | {alias for n in base for alias in (TOOL_ALIASES.get(n), TOOL_ALIASES_REVERSE.get(n)) if alias}
-    )
+    """Expand a pipe-separated tool spec to include alias and MCP bare spellings."""
+    base = set(spec.split("|"))
+    expanded = base | {alias for n in base for alias in (TOOL_ALIASES.get(n), TOOL_ALIASES_REVERSE.get(n)) if alias}
+    return frozenset(expanded | {bare for bare, builtin in MCP_TOOL_ALIASES.items() if builtin in expanded})
 
 
 def matches_names(actual: str, names: Container[str]) -> bool:
     """Whether ``actual`` is one of ``names``, exactly or as an MCP tool suffix.
 
     True when ``actual`` is in ``names``, or when it splits as
-    ``mcp__<server>__<tool>`` on the first two ``__`` and ``<tool>`` is in
-    ``names``. ``names`` is taken verbatim — no alias closure; pre-expand with
-    :func:`expand_tool_names` when aliases should match.
+    ``mcp__<server>__<tool>`` on the first two ``__`` and ``<tool>`` — or its
+    :data:`MCP_TOOL_ALIASES` builtin equivalent — is in ``names``. That alias
+    closes the edit-gate bypass where cc-context's ``ccx_code_edit`` /
+    ``ccx_code_replace`` write through the MCP under names no ``Edit``/``Write``
+    gate would catch. Harness-rename aliases are not closed over — ``names`` is
+    taken verbatim; pre-expand with :func:`expand_tool_names` for those.
 
     Example:
         >>> matches_names("mcp__github__Grep", {"Grep"})
         True
+        >>> matches_names("mcp__cc-context__ccx_code_edit", {"Edit"})
+        True
         >>> matches_names("Execute", {"Bash"})
         False
     """
-    return actual in names or ((mp := mcp_parts(actual)) is not None and mp[1] in names)
+    return actual in names or (
+        (mp := mcp_parts(actual)) is not None and (mp[1] in names or MCP_TOOL_ALIASES.get(mp[1]) in names)
+    )
 
 
 def tool_name_matches(actual: str, spec: str) -> bool:

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

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "10.2.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.2.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.2.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).
@@ -473,23 +475,11 @@ impl Events {
         let lo = index.saturating_sub(spec.reentry_lookback);
         (lo..index)
             .rev()
-            .find(|&i| self.entries[i].tool_uses().any(|tu| spec.edit_tools.contains(&tu.name)))
+            .find(|&i| self.entries[i].tool_uses().any(|tu| matches_names(&tu.name, &spec.edit_tools)))
             .map(|i| i as i64)
     }
 }
 
-/// 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
@@ -1316,6 +1306,10 @@ mod tests {
         assert!(matches_names("mcp__conductor__ExitPlanMode", &names));
         assert!(!matches_names("mcp__ExitPlanMode", &names));
         assert!(!matches_names("AskUserQuestion", &names));
+
+        let edit_names: HashSet<String> = ["Edit".to_string(), "ccx_code_edit".to_string()].into();
+        assert!(matches_names("mcp__cc-context__ccx_code_edit", &edit_names));
+        assert!(!matches_names("mcp__cc-context__ccx_code_read", &edit_names));
     }
 
     #[test]

{cc_transcript-10.2.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 {