cc-transcript 14.37.2__tar.gz → 14.39.0__tar.gz

{cc_transcript-14.37.2 → cc_transcript-14.39.0}/PKG-INFO

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

{cc_transcript-14.37.2 → cc_transcript-14.39.0}/cc_transcript/query.py

@@ -51,6 +51,7 @@ if TYPE_CHECKING:
 DEEP_LIFT_BUDGET = 1024 * 1024 * 1024
 DEEP_LIFT_FENCE = 64
 IDLE_SECONDS_BEFORE_RELEASE = 900
+SYNTHETIC_MODEL = "<synthetic>"
 
 type LiftStamp = tuple[int, int, int, int]
 type LiftKey = tuple[Path, int, ToolUseId | None]
@@ -542,6 +543,18 @@ class Session:
         """Every event in the window, in order."""
         return tuple(event for turn in self.turns for event in turn.events)
 
+    @cached_property
+    def model(self) -> str | None:
+        """The model behind the window's last non-synthetic assistant event, or ``None`` before the first reply."""
+        return next(
+            (
+                event.model
+                for event in reversed(self.events)
+                if isinstance(event, AssistantEvent) and event.model != SYNTHETIC_MODEL
+            ),
+            None,
+        )
+
     @cached_property
     def tool_calls(self) -> ToolCallQuery:
         """The window's tool calls as a chainable query."""

{cc_transcript-14.37.2 → cc_transcript-14.39.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.2 → cc_transcript-14.39.0}/cc_transcript/snapshot_schema/response.schema.json

@@ -247,6 +247,19 @@
           "title": "Lease Expires Unix Ms",
           "type": "integer"
         },
+        "model": {
+          "anyOf": [
+            {
+              "maxLength": 256,
+              "minLength": 1,
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "title": "Model"
+        },
         "mtime_ns": {
           "pattern": "^[0-9]+$",
           "title": "Mtime Ns",
@@ -293,6 +306,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 +334,8 @@
         "parser_version",
         "source_bytes",
         "window_start",
+        "window_started_unix_ms",
+        "model",
         "committed_bytes",
         "event_count",
         "turn_count",

{cc_transcript-14.37.2 → cc_transcript-14.39.0}/pyproject.toml

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

@@ -30,7 +30,7 @@ use crate::snapshot_memory::{
     arena_bytes, arena_charge, dom_parse_bound, entry_charge, MemoryCharge, SourceArena,
 };
 use crate::snapshot_projection::JSON_LITERAL_OBJECT_CAPACITY;
-use crate::types::Entry;
+use crate::types::{Entry, SYNTHETIC_MODEL};
 
 pub const SCHEMA: &str = "cc-transcript.snapshot/1";
 pub const PARSER_VERSION: &str = "cc-transcript.snapshot/1";
@@ -369,6 +369,30 @@ 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 model(&self) -> Option<&str> {
+        self.chunks
+            .iter()
+            .rev()
+            .flat_map(|chunk| chunk.entries.iter().rev())
+            .find_map(|entry| match entry {
+                Entry::Assistant(assistant) if assistant.model != SYNTHETIC_MODEL => {
+                    Some(assistant.model.as_str())
+                }
+                _ => None,
+            })
+    }
+
     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]
@@ -2923,6 +2947,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,
@@ -5539,7 +5581,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(), "model": snapshot.model(), "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})
     }
@@ -11988,6 +12030,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!(
@@ -12274,6 +12320,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn acquire_describes_the_latest_non_synthetic_model() {
+        let reply = |uuid: &str, model: &str| {
+            format!(
+                r#"{{"type":"assistant","uuid":"{uuid}","sessionId":"s","timestamp":"2026-01-02T03:04:06Z","message":{{"model":"{model}","content":[{{"type":"text","text":"ok"}}]}}}}"#
+            )
+        };
+        let source = Source::new(&format!(
+            "{}{}\n{}\n{}\n{}",
+            users(0..2),
+            reply("older", "claude-opus-4-7"),
+            reply("newer", "claude-opus-5-5"),
+            reply("error", SYNTHETIC_MODEL),
+            users(2..3)
+        ));
+        let silent = Source::new(&users(0..3));
+        let store = windowed_store();
+        let owner = context("a");
+        let model = |path: &Path| {
+            finish(
+                &store,
+                store.request(&acquire(path), &owner, &Cancellation::default()),
+                &owner,
+            )["data"]["description"]["model"]
+                .clone()
+        };
+
+        assert_eq!(model(&source.path), json!("claude-opus-5-5"));
+        assert_eq!(model(&silent.path), json!(null));
+    }
+
     #[test]
     fn null_tail_bytes_is_a_whole_file_acquire() {
         let source = Source::new(&users(0..200));
@@ -12299,6 +12376,7 @@ mod tests {
             unwindowed["data"]["description"]["window_start"].as_u64(),
             Some(0)
         );
+        assert!(unwindowed["data"]["description"]["window_started_unix_ms"].is_null());
     }
 
     #[test]
@@ -14029,6 +14107,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.2 → cc_transcript-14.39.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.2 → cc_transcript-14.39.0}/rust/crates/core/src/types.rs

@@ -432,6 +432,8 @@ pub struct AttachmentEntry {
     pub detail: AttachmentDetail,
 }
 
+pub const SYNTHETIC_MODEL: &str = "<synthetic>";
+
 /// One parsed JSONL transcript line. Each line is parsed exactly once into this
 /// model; Python objects are materialized from it afterwards.
 #[derive(Debug, serde::Serialize, serde::Deserialize)]