cc-transcript 14.19.0__tar.gz → 14.20.0__tar.gz

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/PKG-INFO

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

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/cc_transcript/_native.pyi

@@ -1498,12 +1498,17 @@ class QueuedCommand:
             plain-string prompt (e.g. an image-paste payload).
         command_mode: How the command was queued, e.g. ``prompt`` or
             ``task-notification``, or None.
+        origin: Who sent a ``prompt``-mode command: ``human`` for the user,
+            ``peer`` for another agent or session, ``channel`` for an MCP
+            channel event; None when the transcript does not record it.
     """
     __match_args__: typing.ClassVar[tuple[str, ...]]
     @property
     def prompt(self) -> typing.Optional[builtins.str]: ...
     @property
     def command_mode(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def origin(self) -> typing.Optional[builtins.str]: ...
 
 @typing.final
 class ReadCall(ToolCallBase):

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/cc_transcript/query.py

@@ -26,7 +26,7 @@ from cc_transcript.activity import ActivityLift, SessionActivity, Turn, event_st
 from cc_transcript.discovery import TranscriptExpiredError, resolve, subagent_paths, subagent_transcripts
 from cc_transcript.filterspec import event_meta, session_id_of
 from cc_transcript.ids import SessionId, ToolUseId
-from cc_transcript.models import AssistantEvent, SystemEvent, ToolResultBlock, UserEvent
+from cc_transcript.models import AssistantEvent, AttachmentEvent, QueuedCommand, SystemEvent, ToolResultBlock, UserEvent
 from cc_transcript.notifications import Notifications
 from cc_transcript.parser import parse
 from cc_transcript.tools import (
@@ -642,6 +642,16 @@ class Session:
         """The window's last ``n`` events."""
         return windowed(self, max(len(self) - n, 0), len(self))
 
+    def recent_messages(self, n: int) -> Session:
+        """The window reaching back over its last ``n`` messages, for positive ``n``.
+
+        A message is a user or assistant event or a queued command. The hook,
+        reminder, system and mode events between messages ride along without
+        counting, so harness noise never crowds the conversation out of the window.
+        """
+        messages = [index for index, event in enumerate(self.events) if is_message(event)]
+        return windowed(self, messages[-n] if n <= len(messages) else 0, len(self))
+
     @property
     def current_turn(self) -> Session:
         """The one-turn view of the window's last turn."""
@@ -960,6 +970,12 @@ class DeepView:
         return iter(self.sessions)
 
 
+def is_message(event: TranscriptEvent) -> bool:
+    return isinstance(event, UserEvent | AssistantEvent) or (
+        isinstance(event, AttachmentEvent) and isinstance(event.detail, QueuedCommand)
+    )
+
+
 def windowed(session: Session, start: int, stop: int) -> Session:
     turns: list[Turn] = []
     base = 0

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.19.0" # informational — releases stamp the version from the git tag
+version = "14.20.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.19.0 → cc_transcript-14.20.0}/rust/crates/core/src/context.rs

@@ -11,7 +11,7 @@ use sonic_rs::{JsonContainerTrait, JsonValueTrait, Value};
 use crate::activity::{LiftedSession, ToolUse, Turn};
 use crate::ids::{encode_string, tool_digest, EventRef};
 use crate::parse::parse_questions;
-use crate::render::{clip, render_tool_call, render_turn, Budget};
+use crate::render::{clip, human_queued_prompt, render_tool_call, render_turn, Budget};
 use crate::toolcall::{parse_tool_call, parse_tool_result, ToolResult};
 use crate::types::{ContentBlock, Entry, Question, ToolUseBlock};
 use crate::value::{field, field_bool, field_str};
@@ -19,7 +19,7 @@ use crate::value::{field, field_bool, field_str};
 pub const SCHEMA: &str = "cc-transcript.context/2";
 pub const PREVIEW_SCHEMA: &str = "cc-transcript.preview/1";
 pub const SUMMARY_LABEL: &str = "[summary fidelity — transcript unavailable]";
-const ASK_USER_QUESTION: &str = "AskUserQuestion";
+pub(crate) const ASK_USER_QUESTION: &str = "AskUserQuestion";
 
 /// One structured preview part of a turn (context.py `Preview`): typed text, a tool
 /// call reduced to name + digest + summary, or an AskUserQuestion round with its
@@ -549,8 +549,17 @@ fn build_previews(turn: &Turn, budget: &Budget) -> Vec<Preview> {
     }
     let mut uses = turn.tool_uses.iter();
     for &event in &turn.events {
-        let Entry::Assistant(assistant) = event else {
-            continue;
+        let assistant = match event {
+            Entry::Assistant(assistant) => assistant,
+            Entry::Attachment(attachment) => {
+                if let Some(prompt) = human_queued_prompt(&attachment.detail) {
+                    parts.push(Preview::Text {
+                        text: clip(prompt, budget.turn_chars),
+                    });
+                }
+                continue;
+            }
+            _ => continue,
         };
         for block in &assistant.blocks {
             match block {

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/rust/crates/core/src/parse.rs

@@ -478,6 +478,7 @@ fn parse_attachment_detail(data: &Value) -> AttachmentDetail {
         Some("queued_command") => AttachmentDetail::QueuedCommand(QueuedCommand {
             prompt: opt_str(att, "prompt"),
             command_mode: opt_str(att, "commandMode"),
+            origin: field(att, "origin").and_then(|origin| opt_str(origin, "kind")),
         }),
         Some("deferred_tools_delta") => AttachmentDetail::DeferredToolsDelta(DeferredToolsDelta {
             added_names: str_array(att, "addedNames"),

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/rust/crates/core/src/render.rs

@@ -1,13 +1,14 @@
 //! The one renderer, ported from `cc_transcript/render.py` — every cut happens here,
 //! under a [`Budget`]. Parity notes on the individual helpers.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use chrono::{DateTime, FixedOffset};
 use sonic_rs::{JsonContainerTrait, JsonType, JsonValueTrait, Value};
 
 use crate::activity::Turn;
 use crate::blame::{SessionWrites, Verdict};
+use crate::context::ASK_USER_QUESTION;
 #[cfg(feature = "command")]
 use crate::facts::{McpServerSummary, ToolFact};
 use crate::filter::{entry_text, event_kind};
@@ -432,36 +433,73 @@ pub fn render_tool_call(call: &ToolCall, budget: &Budget) -> String {
     }
 }
 
-/// Render one turn — the prompt, assistant prose, and every tool call, in order
-/// (render.py render_turn). Prose clips to `budget.turn_chars`; each tool call
-/// renders via [`render_tool_call`] under `budget.tool_chars`.
+/// 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). Prose clips to `budget.turn_chars`; each tool call and answer
+/// renders under `budget.tool_chars`.
 pub fn render_turn(turn: &Turn, budget: &Budget) -> 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 questions: HashSet<&str> = HashSet::new();
     for &event in &turn.events {
-        let Entry::Assistant(assistant) = event else {
-            continue;
-        };
-        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)));
+        match event {
+            Entry::Assistant(assistant) => {
+                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) => {
+                            if tool_use.name == ASK_USER_QUESTION {
+                                questions.insert(&tool_use.id);
+                            }
+                            parts.push(render_tool_call(
+                                &parse_tool_call(&tool_use.name, &tool_use.input),
+                                budget,
+                            ));
+                        }
+                        _ => {}
+                    }
                 }
-                ContentBlock::ToolUse(tool_use) => {
-                    parts.push(render_tool_call(
-                        &parse_tool_call(&tool_use.name, &tool_use.input),
-                        budget,
-                    ));
+            }
+            Entry::User(user) => {
+                parts.extend(user.blocks().iter().filter_map(|block| match block {
+                    ContentBlock::ToolResult(result)
+                        if !result.is_error && questions.contains(result.tool_use_id.as_str()) =>
+                    {
+                        Some(format!(
+                            "user answered: {}",
+                            clip(&result.content, budget.tool_chars)
+                        ))
+                    }
+                    _ => None,
+                }));
+            }
+            Entry::Attachment(attachment) => {
+                if let Some(prompt) = human_queued_prompt(&attachment.detail) {
+                    parts.push(format!("user: {}", clip(prompt, budget.turn_chars)));
                 }
-                _ => {}
             }
+            _ => {}
         }
     }
     parts.join("\n")
 }
 
+pub(crate) fn human_queued_prompt(detail: &AttachmentDetail) -> Option<&str> {
+    match detail {
+        AttachmentDetail::QueuedCommand(queued)
+            if queued.command_mode.as_deref() == Some("prompt")
+                && queued.origin.as_deref() == Some("human") =>
+        {
+            queued.prompt.as_deref()
+        }
+        _ => None,
+    }
+}
+
 /// One compact `index tag time payload [uuid]` line (render.py compact_line).
 pub fn compact_line(
     index: usize,
@@ -1802,6 +1840,7 @@ fn attachment_detail_json(detail: &AttachmentDetail) -> Json {
         AttachmentDetail::QueuedCommand(q) => obj(vec![
             ("prompt", opt_str(&q.prompt)),
             ("command_mode", opt_str(&q.command_mode)),
+            ("origin", opt_str(&q.origin)),
         ]),
         AttachmentDetail::DeferredToolsDelta(delta) => obj(vec![
             ("added_count", Json::UInt(delta.added_names.len() as u64)),

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/rust/crates/core/src/types.rs

@@ -357,6 +357,7 @@ pub struct AsyncHookResponse {
 pub struct QueuedCommand {
     pub prompt: Option<String>,
     pub command_mode: Option<String>,
+    pub origin: Option<String>,
 }
 
 #[derive(Debug)]

{cc_transcript-14.19.0 → cc_transcript-14.20.0}/rust/crates/py/src/views/attachment.rs

@@ -463,6 +463,9 @@ view_dunders!(
 ///         plain-string prompt (e.g. an image-paste payload).
 ///     command_mode: How the command was queued, e.g. ``prompt`` or
 ///         ``task-notification``, or None.
+///     origin: Who sent a ``prompt``-mode command: ``human`` for the user,
+///         ``peer`` for another agent or session, ``channel`` for an MCP
+///         channel event; None when the transcript does not record it.
 #[pyo3_stub_gen::derive::gen_stub_pyclass]
 #[pyclass(name = "QueuedCommand", module = "cc_transcript.models", frozen)]
 pub(crate) struct QueuedCommandView {
@@ -490,12 +493,17 @@ impl QueuedCommandView {
     fn command_mode(&self, _py: Python<'_>) -> PyResult<Option<String>> {
         Ok(self.queued_command().command_mode.clone())
     }
+
+    #[getter]
+    fn origin(&self, _py: Python<'_>) -> PyResult<Option<String>> {
+        Ok(self.queued_command().origin.clone())
+    }
 }
 
 view_dunders!(
     QueuedCommandView,
     "QueuedCommand",
-    fields = [prompt, command_mode]
+    fields = [prompt, command_mode, origin]
 );
 
 /// Tools added to and removed from the deferred tool inventory.