cc-transcript 14.37.1__tar.gz → 14.38.0__tar.gz

{cc_transcript-14.37.1 → cc_transcript-14.38.0}/PKG-INFO

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

{cc_transcript-14.37.1 → cc_transcript-14.38.0}/cc_transcript/snapshot_schema/request.schema.json

@@ -1032,6 +1032,20 @@
     "PrepareGraph": {
       "additionalProperties": false,
       "properties": {
+        "active_since_unix_ms": {
+          "anyOf": [
+            {
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991,
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Active Since Unix Ms"
+        },
         "deadline_unix_ms": {
           "exclusiveMinimum": 0,
           "maximum": 9007199254740991,
@@ -1045,7 +1059,6 @@
             "pattern": "^/",
             "type": "string"
           },
-          "maxItems": 1024,
           "title": "Direct Paths",
           "type": "array"
         },
@@ -1085,7 +1098,6 @@
             "minLength": 1,
             "type": "string"
           },
-          "maxItems": 1024,
           "title": "Thread Ids",
           "type": "array"
         },
@@ -2341,6 +2353,20 @@
     "WarmRegistered": {
       "additionalProperties": false,
       "properties": {
+        "active_since_unix_ms": {
+          "anyOf": [
+            {
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991,
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Active Since Unix Ms"
+        },
         "classifier": {
           "$ref": "#/$defs/Classifier"
         },
@@ -2357,7 +2383,6 @@
             "pattern": "^/",
             "type": "string"
           },
-          "maxItems": 1024,
           "title": "Direct Paths",
           "type": "array"
         },
@@ -2416,7 +2441,6 @@
             "minLength": 1,
             "type": "string"
           },
-          "maxItems": 1024,
           "title": "Thread Ids",
           "type": "array"
         }

{cc_transcript-14.37.1 → cc_transcript-14.38.0}/cc_transcript/snapshot_schema/response.schema.json

@@ -293,6 +293,19 @@
           "minimum": 0,
           "title": "Window Start",
           "type": "integer"
+        },
+        "window_started_unix_ms": {
+          "anyOf": [
+            {
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991,
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "title": "Window Started Unix Ms"
         }
       },
       "required": [
@@ -308,6 +321,7 @@
         "parser_version",
         "source_bytes",
         "window_start",
+        "window_started_unix_ms",
         "committed_bytes",
         "event_count",
         "turn_count",

{cc_transcript-14.37.1 → cc_transcript-14.38.0}/pyproject.toml

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

@@ -204,6 +204,10 @@ impl SourceStamp {
         self
     }
 
+    pub fn window_bytes(&self) -> u64 {
+        self.size - self.identity.window_base
+    }
+
     pub fn viewed_as(mut self, pinned: SourceStamp) -> Self {
         self.identity.window_base = pinned.identity.window_base;
         self
@@ -365,6 +369,17 @@ impl TranscriptSnapshot {
             .collect()
     }
 
+    pub fn window_started_unix_ms(&self) -> Option<i64> {
+        if self.window_start == 0 {
+            return None;
+        }
+        self.chunks
+            .iter()
+            .flat_map(|chunk| chunk.entries.iter())
+            .find_map(Entry::meta)
+            .map(|meta| meta.timestamp.timestamp_millis())
+    }
+
     pub fn entry(&self, position: usize) -> &Entry {
         let at = self.chunks.partition_point(|chunk| chunk.start <= position) - 1;
         &self.chunks[at].entries[position - self.chunks[at].start]
@@ -2919,6 +2934,24 @@ fn tail_bytes(request: &Value) -> Result<Option<u64>, SnapshotError> {
         .transpose()
 }
 
+fn active_since_ns(request: &Value) -> Result<Option<i128>, SnapshotError> {
+    request
+        .get("active_since_unix_ms")
+        .filter(|value| !value.is_null())
+        .map(|value| {
+            value
+                .as_u64()
+                .filter(|since| *since > 0)
+                .map(|since| i128::from(since) * 1_000_000)
+                .ok_or_else(|| invalid("active_since_unix_ms must be a positive integer"))
+        })
+        .transpose()
+}
+
+fn active(source: &PreparedSourceRef, since: Option<i128>) -> bool {
+    since.is_none_or(|since| source.stamp.mtime_ns >= since)
+}
+
 fn io_error(error: std::io::Error) -> SnapshotError {
     let status = match error.kind() {
         std::io::ErrorKind::NotFound => Status::Missing,
@@ -5535,7 +5568,7 @@ impl NativeStore {
             "device": snapshot.stamp.identity.device.to_string(), "inode": snapshot.stamp.identity.inode.to_string(),
             "mtime_ns": snapshot.stamp.mtime_ns.to_string(), "ctime_ns": snapshot.stamp.ctime_ns.to_string(),
             "provider": snapshot.provider.as_str(), "parser_version": PARSER_VERSION,
-            "source_bytes": snapshot.stamp.size, "window_start": snapshot.window_start, "committed_bytes": snapshot.committed_bytes,
+            "source_bytes": snapshot.stamp.size, "window_start": snapshot.window_start, "window_started_unix_ms": snapshot.window_started_unix_ms(), "committed_bytes": snapshot.committed_bytes,
             "event_count": snapshot.event_count, "turn_count": snapshot.activity.turn_count(),
             "classifier": classifier, "provisional_tail": snapshot.provisional_tail,"lease_expires_unix_ms":expires})
     }
@@ -6765,13 +6798,10 @@ impl NativeStore {
             return Err(invalid("source must be a regular file"));
         }
         let stamp = SourceStamp::of(&metadata);
-        if stamp.size > self.config.source as u64 {
-            return Err(SnapshotError::new(
-                Status::SourceLimit,
-                "source exceeds owner bound",
-            ));
-        }
-        let budget = limits.max_source_read_bytes.min(stamp.size as usize);
+        let budget = limits
+            .max_source_read_bytes
+            .min(self.config.source)
+            .min(stamp.size as usize);
         let mut reservation = self.reserve_projection(context, 0)?;
         let mut pending: Vec<u8> = Vec::new();
         let mut pending_start = stamp.size;
@@ -6962,7 +6992,7 @@ impl NativeStore {
         }
         let window = tail_bytes(request)?;
         let stamp = SourceStamp::of(&metadata).windowed(window);
-        if stamp.size > self.config.source as u64 {
+        if stamp.window_bytes() > self.config.source as u64 {
             return Err(SnapshotError::new(
                 Status::SourceLimit,
                 "source exceeds owner bound",
@@ -11875,6 +11905,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn tail_reads_the_newest_events_of_a_source_past_the_owner_bound() {
+        let source = Source::new(&users(0..50));
+        let store = NativeStore::new(&json!({"max_read_bytes_per_step":64,"max_source_bytes":users(40..50).len(),"max_retained_bytes":32*1024*1024,"reserved_hook_accounted_bytes":4096})).unwrap();
+        let owner = context("a");
+        let response = store.request(
+            &tail_request(&source.path, 5, 1024 * 1024),
+            &owner,
+            &Cancellation::default(),
+        );
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(tail_uuids(&response), ["45", "46", "47", "48", "49"]);
+        let read = response["usage"]["source_bytes_read"].as_u64().unwrap() as usize;
+        assert!(read <= users(40..50).len(), "{read}");
+    }
+
     #[test]
     fn tail_refuses_codex_sources_and_counts_outside_the_budgets() {
         let codex = Source::new(
@@ -11971,6 +12017,10 @@ mod tests {
         let response = windowed(&store, &source.path, 4096, &owner);
         let description = &response["data"]["description"];
         assert_eq!(description["window_start"].as_u64(), Some(start));
+        assert_eq!(
+            description["window_started_unix_ms"].as_u64(),
+            Some(1_767_323_045_000)
+        );
         assert_eq!(description["source_bytes"].as_u64(), Some(size));
         assert_eq!(description["committed_bytes"].as_u64(), Some(size));
         assert_eq!(
@@ -12282,6 +12332,7 @@ mod tests {
             unwindowed["data"]["description"]["window_start"].as_u64(),
             Some(0)
         );
+        assert!(unwindowed["data"]["description"]["window_started_unix_ms"].is_null());
     }
 
     #[test]
@@ -14012,6 +14063,102 @@ mod tests {
         assert_eq!(changed["status"].as_str(), Some("changed"), "{changed:?}");
     }
 
+    #[test]
+    fn registered_graph_admits_only_members_active_since_the_cutoff() {
+        let tool = |name: &str| {
+            format!(
+                r#"{{"type":"assistant","uuid":"{name}","sessionId":"s","timestamp":"2026-01-02T03:04:06Z","message":{{"model":"test","content":[{{"type":"tool_use","id":"{name}","name":"{name}","input":{{}}}}]}}}}"#
+            )
+        };
+        let source = Source::new(&format!("{}\n", user("root")));
+        let stale = std::time::SystemTime::now() - std::time::Duration::from_secs(3600);
+        let ids: Vec<String> = (0..1030).map(|index| format!("thread-{index}")).collect();
+        for id in &ids {
+            let path = source.directory.join(format!("{id}.jsonl"));
+            let body = match id.as_str() {
+                "thread-3" => format!("{}\n{}\n", user(id), tool("Grep")),
+                "thread-7" => format!("{}\n{}\n", user(id), tool("Read")),
+                _ => format!("{}\n", user(id)),
+            };
+            std::fs::write(&path, body).unwrap();
+            if id != "thread-7" {
+                File::options()
+                    .write(true)
+                    .open(&path)
+                    .unwrap()
+                    .set_modified(stale)
+                    .unwrap();
+            }
+        }
+        let store = store();
+        let owner = context("a");
+        let mut background = owner.clone();
+        background.insert("work_class", json!("background"));
+        let root = finish(
+            &store,
+            store.request(&acquire(&source.path), &owner, &Cancellation::default()),
+            &owner,
+        );
+        let mut template = acquire(&source.path);
+        template["limits"].insert("max_discovery_entries", json!(20_000));
+        let since = now_ms() - 60_000;
+        let warm = || {
+            let mut request = json!({"schema":SCHEMA,"id":"warm","operation":"warm_registered","classifier":{"id":"native","version":"1"},"thread_ids":ids,"roots":[source.directory.to_string_lossy().as_ref()],"direct_paths":[],"start_index":0,"membership_revision":null,"active_since_unix_ms":since,"deadline_unix_ms":template["deadline_unix_ms"],"limits":template["limits"]});
+            for _ in 0..12 {
+                let reply = store.request(&request, &background, &Cancellation::default());
+                assert_eq!(reply["status"].as_str(), Some("ok"), "{reply:?}");
+                if reply["data"]["complete"].as_bool() == Some(true) {
+                    return;
+                }
+                request.insert("start_index", reply["data"]["next_index"].clone());
+                request.insert(
+                    "membership_revision",
+                    reply["data"]["membership_revision"].clone(),
+                );
+            }
+            panic!("registered warming did not complete");
+        };
+        let prepare = json!({"schema":SCHEMA,"id":"prepare","operation":"prepare_graph","view":{"handle":handle(&root),"classifier":{"id":"native","version":"1"},"selectors":[],"attachments":[]},"thread_ids":ids,"roots":[source.directory.to_string_lossy().as_ref()],"direct_paths":[],"active_since_unix_ms":since,"deadline_unix_ms":template["deadline_unix_ms"],"limits":template["limits"]});
+        let has = |graph: &Value, name: &str| {
+            let result = finish_prepared(
+                &store,
+                store.request(&json!({"schema":SCHEMA,"id":"query","operation":"query_graph","handle":graph["data"]["handle"],"selectors":[],"query":{"kind":"has_tool","pattern":name,"subagents":true},"deadline_unix_ms":template["deadline_unix_ms"],"limits":template["limits"]}), &owner, &Cancellation::default()),
+                &owner,
+            );
+            assert_eq!(result["status"].as_str(), Some("ok"), "{result:?}");
+            result["data"]["value"].as_bool().unwrap()
+        };
+        warm();
+        let graph = finish_prepared(
+            &store,
+            store.request(&prepare, &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(graph["status"].as_str(), Some("ok"), "{graph:?}");
+        assert!(has(&graph, "Read"));
+        assert!(!has(&graph, "Grep"));
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(source.directory.join("thread-3.jsonl"))
+            .unwrap()
+            .write_all(format!("{}\n", user("resumed")).as_bytes())
+            .unwrap();
+        let stale_membership = store.request(&prepare, &owner, &Cancellation::default());
+        assert_eq!(
+            stale_membership["status"].as_str(),
+            Some("incomplete"),
+            "{stale_membership:?}"
+        );
+        warm();
+        let resumed = finish_prepared(
+            &store,
+            store.request(&prepare, &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(resumed["status"].as_str(), Some("ok"), "{resumed:?}");
+        assert!(has(&resumed, "Grep"));
+    }
+
     #[test]
     fn background_warming_preserves_a_foreground_load_slot() {
         let source = Source::new(&format!("{}\n", user("root")));

{cc_transcript-14.37.1 → cc_transcript-14.38.0}/rust/crates/core/src/snapshot_prepared_service.rs

@@ -654,6 +654,7 @@ impl NativeStore {
             "thread_ids": request["thread_ids"],
             "roots": request["roots"],
             "direct_paths": request["direct_paths"],
+            "active_since_unix_ms": request["active_since_unix_ms"],
             "registry_generation": context["registry_generation"],
             "admission": context["admission"],
             "authority": context["authority"],
@@ -767,13 +768,14 @@ impl NativeStore {
             .get("roots")
             .and_then(Value::as_array)
             .ok_or_else(|| invalid("missing roots"))?;
-        let direct = request
+        request
             .get("direct_paths")
             .and_then(Value::as_array)
             .ok_or_else(|| invalid("missing direct_paths"))?;
-        if ids.len() > 1024 || roots.len() > 64 || direct.len() > 1024 {
+        if roots.len() > 64 {
             return Err(invalid("prepared registry input exceeds its bound"));
         }
+        let since = active_since_ns(request)?;
         if !ids.is_empty() {
             let key = Self::warm_membership_key(request, context)?;
             let (members, sidechain_dirs, complete) = self
@@ -814,14 +816,20 @@ impl NativeStore {
                 Some(index) => (&members[..index], &members[index + 1..]),
                 None => (&members[..], &members[members.len()..]),
             };
-            let others = || before.iter().chain(after);
+            let others = || {
+                before
+                    .iter()
+                    .chain(after)
+                    .filter(move |source| active(source, since))
+            };
+            let copied = shared.is_some() || since.is_some();
             let graph_id = self.token("prepared-graph");
             let stamps_bytes = (others().count() + 1) * size_of::<(PathBuf, SourceStamp)>()
                 + root.canonical_path.as_os_str().len()
                 + others()
                     .map(|source| source.path.as_os_str().len())
                     .sum::<usize>();
-            let buffers: usize = if shared.is_some() {
+            let buffers: usize = if copied {
                 arc_slice_bytes::<PreparedSourceRef>(others().count())
                     + others()
                         .map(|source| source.path.as_os_str().len())
@@ -845,7 +853,7 @@ impl NativeStore {
                     + stamps_bytes
                     + buffers,
             )?;
-            let sources: Arc<[PreparedSourceRef]> = if shared.is_some() {
+            let sources: Arc<[PreparedSourceRef]> = if copied {
                 #[cfg(test)]
                 self.registered_sources.fetch_add(1, Ordering::Relaxed);
                 others().cloned().collect()
@@ -1154,7 +1162,26 @@ impl NativeStore {
                     if build.seen.contains(&stamp.identity.file()) {
                         continue;
                     }
-                    if build.seen.len() >= build.remaining.max_sources {
+                    if active_since_ns(&build.request)?.is_some_and(|since| stamp.mtime_ns < since) {
+                        self.extend_projection_reservation(
+                            reservation,
+                            context,
+                            set_growth(&build.seen, 1) + canonical.as_os_str().len(),
+                        )?;
+                        let predicted = (set_capacity_for(&build.seen, 1), build.tasks.capacity());
+                        build.seen.insert(stamp.identity.file());
+                        build.tasks.push(GraphTask::List {
+                            parent: canonical,
+                            depth: depth + 1,
+                        });
+                        assert_eq!(
+                            (build.seen.capacity(), build.tasks.capacity()),
+                            predicted,
+                            "prepared build collections landed off their predicted capacities"
+                        );
+                        continue;
+                    }
+                    if build.stamps.len() >= build.remaining.max_sources {
                         return Err(SnapshotError::new(
                             Status::Incomplete,
                             "prepared graph source budget exhausted",
@@ -1363,9 +1390,12 @@ impl NativeStore {
         )?;
         #[cfg(test)]
         self.warm_records.fetch_add(1, Ordering::Relaxed);
+        let since = active_since_ns(request)?;
         let mut located = HashMap::new();
-        if !ids.is_empty() {
-            let location = json!({"schema":SCHEMA,"id":"warm-registered-locate","operation":"locate","session_ids":ids,"roots":roots,"deadline_unix_ms":remaining.deadline_unix_ms,"limits":remaining.to_json()});
+        for chunk in ids.chunks(1024.min(remaining.max_items)) {
+            let mut bounds = *remaining;
+            bounds.max_sources = chunk.len();
+            let location = json!({"schema":SCHEMA,"id":"warm-registered-locate","operation":"locate","session_ids":chunk,"roots":roots,"deadline_unix_ms":remaining.deadline_unix_ms,"limits":bounds.to_json()});
             let before = usage[17];
             let mut outcome = self.locate(&location, context, cancel, usage)?;
             loop {
@@ -1434,12 +1464,6 @@ impl NativeStore {
         let mut examined = 0usize;
         while examined < members.len() {
             cancel.check(remaining.deadline_unix_ms)?;
-            if members.len() > remaining.max_sources {
-                return Err(SnapshotError::new(
-                    Status::Incomplete,
-                    "registered source bound exhausted",
-                ));
-            }
             let source = &members[examined];
             let directory = sidechain_directory(
                 source
@@ -1522,6 +1546,12 @@ impl NativeStore {
             }
             examined += 1;
         }
+        if members.iter().filter(|member| active(member, since)).count() > remaining.max_sources {
+            return Err(SnapshotError::new(
+                Status::Incomplete,
+                "registered source bound exhausted",
+            ));
+        }
         let mut digest = Sha256::new();
         for source in &members {
             digest.update(source.path.as_os_str().as_encoded_bytes());
@@ -1597,16 +1627,16 @@ impl NativeStore {
         if request["classifier"] != json!({"id":"native","version":"1"}) {
             return Err(invalid("registered warming requires the native classifier"));
         }
-        let ids = request["thread_ids"]
+        request["thread_ids"]
             .as_array()
             .ok_or_else(|| invalid("missing registered thread ids"))?;
         let roots = request["roots"]
             .as_array()
             .ok_or_else(|| invalid("missing registered roots"))?;
-        let direct = request["direct_paths"]
+        request["direct_paths"]
             .as_array()
             .ok_or_else(|| invalid("missing registered direct paths"))?;
-        if ids.len() > 1024 || roots.len() > 64 || direct.len() > 1024 {
+        if roots.len() > 64 {
             return Err(invalid("registered warming input exceeds its bound"));
         }
         let start = number(request, "start_index")?;
@@ -1661,11 +1691,16 @@ impl NativeStore {
                 "registered warming membership changed",
             ));
         }
+        let since = active_since_ns(request)?;
         let mut next = start;
         let mut steps = 0usize;
         'warming: while next < members.len() && steps < 8 {
             cancel.check(remaining.deadline_unix_ms)?;
             let source = &members[next];
+            if !active(source, since) {
+                next += 1;
+                continue;
+            }
             let before_read = usage[1];
             let before_events = usage[3];
             let (stamp, mut outcome) = match self.prepared_source(
@@ -1777,7 +1812,7 @@ impl NativeStore {
                     "registered warming membership changed",
                 ));
             }
-            for source in members.iter() {
+            for source in members.iter().filter(|source| active(source, since)) {
                 cancel.check(remaining.deadline_unix_ms)?;
                 let key = crate::snapshot_prepared_disk::PreparedDiskKey::new(
                     source.stamp,

{cc_transcript-14.37.1 → cc_transcript-14.38.0}/rust/crates/core/src/snapshot_root_warm.rs

@@ -23,7 +23,7 @@ impl NativeStore {
             return Err(invalid("root source must be a regular file"));
         }
         let current = SourceStamp::of(&metadata).windowed(tail_bytes(request)?);
-        if current.size > self.config.source as u64 {
+        if current.window_bytes() > self.config.source as u64 {
             return Err(SnapshotError::new(
                 Status::SourceLimit,
                 "root source exceeds owner bound",
@@ -346,6 +346,41 @@ mod root_warm_tests {
         std::fs::remove_dir_all(directory).unwrap();
     }
 
+    #[test]
+    fn a_trailing_window_of_a_root_past_the_source_bound_warms_and_acquires() {
+        let (directory, path) = source(4 * 1024 * 1024);
+        let bound = std::fs::metadata(&path).unwrap().len() - 1;
+        let store = NativeStore::new(&json!({"max_read_bytes_per_step":256*1024,"max_source_bytes":bound,"max_retained_bytes":128*1024*1024,"reserved_hook_accounted_bytes":4096,"max_leases":16,"reserved_hook_leases":1})).unwrap();
+        let context = context("bounded-window");
+        let mut request = warm_request(&path, 256 * 1024);
+        request.insert("tail_bytes", json!(256 * 1024));
+        let mut finished = false;
+        for _ in 0..24 {
+            let reply = store.request(&request, &context, &Cancellation::default());
+            assert_eq!(reply["status"].as_str(), Some("ok"), "{reply:?}");
+            if reply["data"]["complete"].as_bool() == Some(true) {
+                finished = true;
+                break;
+            }
+        }
+        assert!(finished);
+        let mut acquire = request.clone();
+        acquire.insert("operation", json!("acquire"));
+        let acquired = store.request(&acquire, &context, &Cancellation::default());
+        assert_eq!(acquired["status"].as_str(), Some("ok"), "{acquired:?}");
+        acquire.insert("tail_bytes", json!(null));
+        let whole = store.request(&acquire, &context, &Cancellation::default());
+        assert_eq!(whole["status"].as_str(), Some("source_limit"), "{whole:?}");
+        assert_eq!(whole["reason"].as_str(), Some("source exceeds owner bound"));
+        let whole_warm = store.request(
+            &warm_request(&path, 256 * 1024),
+            &context,
+            &Cancellation::default(),
+        );
+        assert_eq!(whole_warm["status"].as_str(), Some("source_limit"), "{whole_warm:?}");
+        std::fs::remove_dir_all(directory).unwrap();
+    }
+
     #[test]
     fn a_base_advance_supersedes_the_previous_window_pin() {
         let (directory, path) = source(4 * 1024 * 1024);