cc-transcript 14.32.0__tar.gz → 14.32.1__tar.gz

{cc_transcript-14.32.0 → cc_transcript-14.32.1}/PKG-INFO

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

{cc_transcript-14.32.0 → cc_transcript-14.32.1}/pyproject.toml

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

@@ -2488,9 +2488,8 @@ impl NativeStore {
             .projections
             .values()
             .map(|cursor| {
-                crate::snapshot_memory::value_charge(&cursor.request).owned_capacity_bytes
-                    + crate::snapshot_memory::value_charge(&cursor.request)
-                        .opaque_dom_accounted_bytes
+                let charge = crate::snapshot_memory::value_charge(&cursor.request);
+                charge.owned_capacity_bytes + charge.opaque_dom_accounted_bytes
             })
             .sum();
         let graph_bytes: usize = state
@@ -2669,24 +2668,25 @@ impl NativeStore {
         let cap = self.memory_cap(context)?;
         if number(&Self::gauges(state), "retained_total_accounted_bytes")?
             .saturating_add(additional)
-            > cap
+            <= cap
         {
-            self.classified
-                .lock()
-                .expect("classified snapshots")
-                .retain(|_, snapshot| Arc::strong_count(snapshot) > 1);
-            let leased: HashSet<_> = state
-                .leases
-                .values()
-                .map(|lease| lease.snapshot.id.clone())
-                .collect();
-            state.latest.retain(|_, snapshot| {
-                leased.contains(&snapshot.id) || Arc::strong_count(snapshot) > 1
-            });
-            state
-                .carried_classifications
-                .retain(|_, carried| Arc::strong_count(carried) > 1);
+            return Ok(());
         }
+        self.classified
+            .lock()
+            .expect("classified snapshots")
+            .retain(|_, snapshot| Arc::strong_count(snapshot) > 1);
+        let leased: HashSet<_> = state
+            .leases
+            .values()
+            .map(|lease| lease.snapshot.id.clone())
+            .collect();
+        state
+            .latest
+            .retain(|_, snapshot| leased.contains(&snapshot.id) || Arc::strong_count(snapshot) > 1);
+        state
+            .carried_classifications
+            .retain(|_, carried| Arc::strong_count(carried) > 1);
         if number(&Self::gauges(state), "retained_total_accounted_bytes")?
             .saturating_add(additional)
             > cap
@@ -7068,6 +7068,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn projection_reservations_preserve_exact_admission_caps_and_release_capacity() {
+        for background in [false, true] {
+            let store = store();
+            let mut owner = context("a");
+            if background {
+                owner.insert("work_class", json!("background"));
+            }
+            let baseline = store.retained_accounted_bytes();
+            let cap = if background {
+                32 * 1024 * 1024 - 4096
+            } else {
+                32 * 1024 * 1024
+            };
+            let reservation = store.reserve_projection(&owner, cap - baseline).unwrap();
+            assert_eq!(store.retained_accounted_bytes(), cap);
+            let refused = store.reserve_projection(&owner, 1);
+            assert!(matches!(refused, Err(error) if error.status == Status::RetainedLimit));
+            assert_eq!(store.retained_accounted_bytes(), cap);
+            drop(reservation);
+            assert_eq!(store.retained_accounted_bytes(), baseline);
+            let reused = store.reserve_projection(&owner, cap - baseline).unwrap();
+            assert_eq!(store.retained_accounted_bytes(), cap);
+            drop(reused);
+            assert_eq!(store.retained_accounted_bytes(), baseline);
+        }
+    }
+
     #[test]
     fn escaped_borrowed_entries_remain_accounted_after_release() {
         let source = Source::new(&format!("{}\n", user("a")));

{cc_transcript-14.32.0 → cc_transcript-14.32.1}/rust/crates/core/src/snapshot_projection.rs

@@ -1336,77 +1336,58 @@ fn workflow_query(
     scalar(json!(matched), work)
 }
 
-fn checked_render<T>(
-    work: &mut Work,
-    range: &Range<usize>,
-    produce: impl FnOnce(&mut Work) -> Result<T, SnapshotError>,
-) -> Result<T, SnapshotError> {
+fn render_window(work: &Work, range: &Range<usize>) -> Result<Range<usize>, SnapshotError> {
+    let limit = work.limits.max_output_bytes;
     let mut input = OutputCounter {
-        remaining: work
-            .limits
-            .max_output_bytes
-            .checked_sub(64)
-            .ok_or_else(output_limit)?
-            / 16,
+        remaining: limit.checked_sub(64).ok_or_else(output_limit)? / 16,
     };
-    let mut clones = work.limits.max_output_bytes;
-    if !range.is_empty() {
-        let first = work
-            .snapshot
-            .activity
-            .turn_of_event(range.start)
-            .expect("view turn");
-        let last = work
-            .snapshot
-            .activity
-            .turn_of_event(range.end - 1)
-            .expect("view turn");
+    let activity = &work.snapshot.activity;
+    let mut start = range.end;
+    let mut turn = 0;
+    let mut bounds = 0..0;
+    let mut pending = HashSet::new();
+    for index in range.clone().rev() {
+        work.cancel.check(work.limits.deadline_unix_ms)?;
+        if !bounds.contains(&index) {
+            turn = activity.turn_of_event(index).expect("view turn");
+            bounds = activity.turn_bounds(turn).expect("view turn");
+            pending.clear();
+        }
+        let entry = work.snapshot.entry(index);
+        pending.extend(entry.blocks().iter().filter_map(|block| match block {
+            ContentBlock::ToolResult(result) => Some(result.tool_use_id.as_str()),
+            _ => None,
+        }));
+        let fits = snapshot_codec::write_json(&mut input, entry, limit).is_ok()
+            && entry.blocks().iter().all(|block| match block {
+                ContentBlock::ToolUse(tool) if pending.contains(tool.id.as_str()) => {
+                    snapshot_codec::write_json(&mut input, tool.name.as_str(), limit).is_ok()
+                }
+                _ => true,
+            })
+            && (index != bounds.start
+                || snapshot_codec::write_json(
+                    &mut input,
+                    activity.prompt(turn).expect("view turn"),
+                    limit,
+                )
+                .is_ok());
+        if !fits {
+            break;
+        }
+        start = index;
+    }
+    let window = start..range.end;
+    if !window.is_empty() {
+        let first = activity.turn_of_event(window.start).expect("view turn");
+        let last = activity.turn_of_event(window.end - 1).expect("view turn");
+        let mut clones = limit;
         for index in first..=last {
-            let copied = work
-                .snapshot
-                .activity
-                .projected_bytes(index)
-                .expect("view turn");
+            let copied = activity.projected_bytes(index).expect("view turn");
             clones = clones.checked_sub(copied).ok_or_else(output_limit)?;
-            let bounds = work
-                .snapshot
-                .activity
-                .turn_bounds(index)
-                .expect("view turn");
-            work.charge_range(bounds.clone())?;
-            let mut names = std::collections::HashMap::new();
-            for position in bounds {
-                let entry = work.snapshot.entry(position);
-                snapshot_codec::write_json(&mut input, entry, work.limits.max_output_bytes)
-                    .map_err(|_| output_limit())?;
-                for block in entry.blocks() {
-                    match block {
-                        ContentBlock::ToolUse(tool) => {
-                            names.insert(tool.id.as_str(), tool.name.as_str());
-                        }
-                        ContentBlock::ToolResult(result) => {
-                            if let Some(name) = names.get(result.tool_use_id.as_str()) {
-                                snapshot_codec::write_json(
-                                    &mut input,
-                                    name,
-                                    work.limits.max_output_bytes,
-                                )
-                                .map_err(|_| output_limit())?;
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-            }
-            snapshot_codec::write_json(
-                &mut input,
-                work.snapshot.activity.prompt(index).expect("view turn"),
-                work.limits.max_output_bytes,
-            )
-            .map_err(|_| output_limit())?;
         }
     }
-    produce(work)
+    Ok(window)
 }
 
 fn render_query(
@@ -1418,24 +1399,30 @@ fn render_query(
     let tool_results = field(query, "tool_results")?
         .as_bool()
         .ok_or_else(|| invalid("tool_results must be boolean"))?;
-    checked_render(work, &range, |work| {
-        let lift = lift_range(work, &range, None)?;
-        let session = view(&lift, &range, work.snapshot);
-        let parts: Vec<_> = session
-            .turn_views()
-            .map(|(_, prompt, events, uses)| {
-                render::render_turn_parts(
-                    prompt,
-                    events,
-                    &uses.iter().map(|use_| &use_.call).collect::<Vec<_>>(),
-                    &budget,
-                    tool_results,
-                )
-            })
-            .filter(|text| !text.is_empty())
-            .collect();
-        scalar(json!(parts.join("\n\n")), work)
-    })
+    let window = render_window(work, &range)?;
+    let lift = lift_range(work, &window, None)?;
+    let session = view(&lift, &window, work.snapshot);
+    let mut parts: Vec<_> = session
+        .turn_views()
+        .map(|(_, prompt, events, uses)| {
+            render::render_turn_parts(
+                prompt,
+                events,
+                &uses.iter().map(|use_| &use_.call).collect::<Vec<_>>(),
+                &budget,
+                tool_results,
+            )
+        })
+        .filter(|text| !text.is_empty())
+        .collect();
+    let omitted = window.start - range.start;
+    if omitted != 0 {
+        parts.insert(
+            0,
+            format!("[{omitted} earlier events omitted: over the render budget]"),
+        );
+    }
+    scalar(json!(parts.join("\n\n")), work)
 }
 
 #[derive(serde::Serialize)]
@@ -2785,19 +2772,103 @@ mod tests {
         let mut cap = limits();
         cap.max_output_bytes = 128;
         let cancel = Cancellation::default();
-        let mut work = Work::new(&snap, &cap, &cancel);
-        let produced = checked_render(&mut work, &(0..1), |_| {
-            visits.set(visits.get() + 1);
-            Ok(())
-        });
-        assert!(matches!(produced,Err(error) if error.status==Status::OutputLimit));
-        assert_eq!(visits.get(), 0);
+        let work = Work::new(&snap, &cap, &cancel);
+        assert_eq!(render_window(&work, &(0..1)).unwrap(), 1..1);
         let req = request(json!({"kind":"user_text"}), json!([]));
         assert!(
             matches!(project(&snap,&req,&cap,&cancel,0),Err(error) if error.status==Status::OutputLimit)
         );
     }
 
+    fn render_request(selectors: Value) -> Value {
+        request(
+            json!({"kind":"render","budget":{"turn_chars":100,"tool_chars":100},"tool_results":false}),
+            selectors,
+        )
+    }
+
+    fn long_turn(calls: usize, input_bytes: usize) -> Vec<Value> {
+        std::iter::once(user("u", "start the long run"))
+            .chain((0..calls).flat_map(|call| {
+                let id = format!("bash-{call}");
+                [
+                    tool(
+                        &format!("call-{call}"),
+                        &id,
+                        "Bash",
+                        json!({"command":format!("echo {call} {}", "x".repeat(input_bytes))}),
+                    ),
+                    tool_result(&format!("result-{call}"), &id, format!("done {call}")),
+                ]
+            }))
+            .collect()
+    }
+
+    #[test]
+    fn render_inside_one_long_turn_charges_only_the_window() {
+        let snap = snapshot(&long_turn(400, 2048));
+        let count = snap.event_count;
+        let cap = long_turn_limits();
+        let mut whole_turn = OutputCounter {
+            remaining: (cap.max_output_bytes - 64) / 16,
+        };
+        assert!((0..count).any(|index| {
+            snapshot_codec::write_json(&mut whole_turn, snap.entry(index), cap.max_output_bytes)
+                .is_err()
+        }));
+        let cancel = Cancellation::default();
+        let request =
+            render_request(json!([{"kind":"event_range","start":count - 6,"stop":count}]));
+        let result = project(&snap, &request, &cap, &cancel, 0).unwrap();
+        assert!(result.complete);
+        let text = result.data["value"].as_str().unwrap();
+        assert!(!text.contains("omitted"));
+        assert!(text.contains("echo 397") && text.contains("echo 399"));
+        assert!(!text.contains("echo 396"));
+    }
+
+    fn long_turn_limits() -> WorkLimits {
+        WorkLimits {
+            max_read_bytes: 64 * 1024 * 1024,
+            max_events: 10_000,
+            max_output_bytes: 2 * 1024 * 1024,
+            ..limits()
+        }
+    }
+
+    #[test]
+    fn over_budget_render_keeps_the_newest_events_and_names_the_omission() {
+        let snap = snapshot(&long_turn(400, 2048));
+        let count = snap.event_count;
+        let cap = long_turn_limits();
+        let cancel = Cancellation::default();
+        let work = Work::new(&snap, &cap, &cancel);
+        let window = render_window(&work, &(0..count)).unwrap();
+        assert_eq!(window.end, count);
+        assert!(window.start > 1 && window.len() > 6);
+        let result = project(&snap, &render_request(json!([])), &cap, &cancel, 0).unwrap();
+        assert!(result.complete);
+        let text = result.data["value"].as_str().unwrap();
+        let marker = format!(
+            "[{} earlier events omitted: over the render budget]\n\n",
+            window.start
+        );
+        assert!(text.starts_with(&marker));
+        assert!(text.contains("echo 399"));
+        assert!(!text.contains("start the long run"));
+        let single = snapshot(&[user("u", &"y".repeat(32768))]);
+        let tiny = WorkLimits {
+            max_output_bytes: 1024,
+            ..limits()
+        };
+        let result = project(&single, &render_request(json!([])), &tiny, &cancel, 0).unwrap();
+        assert!(result.complete);
+        assert_eq!(
+            result.data["value"].as_str(),
+            Some("[1 earlier events omitted: over the render budget]")
+        );
+    }
+
     #[test]
     fn text_preflight_counts_escaping_and_keeps_unicode_prefixes() {
         let parts = ["\n\t\u{0}", "\"\\😀"];