cc-transcript 14.22.0__tar.gz → 14.24.0__tar.gz

{cc_transcript-14.22.0 → cc_transcript-14.24.0}/PKG-INFO

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

{cc_transcript-14.22.0 → cc_transcript-14.24.0}/cc_transcript/render.py

@@ -62,7 +62,11 @@ def prefixed(prefix: str, text: str) -> tuple[str, ...]:
 
 
 def render_turn(turn: Turn, *, budget: Budget, tool_results: bool = False) -> str:
-    """Render one turn: the prompt, the user's mid-turn messages, assistant prose, and every tool call, in order.
+    """Render one turn: the prompt, the messages queued mid-turn, assistant prose, and every tool call, in order.
+
+    A message queued while the agent worked renders under who sent it: ``user:`` for
+    the user's own, ``notification:`` for a background task's, ``peer:`` for another
+    agent's, ``channel:`` for an MCP channel's.
 
     Prose chunks clip to ``budget.turn_chars``; each tool call renders via
     :func:`render_tool_call` under ``budget.tool_chars``. An AskUserQuestion answer
@@ -72,8 +76,10 @@ def render_turn(turn: Turn, *, budget: Budget, tool_results: bool = False) -> st
     Args:
         turn: The turn to render.
         budget: Character budgets for prose and tool calls.
-        tool_results: Render each other tool result after its call, as ``result:``,
-            or ``failed:`` when the call errored, clipped to ``budget.turn_chars``.
+        tool_results: Render each other tool result after its call: a ``result:``
+            head, or ``failed:`` when the call errored, naming the tool, then the
+            content clipped to ``budget.turn_chars`` on ``> `` lines. Calls batched in
+            one message and their results carry a ``call i/n``/``result i/n`` ordinal.
     """
     return _native.render_turn_from_events(
         turn.prompt,

{cc_transcript-14.22.0 → cc_transcript-14.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.22.0" # informational — releases stamp the version from the git tag
+version = "14.24.0" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.22.0 → cc_transcript-14.24.0}/rust/crates/core/src/render.rs

@@ -436,31 +436,46 @@ pub fn render_tool_call(call: &ToolCall, budget: &Budget) -> String {
     }
 }
 
-/// Render one turn — the prompt, the user's mid-turn messages, assistant prose,
-/// every tool call, and the user's AskUserQuestion answers, in order (render.py
-/// render_turn). With `tool_results`, each other result follows its call. Prose and
-/// tool results clip to `budget.turn_chars`; each tool call and answer preview
-/// renders under `budget.tool_chars`.
+/// Render one turn — the prompt, the messages queued mid-turn under `user:`,
+/// `notification:`, `peer:` or `channel:` by who sent them, assistant prose, every tool
+/// call, and the user's AskUserQuestion answers, in order (render.py render_turn). With `tool_results`, each other result follows its call as a
+/// `result:`/`failed:` head naming the call, its content on `> ` lines, and a
+/// `call i/n`/`result i/n` ordinal on calls batched in one message.
 pub fn render_turn(turn: &Turn, budget: &Budget, tool_results: bool) -> String {
     let mut parts: Vec<String> = Vec::new();
     if !turn.prompt.is_empty() {
         parts.push(format!("user: {}", clip(&turn.prompt, budget.turn_chars)));
     }
-    let mut calls: HashMap<&str, &str> = HashMap::new();
+    let mut calls: HashMap<&str, CallLabel<'_>> = HashMap::new();
     for &event in &turn.events {
         match event {
             Entry::Assistant(assistant) => {
+                let batch = assistant
+                    .blocks
+                    .iter()
+                    .filter(|block| matches!(block, ContentBlock::ToolUse(_)))
+                    .count();
+                let mut ordinal = 0;
                 for block in &assistant.blocks {
                     match block {
                         ContentBlock::Text(text) if !pystr::strip(text).is_empty() => {
                             parts.push(format!("assistant: {}", clip(text, budget.turn_chars)));
                         }
                         ContentBlock::ToolUse(tool_use) => {
-                            calls.insert(&tool_use.id, &tool_use.name);
-                            parts.push(render_tool_call(
+                            ordinal += 1;
+                            let label = CallLabel {
+                                name: &tool_use.name,
+                                ordinal: (tool_results && batch > 1).then_some((ordinal, batch)),
+                            };
+                            let rendered = render_tool_call(
                                 &parse_tool_call(&tool_use.name, &tool_use.input),
                                 budget,
-                            ));
+                            );
+                            parts.push(match label.ordinal {
+                                Some((i, n)) => format!("call {i}/{n}: {rendered}"),
+                                None => rendered,
+                            });
+                            calls.insert(&tool_use.id, label);
                         }
                         _ => {}
                     }
@@ -469,15 +484,15 @@ pub fn render_turn(turn: &Turn, budget: &Budget, tool_results: bool) -> String {
             Entry::User(user) => {
                 for block in user.blocks() {
                     if let ContentBlock::ToolResult(result) = block {
-                        if let Some(name) = calls.get(result.tool_use_id.as_str()) {
-                            parts.extend(result_lines(name, result, budget, tool_results));
+                        if let Some(label) = calls.get(result.tool_use_id.as_str()) {
+                            parts.extend(result_lines(label, result, budget, tool_results));
                         }
                     }
                 }
             }
             Entry::Attachment(attachment) => {
-                if let Some(prompt) = human_queued_prompt(&attachment.detail) {
-                    parts.push(format!("user: {}", clip(prompt, budget.turn_chars)));
+                if let Some((role, prompt)) = queued_line(&attachment.detail) {
+                    parts.push(format!("{role}: {}", clip(prompt, budget.turn_chars)));
                 }
             }
             _ => {}
@@ -486,8 +501,22 @@ pub fn render_turn(turn: &Turn, budget: &Budget, tool_results: bool) -> String {
     parts.join("\n")
 }
 
+struct CallLabel<'a> {
+    name: &'a str,
+    ordinal: Option<(usize, usize)>,
+}
+
+impl CallLabel<'_> {
+    fn head(&self, verdict: &str) -> String {
+        match self.ordinal {
+            Some((i, n)) => format!("{verdict} {i}/{n}: {}", self.name),
+            None => format!("{verdict}: {}", self.name),
+        }
+    }
+}
+
 fn result_lines(
-    name: &str,
+    label: &CallLabel<'_>,
     result: &ToolResultBlock,
     budget: &Budget,
     tool_results: bool,
@@ -496,16 +525,13 @@ fn result_lines(
         if !tool_results {
             return Vec::new();
         }
-        return vec![format!(
-            "failed: {}",
-            clip(&result.content, budget.turn_chars)
-        )];
+        return quoted_result(label.head("failed"), &result.content, budget);
     }
-    if name == ASK_USER_QUESTION {
+    if label.name == ASK_USER_QUESTION {
         if let Some(ToolResult::AskUserQuestion(answer)) = result
             .tool_use_result
             .as_ref()
-            .map(|payload| parse_tool_result(name, payload))
+            .map(|payload| parse_tool_result(label.name, payload))
         {
             return answer_lines(&answer, budget);
         }
@@ -514,13 +540,18 @@ fn result_lines(
             clip(&result.content, budget.tool_chars)
         )];
     }
-    if !tool_results || pystr::strip(&result.content).is_empty() {
+    if !tool_results {
         return Vec::new();
     }
-    vec![format!(
-        "result: {}",
-        clip(&result.content, budget.turn_chars)
-    )]
+    quoted_result(label.head("result"), &result.content, budget)
+}
+
+fn quoted_result(head: String, content: &str, budget: &Budget) -> Vec<String> {
+    let mut lines = vec![head];
+    if !pystr::strip(content).is_empty() {
+        lines.extend(prefixed("> ", &clip(content, budget.turn_chars)));
+    }
+    lines
 }
 
 fn answer_lines(answer: &AskUserQuestionResult, budget: &Budget) -> Vec<String> {
@@ -566,6 +597,22 @@ fn chosen_option<'a>(payload: &'a Value, question: &str, label: &str) -> Option<
         .find(|option| field_str(option, "label") == Some(label))
 }
 
+// The role a queued command renders under: the user's own `user:`, a background task's
+// `notification:`, another agent's `peer:`, an MCP channel's `channel:`.
+pub(crate) fn queued_line(detail: &AttachmentDetail) -> Option<(&'static str, &str)> {
+    let AttachmentDetail::QueuedCommand(queued) = detail else {
+        return None;
+    };
+    let prompt = queued.prompt.as_deref()?;
+    match (queued.command_mode.as_deref(), queued.origin.as_deref()) {
+        (Some("task-notification"), _) => Some(("notification", prompt)),
+        (Some("prompt"), Some("human")) => Some(("user", prompt)),
+        (Some("prompt"), Some("peer")) => Some(("peer", prompt)),
+        (Some("prompt"), Some("channel")) => Some(("channel", prompt)),
+        _ => None,
+    }
+}
+
 pub(crate) fn human_queued_prompt(detail: &AttachmentDetail) -> Option<&str> {
     match detail {
         AttachmentDetail::QueuedCommand(queued)