cc-transcript 14.31.0__tar.gz → 14.31.1__tar.gz

{cc_transcript-14.31.0 → cc_transcript-14.31.1}/PKG-INFO

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

{cc_transcript-14.31.0 → cc_transcript-14.31.1}/pyproject.toml

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

@@ -423,6 +423,7 @@ struct Waiter {
     used_source_bytes: usize,
     used_events: usize,
     stage: Option<Arc<ClassifierSlot>>,
+    windowed: bool,
     busy: bool,
 }
 
@@ -4154,6 +4155,7 @@ impl NativeStore {
                 used_source_bytes: 0,
                 used_events: 0,
                 stage: None,
+                windowed: window.is_some(),
                 busy: false,
             };
             state.waiters.insert(cursor.clone(), waiter.clone());
@@ -4409,6 +4411,14 @@ impl NativeStore {
         if let Some(snapshot) = &load.result {
             let snapshot = Arc::clone(snapshot);
             drop(load);
+            if waiter.windowed && snapshot.provider == Provider::Codex {
+                self.state
+                    .lock()
+                    .expect("snapshot state")
+                    .waiters
+                    .remove(token);
+                return Err(invalid("tail_bytes requires a Claude source"));
+            }
             let mut state = self.state.lock().expect("snapshot state");
             if !state
                 .latest
@@ -5039,7 +5049,7 @@ impl NativeStore {
                 depth: 1,
             });
         }
-        let identity = root.stamp.identity;
+        let identity = root.stamp.identity.file();
         let graph = GraphCursor {
             claimant: str_field(context, "claimant")?.to_owned(),
             context: context.clone(),
@@ -5199,7 +5209,7 @@ impl NativeStore {
             &graph.context,
             graph.remaining.deadline_unix_ms,
         )?;
-        let identity = snapshot.stamp.identity;
+        let identity = snapshot.stamp.identity.file();
         if !graph.seen.insert(identity)
             && graph.request["query"]["kind"].as_str() != Some("direct_sidechains")
         {
@@ -8235,6 +8245,64 @@ mod tests {
             &Cancellation::default(),
         );
         assert_eq!(zero["status"].as_str(), Some("invalid_request"));
+        let size = std::fs::metadata(&codex.path).unwrap().len();
+        for tail_bytes in [size, size - 1, 1024 * 1024] {
+            let covered = finish(
+                &store,
+                store.request(
+                    &windowed_acquire(&codex.path, tail_bytes),
+                    &owner,
+                    &Cancellation::default(),
+                ),
+                &owner,
+            );
+            assert_eq!(
+                covered["reason"].as_str(),
+                Some("tail_bytes requires a Claude source"),
+                "{tail_bytes}: {covered:?}"
+            );
+        }
+        let whole = finish(
+            &store,
+            store.request(&acquire(&codex.path), &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(whole["status"].as_str(), Some("ok"), "{whole:?}");
+        let cached = finish(
+            &store,
+            store.request(
+                &windowed_acquire(&codex.path, 1024 * 1024),
+                &owner,
+                &Cancellation::default(),
+            ),
+            &owner,
+        );
+        assert_eq!(cached["status"].as_str(), Some("invalid_request"));
+        assert_eq!(
+            cached["reason"].as_str(),
+            Some("tail_bytes requires a Claude source")
+        );
+    }
+
+    #[test]
+    fn windowed_root_attached_to_itself_is_not_its_own_child() {
+        let source = Source::new(&users(0..200));
+        let store = windowed_store();
+        let owner = context("a");
+        let root = windowed(&store, &source.path, 4096, &owner);
+        let (_, _, first) = expected_window(&source.path, 4096);
+        assert!(first > 0);
+        let records = graph_records(
+            &store,
+            &graph_request(
+                &root,
+                json!({"kind":"sidechain_membership","order":"forward"}),
+                vec![source.path.to_string_lossy().into_owned()],
+                json!([]),
+            ),
+            &owner,
+        );
+        assert!(records.is_empty(), "{records:?}");
     }
 
     #[test]

{cc_transcript-14.31.0 → cc_transcript-14.31.1}/rust/crates/core/src/snapshot_labels.rs

@@ -470,7 +470,7 @@ impl LabelPreparation {
             session_id: self.source.session_id.clone(),
             chunks: self.source.chunks.clone(),
             activity: Arc::new(self.activity),
-            window_start: 0,
+            window_start: self.source.window_start,
             committed_bytes: self.source.committed_bytes,
             provisional_tail: self.source.provisional_tail,
             fence: self.source.fence.clone(),
@@ -1042,4 +1042,26 @@ mod tests {
             "labels:execution"
         );
     }
+
+    #[test]
+    fn finish_keeps_the_source_window_start() {
+        let mut snapshot = source(vec![user(0, "prompt"), user(1, "later")]);
+        {
+            let windowed = Arc::get_mut(&mut snapshot).unwrap();
+            windowed.window_start = 1000;
+            windowed.stamp.identity.window_base = 1024;
+        }
+        let binding = binding("execution");
+        let cancel = Cancellation::default();
+        let mut stage =
+            LabelPreparation::new(snapshot, binding.clone(), limits(), 8 * PAGE_BYTES, None)
+                .unwrap();
+        stage.next_page("page1".into(), &binding, &cancel).unwrap();
+        assert!(stage
+            .submit("page1", &[true, false], &binding, &cancel)
+            .unwrap());
+        let derived = stage.finish(&binding, &cancel).unwrap().0;
+        assert_eq!(derived.window_start, 1000);
+        assert_eq!(derived.stamp.identity.window_base, 1024);
+    }
 }

{cc_transcript-14.31.0 → cc_transcript-14.31.1}/rust/crates/core/src/snapshot_root_warm.rs

@@ -35,13 +35,22 @@ impl NativeStore {
                 .prepared_loads
                 .keys()
                 .filter(|identity| {
-                    identity.file() == current.identity.file() && **identity != current.identity
+                    current.identity.window_base > 0
+                        && identity.window_base > 0
+                        && identity.file() == current.identity.file()
+                        && **identity != current.identity
                 })
                 .copied()
                 .collect();
             for identity in superseded {
                 state.prepared_loads.remove(&identity);
-                state.loads.remove(&identity);
+                if state
+                    .loads
+                    .get(&identity)
+                    .is_some_and(|slot| Arc::strong_count(slot) == 1)
+                {
+                    state.loads.remove(&identity);
+                }
             }
             if let Some((slot, touched)) = state.prepared_loads.get_mut(&current.identity) {
                 if Self::matches_prefix(current, slot.stamp)
@@ -65,7 +74,15 @@ impl NativeStore {
         };
         let stamp = pinned.as_ref().map_or(current, |slot| slot.stamp);
         let outcome = if let Some(slot) = pinned {
-            self.resume_warm_root(slot, classifier, context, bounds, cancel, usage)
+            self.resume_warm_root(
+                slot,
+                classifier,
+                context,
+                bounds,
+                tail_bytes(request)?.is_some(),
+                cancel,
+                usage,
+            )
         } else {
             self.acquire(request, context, cancel, usage)
         };
@@ -152,6 +169,7 @@ impl NativeStore {
         classifier: &Value,
         context: &Value,
         bounds: WorkLimits,
+        windowed: bool,
         cancel: &Cancellation,
         usage: &mut [u64; 18],
     ) -> Result<(Value, Option<String>, Option<String>), SnapshotError> {
@@ -173,6 +191,7 @@ impl NativeStore {
             used_source_bytes: 0,
             used_events: 0,
             stage: None,
+            windowed,
             busy: false,
         };
         {
@@ -364,6 +383,43 @@ mod root_warm_tests {
         std::fs::remove_dir_all(directory).unwrap();
     }
 
+    #[test]
+    fn whole_file_and_window_warms_keep_their_own_pins() {
+        let (directory, path) = source(4 * 1024 * 1024);
+        let store = NativeStore::new(&json!({"max_read_bytes_per_step":256*1024,"max_retained_bytes":128*1024*1024,"reserved_hook_accounted_bytes":4096,"max_leases":16,"reserved_hook_leases":1})).unwrap();
+        let context = context("alternating-views");
+        let whole = warm_request(&path, 256 * 1024);
+        let mut window = whole.clone();
+        window.insert("tail_bytes", json!(1024 * 1024));
+        let step = |request: &Value| {
+            let reply = store.request(request, &context, &Cancellation::default());
+            assert_eq!(reply["status"].as_str(), Some("ok"), "{reply:?}");
+            assert_eq!(reply["data"]["complete"].as_bool(), Some(false), "{reply:?}");
+            reply["data"]["source_offset"].as_u64().unwrap()
+        };
+        step(&whole);
+        let whole_offset = step(&whole);
+        assert!(whole_offset > 0);
+        step(&window);
+        let window_offset = step(&window);
+        assert!(window_offset > whole_offset);
+        assert_eq!(store.state.lock().unwrap().prepared_loads.len(), 2);
+        let advances = |request: &Value, from: u64| {
+            for _ in 0..4 {
+                let offset = step(request);
+                assert!(offset >= from, "{offset} < {from}");
+                if offset > from {
+                    return;
+                }
+            }
+            panic!("view did not advance past {from}");
+        };
+        advances(&whole, whole_offset);
+        advances(&window, window_offset);
+        assert_eq!(store.state.lock().unwrap().prepared_loads.len(), 2);
+        std::fs::remove_dir_all(directory).unwrap();
+    }
+
     #[test]
     fn a_productive_deadline_keeps_the_partial_root() {
         let (directory, path) = source(1024 * 1024);