cc-transcript 14.35.0__tar.gz → 14.36.0__tar.gz

{cc_transcript-14.35.0 → cc_transcript-14.36.0}/PKG-INFO

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

{cc_transcript-14.35.0 → cc_transcript-14.36.0}/cc_transcript/snapshot_schema/config.schema.json

@@ -81,6 +81,7 @@
     },
     "max_retained_bytes": {
       "default": 1073741824,
+      "description": "Hard cap on retained accounted bytes. It must be at least the store's startup footprint (the pre-sized delivery and expired-query tables plus the default tool registries); a smaller value is rejected as an invalid configuration. Background admissions are capped at max_retained_bytes - reserved_hook_accounted_bytes, so a footprint above that difference refuses every background admission while foreground hook admissions proceed.",
       "exclusiveMinimum": 0,
       "maximum": 9007199254740991,
       "title": "Max Retained Bytes",

{cc_transcript-14.35.0 → cc_transcript-14.36.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.35.0" # informational — releases stamp the version from the git tag
+version = "14.36.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.35.0 → cc_transcript-14.36.0}/rust/crates/core/src/codex/lower.rs

@@ -9,6 +9,7 @@ use crate::codex::types::{
     CodexEntry, CodexItem, CodexSession, EventMsg, ResponseItem, ResponseItemPayload,
 };
 use crate::pystr;
+use crate::snapshot_memory::{pins_arena, SourceArena};
 use crate::types::{
     AssistantEntry, ContentBlock, Entry, EntryMeta, OtherEntry, ToolResultBlock, ToolUseBlock,
     UserContent, UserEntry,
@@ -547,15 +548,17 @@ fn payload_tag(payload: &ResponseItemPayload) -> &str {
 }
 
 fn payload_raw(payload: &ResponseItemPayload) -> Value {
+    payload_dom(payload).cloned().unwrap_or_default()
+}
+
+fn payload_dom(payload: &ResponseItemPayload) -> Option<&Value> {
     use ResponseItemPayload as R;
     match payload {
-        R::ToolSearchCall { arguments, .. } => arguments.clone(),
-        R::LocalShellCall { action, .. } | R::WebSearchCall { action, .. } => {
-            action.clone().unwrap_or_default()
-        }
-        R::GhostSnapshot(v) => v.clone(),
-        R::Other { raw, .. } => raw.clone(),
-        _ => Value::default(),
+        R::ToolSearchCall { arguments, .. } => Some(arguments),
+        R::LocalShellCall { action, .. } | R::WebSearchCall { action, .. } => action.as_ref(),
+        R::GhostSnapshot(v) => Some(v),
+        R::Other { raw, .. } => Some(raw),
+        _ => None,
     }
 }
 
@@ -592,6 +595,10 @@ fn event_tag(em: &EventMsg) -> &str {
 }
 
 fn event_raw(em: &EventMsg) -> Value {
+    event_dom(em).cloned().unwrap_or_default()
+}
+
+fn event_dom(em: &EventMsg) -> Option<&Value> {
     use EventMsg as E;
     match em {
         E::ExecCommandEnd(v)
@@ -607,11 +614,75 @@ fn event_raw(em: &EventMsg) -> Value {
         | E::CollabAgentSpawnEnd(v)
         | E::CollabWaitingEnd(v)
         | E::CollabCloseEnd(v)
-        | E::Other { raw: v, .. } => v.clone(),
-        _ => Value::default(),
+        | E::Other { raw: v, .. } => Some(v),
+        _ => None,
+    }
+}
+
+pub(crate) fn line_dom(item: &CodexItem) -> Option<&Value> {
+    use ResponseItemPayload as R;
+    match item {
+        CodexItem::SessionMeta(m) => Some(&m.raw),
+        CodexItem::TurnContext(v) => Some(v),
+        CodexItem::WorldState(w) => Some(&w.state),
+        CodexItem::ResponseItem(ri) => match &ri.payload {
+            R::FunctionCallOutput { output, .. } | R::CustomToolCallOutput { output, .. } => {
+                Some(output)
+            }
+            payload => payload_dom(payload),
+        },
+        CodexItem::EventMsg(em) => event_dom(em),
+        CodexItem::Compacted(_)
+        | CodexItem::InterAgentCommunicationMetadata { .. }
+        | CodexItem::Other(_) => None,
+    }
+}
+
+fn retains_line(entry: &Entry) -> bool {
+    match entry {
+        Entry::Other(other) => pins_arena(&other.raw),
+        _ => entry
+            .tool_results()
+            .any(|result| result.tool_use_result.as_ref().is_some_and(pins_arena)),
+    }
+}
+
+fn lowered_arenas(source: &CodexEntry, entry: &Entry) -> Vec<SourceArena> {
+    match (&source.item, entry) {
+        (CodexItem::Other(other), Entry::Other(lowered)) => pins_arena(&lowered.raw)
+            .then(|| SourceArena {
+                root: lowered.raw.clone(),
+                source_len: other.raw.len(),
+            })
+            .into_iter()
+            .collect(),
+        _ => source
+            .source
+            .iter()
+            .filter(|_| retains_line(entry))
+            .cloned()
+            .collect(),
     }
 }
 
+pub(crate) fn session_arenas(
+    session: &CodexSession,
+    entries: &[Entry],
+) -> Vec<(usize, SourceArena)> {
+    assert_eq!(session.entries.len(), entries.len());
+    session
+        .entries
+        .iter()
+        .zip(entries)
+        .enumerate()
+        .flat_map(|(index, (source, entry))| {
+            lowered_arenas(source, entry)
+                .into_iter()
+                .map(move |arena| (index, arena))
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;
@@ -1339,4 +1410,44 @@ mod tests {
             "050b lifted turns must expose the interrupted user entry"
         );
     }
+
+    #[test]
+    fn lowered_entries_record_the_arenas_they_keep() {
+        let lines = [
+            r#"{"timestamp":"2026-07-19T00:00:00Z","type":"response_item","payload":{"type":"function_call_output","call_id":"c","output":{"stdout":"x"}}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:01Z","type":"response_item","payload":{"type":"function_call","call_id":"c","name":"exec","arguments":"{}"}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:02Z","type":"event_msg","payload":{"type":"task_started","turn_id":"t"}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:03Z","type":"turn_context","payload":{"cwd":"/w","model":"m"}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:04Z","type":"mystery","payload":{"k":1}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:05Z","type":"response_item","payload":{"type":"function_call_output","call_id":"d","output":"plain"}}"#,
+        ];
+        let session = parse_codex_bytes(lines.join("\n").as_bytes());
+        let entries = lower(&session).entries;
+        assert_eq!(
+            session
+                .entries
+                .iter()
+                .map(|entry| entry.source.as_ref().map(|source| source.source_len))
+                .collect::<Vec<_>>(),
+            [
+                Some(lines[0].len()),
+                None,
+                None,
+                Some(lines[3].len()),
+                None,
+                Some(lines[5].len())
+            ]
+        );
+        assert_eq!(
+            session_arenas(&session, &entries)
+                .iter()
+                .map(|(entry, arena)| (*entry, arena.source_len))
+                .collect::<Vec<_>>(),
+            [
+                (0, lines[0].len()),
+                (3, lines[3].len()),
+                (4, lines[4].len())
+            ]
+        );
+    }
 }

{cc_transcript-14.35.0 → cc_transcript-14.36.0}/rust/crates/core/src/codex/parse.rs

@@ -1,12 +1,14 @@
 use memchr::memchr_iter;
 use sonic_rs::{JsonContainerTrait, JsonValueTrait, Value};
 
+use crate::codex::lower::line_dom;
 use crate::codex::types::{
     CodexEntry, CodexItem, CodexOther, CodexSession, Compacted, EventMsg, ResponseItem,
     ResponseItemPayload, SessionMeta, TokenUsage, TokenUsageInfo, WorldState,
 };
 use crate::parse::parse_timestamp;
-use crate::value::{field, field_str, normalize_last_wins};
+use crate::snapshot_memory::{pins_arena, SourceArena};
+use crate::value::{deduplicated, field, field_str};
 
 const AVG_CODEX_LINE_BYTES: usize = 700;
 
@@ -65,14 +67,21 @@ fn parse_codex_line(line: &[u8], line_index: usize, entries: &mut Vec<CodexEntry
         return;
     }
     match sonic_rs::from_slice::<Value>(line) {
-        Ok(mut value) => {
-            normalize_last_wins(&mut value);
+        Ok(parsed) => {
+            let (value, source_len) = deduplicated(&parsed).unwrap_or_else(|| (parsed, line.len()));
             let timestamp = field_str(&value, "timestamp").and_then(|s| parse_timestamp(s).ok());
             let item = parse_codex_item(&value, line);
+            let source = line_dom(&item)
+                .is_some_and(pins_arena)
+                .then(|| SourceArena {
+                    root: value,
+                    source_len,
+                });
             entries.push(CodexEntry {
                 line_index,
                 timestamp,
                 item,
+                source,
             });
         }
         Err(_) => entries.push(CodexEntry {
@@ -82,6 +91,7 @@ fn parse_codex_line(line: &[u8], line_index: usize, entries: &mut Vec<CodexEntry
                 ty: None,
                 raw: String::from_utf8_lossy(line).into_owned(),
             }),
+            source: None,
         }),
     }
 }

{cc_transcript-14.35.0 → cc_transcript-14.36.0}/rust/crates/core/src/codex/types.rs

@@ -1,11 +1,14 @@
 use chrono::{DateTime, FixedOffset};
 use sonic_rs::Value;
 
+use crate::snapshot_memory::SourceArena;
+
 #[derive(Debug)]
 pub struct CodexEntry {
     pub line_index: usize,
     pub timestamp: Option<DateTime<FixedOffset>>,
     pub item: CodexItem,
+    pub source: Option<SourceArena>,
 }
 
 #[derive(Debug)]

{cc_transcript-14.35.0 → cc_transcript-14.36.0}/rust/crates/core/src/lib.rs

@@ -40,6 +40,7 @@ pub mod snapshot;
 pub mod snapshot_activity;
 pub mod snapshot_codec;
 pub mod snapshot_labels;
+pub mod snapshot_ledger;
 pub mod snapshot_memory;
 pub mod snapshot_owned;
 pub mod snapshot_prepared;