cc-transcript 14.45.9__tar.gz → 14.45.11__tar.gz

{cc_transcript-14.45.9 → cc_transcript-14.45.11}/PKG-INFO

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

{cc_transcript-14.45.9 → cc_transcript-14.45.11}/pyproject.toml

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

@@ -14565,6 +14565,74 @@ mod tests {
         assert!(validate().unwrap_err().status == Status::PermissionDenied);
     }
 
+    #[test]
+    fn source_validation_skips_its_parent_hold_once_cancelled_or_past_its_deadline() {
+        let source = Source::new(&format!("{}\n", user("root")));
+        let sources = canonical_members(&source.directory.join("members"), &["a", "b"], "");
+        let store = store();
+        let owner = context("a");
+        let validate = |cancel: &Cancellation, deadline: u64| {
+            let before = store.source_resolutions.load(Ordering::Relaxed);
+            let validated = store
+                .validate_source_stamps(&sources, &owner, cancel, deadline)
+                .map_err(|error| error.status);
+            (
+                validated,
+                store.source_resolutions.load(Ordering::Relaxed) - before,
+            )
+        };
+        assert_eq!(
+            validate(&Cancellation::default(), now_ms() + 30_000),
+            (Ok(true), 2)
+        );
+        for (cancels, status) in [(true, Status::Cancelled), (false, Status::Deadline)] {
+            let cancel = Cancellation::default();
+            let deadline = now_ms() + 1_000;
+            *store.resolve_hook.lock().unwrap() = Some(Arc::new({
+                let (cancel, last) = (cancel.clone(), sources[1].path.clone());
+                move |path: &Path| {
+                    if path != last {
+                        return;
+                    }
+                    if cancels {
+                        cancel.cancel();
+                    } else {
+                        while now_ms() <= deadline {
+                            std::thread::sleep(std::time::Duration::from_millis(5));
+                        }
+                    }
+                }
+            }));
+            assert_eq!(validate(&cancel, deadline), (Err(status), 1));
+        }
+    }
+
+    #[test]
+    fn empty_membership_validation_reports_cancellation_and_an_expired_deadline() {
+        let store = store();
+        let owner = context("a");
+        let cancelled = Cancellation::default();
+        cancelled.cancel();
+        for (cancel, deadline, status) in [
+            (Cancellation::default(), now_ms(), Status::Deadline),
+            (cancelled, now_ms() + 30_000, Status::Cancelled),
+        ] {
+            let before = store.source_resolutions.load(Ordering::Relaxed);
+            assert_eq!(
+                (
+                    store
+                        .validate_source_stamps(&[], &owner, &cancel, deadline)
+                        .map_err(|error| error.status),
+                    store
+                        .validate_sidechain_dirs(&[], &owner, &cancel, deadline)
+                        .map_err(|error| error.status),
+                ),
+                (Err(status), Err(status))
+            );
+            assert_eq!(store.source_resolutions.load(Ordering::Relaxed), before);
+        }
+    }
+
     #[test]
     fn early_positive_query_rejects_a_parent_retargeted_during_its_page() {
         let source = Source::new(&format!("{}\n", user("root")));
@@ -14972,7 +15040,7 @@ mod tests {
             .unwrap();
         registered_pages(&store, &owner, &fresh);
         positions();
-        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 1);
         store.assert_conserved();
 
         store.lock_state().remove_warm_membership(&key);
@@ -17221,7 +17289,7 @@ mod tests {
         );
         assert_eq!(resumed["status"].as_str(), Some("ok"), "{resumed:?}");
         assert!(has(&resumed, "Grep"));
-        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 1);
     }
 
     fn tool_use_line(name: &str) -> String {
@@ -17342,7 +17410,7 @@ mod tests {
         );
         assert_eq!(appended["status"].as_str(), Some("ok"), "{appended:?}");
         assert!(graph_has_tool(&store, &source, &owner, &appended, "Grep"));
-        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 1);
         let subagents = source.directory.join("thread-a").join("subagents");
         std::fs::create_dir_all(&subagents).unwrap();
         std::fs::write(
@@ -17357,14 +17425,103 @@ mod tests {
         );
         assert_eq!(discovered["status"].as_str(), Some("ok"), "{discovered:?}");
         assert!(graph_has_tool(&store, &source, &owner, &discovered, "Bash"));
-        assert_eq!(store.warm_records.load(Ordering::Relaxed), 3);
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
         let hot = finish_prepared(
             &store,
             store.request(&prepare, &owner, &Cancellation::default()),
             &owner,
         );
         assert_eq!(hot["status"].as_str(), Some("ok"), "{hot:?}");
-        assert_eq!(store.warm_records.load(Ordering::Relaxed), 3);
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
+        store.assert_conserved();
+    }
+
+    #[test]
+    fn registered_graph_append_does_not_relist_an_unchanged_sidechain_directory() {
+        let source = Source::new(&format!("{}\n", user("root")));
+        let members = registered_members(&source, &["thread-a", "thread-b"]);
+        let subagents = source.directory.join("thread-a").join("subagents");
+        std::fs::create_dir_all(&subagents).unwrap();
+        std::fs::write(
+            subagents.join("preexisting.jsonl"),
+            format!("{}\n{}\n", user("preexisting"), tool_use_line("Read")),
+        )
+        .unwrap();
+        let store = store();
+        let owner = context("a");
+        let root = finish(
+            &store,
+            store.request(&acquire(&source.path), &owner, &Cancellation::default()),
+            &owner,
+        );
+        let prepare = registered_prepare(&source, &root, &["thread-a", "thread-b"]);
+        let discovery = || store.lock_state().counters[17];
+        let directory_stamp = || SourceStamp::of(&std::fs::metadata(&subagents).unwrap());
+        let graph = finish_prepared(
+            &store,
+            store.request(&prepare, &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(graph["status"].as_str(), Some("ok"), "{graph:?}");
+        assert!(graph_has_tool(&store, &source, &owner, &graph, "Read"));
+        assert!(!graph_has_tool(&store, &source, &owner, &graph, "Grep"));
+        assert!(!graph_has_tool(&store, &source, &owner, &graph, "Bash"));
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 1);
+        let listed = directory_stamp();
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&members[1])
+            .unwrap()
+            .write_all(format!("{}\n", tool_use_line("Grep")).as_bytes())
+            .unwrap();
+        assert_eq!(directory_stamp(), listed);
+        let before = discovery();
+        let appended = finish_prepared(
+            &store,
+            store.request(&prepare, &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(
+            discovery() - before,
+            0,
+            "a member append listed an unchanged sidechain directory again"
+        );
+        assert_eq!(appended["status"].as_str(), Some("ok"), "{appended:?}");
+        assert!(graph_has_tool(&store, &source, &owner, &appended, "Read"));
+        assert!(graph_has_tool(&store, &source, &owner, &appended, "Grep"));
+        assert!(!graph_has_tool(&store, &source, &owner, &appended, "Bash"));
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 1);
+        store.assert_conserved();
+        std::fs::write(
+            subagents.join("child.jsonl"),
+            format!("{}\n{}\n", user("child"), tool_use_line("Bash")),
+        )
+        .unwrap();
+        assert_ne!(directory_stamp(), listed);
+        let before = discovery();
+        let discovered = finish_prepared(
+            &store,
+            store.request(&prepare, &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert!(discovery() > before);
+        assert_eq!(discovered["status"].as_str(), Some("ok"), "{discovered:?}");
+        for tool in ["Read", "Grep", "Bash"] {
+            assert!(graph_has_tool(&store, &source, &owner, &discovered, tool));
+        }
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
+        let before = discovery();
+        let hot = finish_prepared(
+            &store,
+            store.request(&prepare, &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(discovery(), before);
+        assert_eq!(hot["status"].as_str(), Some("ok"), "{hot:?}");
+        for tool in ["Read", "Grep", "Bash"] {
+            assert!(graph_has_tool(&store, &source, &owner, &hot, tool));
+        }
+        assert_eq!(store.warm_records.load(Ordering::Relaxed), 2);
         store.assert_conserved();
     }
 
@@ -17525,6 +17682,81 @@ mod tests {
         assert_eq!(store.prepared_disk.stats().writes, writes);
     }
 
+    #[test]
+    fn registered_append_refresh_reserves_the_member_paths_it_copies() {
+        let (source, store, owner, request) = registered_warming(20);
+        let store = Arc::new(store);
+        registered_pages(&store, &owner, &request);
+        let warmed = store
+            .lock_state()
+            .warm_memberships
+            .values()
+            .next()
+            .unwrap()
+            .clone();
+        let live = source_ref_bytes(&warmed.members)
+            + arc_slice_bytes::<(SourceIdentity, usize)>(warmed.positions.len())
+            + sidechain_dir_bytes(&warmed.sidechain_dirs)
+            + warmed.members.len() * size_of::<PreparedSourceRef>();
+        let copied: usize = warmed.members[..warmed.members.len() - 1]
+            .iter()
+            .map(|member| member.path.as_os_str().len())
+            .sum();
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(source.directory.join("thread-0000.jsonl"))
+            .unwrap()
+            .write_all(format!("{}\n", user("appended")).as_bytes())
+            .unwrap();
+        let resolved = Arc::new(Mutex::new(Vec::new()));
+        *store.resolve_hook.lock().unwrap() = Some(Arc::new({
+            let (store, resolved) = (Arc::downgrade(&store), Arc::clone(&resolved));
+            move |path: &Path| {
+                let store = store.upgrade().unwrap();
+                let state = store.lock_state();
+                resolved.lock().unwrap().push((
+                    path.to_path_buf(),
+                    state.transient_bytes,
+                    state.warm_memberships.is_empty(),
+                ));
+            }
+        }));
+        let mut refresh = request.clone();
+        refresh.insert("deadline_unix_ms", json!(now_ms() + 120_000));
+        let reply = store.request(&refresh, &owner, &Cancellation::default());
+        *store.resolve_hook.lock().unwrap() = None;
+        assert_eq!(reply["status"].as_str(), Some("ok"), "{reply:?}");
+        let resolutions = resolved.lock().unwrap();
+        let uncached: Vec<_> = resolutions
+            .iter()
+            .filter(|(.., uncached)| *uncached)
+            .collect();
+        assert_eq!(
+            uncached.iter().map(|(path, ..)| path).collect::<Vec<_>>(),
+            warmed
+                .members
+                .iter()
+                .map(|member| &member.path)
+                .collect::<Vec<_>>()
+        );
+        assert!(!resolutions[0].2);
+        assert!(
+            uncached.last().unwrap().1 - resolutions[0].1 >= live + copied,
+            "the refresh holds copied member paths its reservation never charged"
+        );
+        assert!(Arc::ptr_eq(
+            &store
+                .lock_state()
+                .warm_memberships
+                .values()
+                .next()
+                .unwrap()
+                .positions,
+            &warmed.positions
+        ));
+        store.assert_conserved();
+    }
+
     #[test]
     fn registered_completion_rejects_an_owner_directory_replaced_between_members() {
         use std::os::unix::fs::DirBuilderExt;
@@ -17682,6 +17914,32 @@ mod tests {
         );
     }
 
+    #[test]
+    fn registered_warmer_cancelled_on_its_last_step_fails_its_final_hold() {
+        let (source, store, owner, mut request) = registered_warming(300);
+        registered_pages(&store, &owner, &request);
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(source.directory.join("thread-0255.jsonl"))
+            .unwrap()
+            .write_all(format!("{}\n", user("appended")).as_bytes())
+            .unwrap();
+        let cancel = Cancellation::default();
+        *store.built_facts_hook.lock().unwrap() = Some(Arc::new({
+            let cancel = cancel.clone();
+            move |_: &Arc<crate::snapshot_prepared::PreparedFacts>| cancel.cancel()
+        }));
+        let builds = store.fact_builds.load(Ordering::Relaxed);
+        request.insert("deadline_unix_ms", json!(now_ms() + 120_000));
+        let cancelled = store.request(&request, &owner, &cancel);
+        assert_eq!(
+            cancelled["status"].as_str(),
+            Some("cancelled"),
+            "{cancelled:?}"
+        );
+        assert_eq!(store.fact_builds.load(Ordering::Relaxed) - builds, 1);
+    }
+
     #[test]
     fn disk_facts_complete_queries_when_memory_fact_budget_is_smaller() {
         let source = Source::new(&format!("{}\n", user("root")));

{cc_transcript-14.45.9 → cc_transcript-14.45.11}/rust/crates/core/src/snapshot_prepared_service.rs

@@ -904,7 +904,7 @@ impl NativeStore {
                 return Ok(false);
             }
         }
-        dirs.hold()
+        dirs.hold(|| cancel.check(deadline))
     }
 
     fn validate_sidechain_dirs(
@@ -935,7 +935,7 @@ impl NativeStore {
                 return Ok(false);
             }
         }
-        dirs.hold()
+        dirs.hold(|| cancel.check(deadline))
     }
 
     fn prepare_graph(
@@ -1598,6 +1598,11 @@ impl NativeStore {
                 return Ok((cached, None));
             }
             self.lock_state().remove_warm_membership(key);
+            if let Some((membership, reservation)) =
+                self.refreshed_warm_membership(key, &cached, request, context, cancel, remaining)?
+            {
+                return Ok((membership, Some(reservation)));
+            }
         }
         let (membership, reservation) =
             self.build_warm_membership(key, request, context, cancel, usage, remaining)?;
@@ -1610,6 +1615,103 @@ impl NativeStore {
         Ok((membership, Some(reservation)))
     }
 
+    fn refreshed_warm_membership(
+        &self,
+        key: &str,
+        cached: &WarmMembership,
+        request: &Value,
+        context: &Value,
+        cancel: &Cancellation,
+        remaining: &WorkLimits,
+    ) -> Result<Option<(WarmMembership, ProjectionReservation<'_>)>, SnapshotError> {
+        if cached.expires <= now_ms()
+            || !self.validate_sidechain_dirs(
+                &cached.sidechain_dirs,
+                context,
+                cancel,
+                remaining.deadline_unix_ms,
+            )?
+        {
+            return Ok(None);
+        }
+        let mut reservation = self.reserve_projection(
+            context,
+            key.len()
+                + cached.accounted_bytes()
+                + cached.members.len() * size_of::<PreparedSourceRef>()
+                + source_ref_bytes(&cached.members)
+                + arc_slice_bytes::<(SourceIdentity, usize)>(cached.positions.len())
+                + sidechain_dir_bytes(&cached.sidechain_dirs),
+        )?;
+        let mut dirs = ResolvedDirs::new(self, context);
+        let mut members = Vec::with_capacity(cached.members.len());
+        for member in cached.members.iter() {
+            #[cfg(test)]
+            self.membership_metadata_checks
+                .fetch_add(1, Ordering::Relaxed);
+            cancel.check(remaining.deadline_unix_ms)?;
+            let (canonical, metadata) = match dirs.resolve(&member.path) {
+                Ok(resolved) => resolved,
+                Err(error) if error.status == Status::Missing => return Ok(None),
+                Err(error) => return Err(error),
+            };
+            self.authority(context, Some(&canonical))?;
+            let stamp = SourceStamp::of(&metadata);
+            if canonical != member.path
+                || stamp.identity != member.stamp.identity
+                || (stamp != member.stamp && stamp.size <= member.stamp.size)
+            {
+                return Ok(None);
+            }
+            self.extend_projection_reservation(&mut reservation, context, canonical.capacity())?;
+            members.push(PreparedSourceRef {
+                path: canonical,
+                stamp,
+            });
+        }
+        let since = active_since_ns(request)?;
+        if !dirs.hold(|| cancel.check(remaining.deadline_unix_ms))?
+            || members
+                .iter()
+                .filter(|member| active(member, since))
+                .count()
+                > remaining.max_sources
+        {
+            return Ok(None);
+        }
+        self.extend_projection_reservation(
+            &mut reservation,
+            context,
+            arc_slice_bytes::<PreparedSourceRef>(members.len()),
+        )?;
+        Ok(Some((
+            WarmMembership {
+                revision: Self::warm_membership_revision(&members),
+                members: members.into(),
+                positions: Arc::clone(&cached.positions),
+                sidechain_dirs: Arc::clone(&cached.sidechain_dirs),
+                complete: cached.complete,
+                expires: cached.expires,
+            },
+            reservation,
+        )))
+    }
+
+    fn warm_membership_revision(members: &[PreparedSourceRef]) -> String {
+        use std::fmt::Write as _;
+
+        let revision_len = 2 * <Sha256 as Digest>::output_size();
+        let mut digest = Sha256::new();
+        for source in members {
+            digest.update(source.path.as_os_str().as_encoded_bytes());
+            digest.update(source.stamp.revision().as_bytes());
+        }
+        let mut revision = String::with_capacity(revision_len);
+        write!(revision, "{:x}", digest.finalize()).expect("hex digest");
+        assert_eq!(revision.capacity(), revision_len);
+        revision
+    }
+
     fn build_warm_membership(
         &self,
         key: &str,
@@ -1619,8 +1721,6 @@ impl NativeStore {
         usage: &mut [u64; 20],
         remaining: &mut WorkLimits,
     ) -> Result<(WarmMembership, ProjectionReservation<'_>), SnapshotError> {
-        use std::fmt::Write as _;
-
         let ids = request["thread_ids"]
             .as_array()
             .ok_or_else(|| invalid("missing registered thread ids"))?;
@@ -1799,11 +1899,6 @@ impl NativeStore {
                 "registered source bound exhausted",
             ));
         }
-        let mut digest = Sha256::new();
-        for source in &members {
-            digest.update(source.path.as_os_str().as_encoded_bytes());
-            digest.update(source.stamp.revision().as_bytes());
-        }
         self.extend_projection_reservation(
             &mut reservation,
             context,
@@ -1811,15 +1906,12 @@ impl NativeStore {
                 + arc_slice_bytes::<(SourceIdentity, usize)>(members.len())
                 + arc_slice_bytes::<(PathBuf, Option<SourceStamp>)>(sidechain_dirs.len()),
         )?;
-        let mut revision = String::with_capacity(revision_len);
-        write!(revision, "{:x}", digest.finalize()).expect("hex digest");
-        assert_eq!(revision.capacity(), revision_len);
         Ok((
             WarmMembership {
+                revision: Self::warm_membership_revision(&members),
                 positions: member_positions(&members),
                 members: members.into(),
                 sidechain_dirs: sidechain_dirs.into(),
-                revision,
                 complete: located.len() == ids.len(),
                 expires: now_ms().saturating_add(30 * 60_000),
             },
@@ -2054,7 +2146,10 @@ impl NativeStore {
             steps += 1;
             uncached_steps += usize::from(!cached);
         }
-        if !dirs.hold()? {
+        if !dirs.hold(|| match cancel.check(remaining.deadline_unix_ms) {
+            Err(error) if error.status == Status::Deadline => Ok(()),
+            checked => checked,
+        })? {
             return Err(SnapshotError::new(
                 Status::Changed,
                 "registered source changed",
@@ -2161,7 +2256,7 @@ impl NativeStore {
         let page = self
             .prepared_query_steps(&mut cursor, &mut dirs, context, reservation, cancel, usage)
             .and_then(|page| {
-                if dirs.hold()? {
+                if dirs.hold(|| cancel.check(cursor.remaining.deadline_unix_ms))? {
                     Ok(page)
                 } else {
                     Err(SnapshotError::new(
@@ -2983,8 +3078,10 @@ impl<'a> ResolvedDirs<'a> {
         Ok(canonical)
     }
 
-    fn hold(&self) -> Result<bool, SnapshotError> {
+    fn hold(&self, check: impl Fn() -> Result<(), SnapshotError>) -> Result<bool, SnapshotError> {
+        check()?;
         for (directory, canonical) in &self.dirs {
+            check()?;
             match self.store.canonical_path(directory) {
                 Ok(current) if current == *canonical => {}
                 Ok(_) => return Ok(false),
@@ -2992,6 +3089,7 @@ impl<'a> ResolvedDirs<'a> {
                 Err(error) => return Err(io_error(error)),
             }
         }
+        check()?;
         Ok(true)
     }
 }