cc-transcript 14.45.12__tar.gz → 14.45.14__tar.gz

{cc_transcript-14.45.12 → cc_transcript-14.45.14}/PKG-INFO

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

{cc_transcript-14.45.12 → cc_transcript-14.45.14}/pyproject.toml

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

@@ -32,7 +32,9 @@ use crate::snapshot_memory::{
 use crate::snapshot_prepared::FactsNeed;
 use crate::snapshot_prepared_disk::PreparedDiskKey;
 use crate::snapshot_projection::JSON_LITERAL_OBJECT_CAPACITY;
-use crate::types::{Entry, SYNTHETIC_MODEL};
+use crate::types::Entry;
+#[cfg(test)]
+use crate::types::SYNTHETIC_MODEL;
 
 pub const SCHEMA: &str = "cc-transcript.snapshot/1";
 pub const PARSER_VERSION: &str = "cc-transcript.snapshot/1";
@@ -375,23 +377,15 @@ impl TranscriptSnapshot {
         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())
+        self.activity.started_unix_ms()
     }
 
     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,
+        self.activity
+            .last_model_event()
+            .map(|position| match self.entry(position) {
+                Entry::Assistant(assistant) => assistant.model.as_str(),
+                _ => unreachable!("indexed model is an assistant event"),
             })
     }
 
@@ -533,11 +527,10 @@ struct Lease {
     registry: Arc<crate::toolcall::ToolRegistrySnapshot>,
 }
 
-struct RenewedScope {
+struct LeasedScope {
     snapshot: Arc<TranscriptSnapshot>,
     classifier: Value,
     expires: u64,
-    description_bytes: usize,
 }
 
 // Sized exactly like an acquire reply's re-serialized copy, whose bytes admit graph members.
@@ -2889,6 +2882,8 @@ pub struct NativeStore {
     #[cfg(test)]
     pub(crate) fact_builds: AtomicUsize,
     #[cfg(test)]
+    pub(crate) description_builds: AtomicUsize,
+    #[cfg(test)]
     pub(crate) fact_lookups: AtomicUsize,
     #[cfg(test)]
     pub(crate) fact_read_waits: AtomicUsize,
@@ -3372,6 +3367,8 @@ impl NativeStore {
             #[cfg(test)]
             fact_builds: AtomicUsize::new(0),
             #[cfg(test)]
+            description_builds: AtomicUsize::new(0),
+            #[cfg(test)]
             fact_lookups: AtomicUsize::new(0),
             #[cfg(test)]
             fact_read_waits: AtomicUsize::new(0),
@@ -3520,7 +3517,7 @@ impl NativeStore {
         deadline: u64,
     ) -> Result<u64, SnapshotError> {
         for handle in handles {
-            self.pin_scope(handle, context)?;
+            self.pin_record(handle, context)?;
         }
         let state = self.lock_state();
         let mut expires = (now_ms() + self.config.ttl).min(deadline);
@@ -3955,11 +3952,9 @@ impl NativeStore {
         mut bounds: WorkLimits,
     ) -> Result<Value, SnapshotError> {
         cancel.check(bounds.deadline_unix_ms)?;
-        let (source, description) =
-            self.pin_scope_for_work(handle, context, bounds.deadline_unix_ms)?;
-        bounds.deadline_unix_ms = bounds
-            .deadline_unix_ms
-            .min(number(&description, "lease_expires_unix_ms")? as u64);
+        let scope = self.renew_scope_for_work(handle, context, bounds.deadline_unix_ms)?;
+        let source = scope.snapshot;
+        bounds.deadline_unix_ms = bounds.deadline_unix_ms.min(scope.expires);
         bounds.deadline_unix_ms = bounds
             .deadline_unix_ms
             .min(now_ms() + self.config.preparation);
@@ -4983,6 +4978,29 @@ impl NativeStore {
 
     #[cfg(test)]
     fn audit_snapshot_allocations(snapshot: &Arc<TranscriptSnapshot>) -> Vec<(usize, usize)> {
+        let started = if snapshot.window_start == 0 {
+            None
+        } else {
+            snapshot
+                .chunks
+                .iter()
+                .flat_map(|chunk| chunk.entries.iter())
+                .find_map(Entry::meta)
+                .map(|meta| meta.timestamp.timestamp_millis())
+        };
+        assert_eq!(snapshot.window_started_unix_ms(), started);
+        let model = snapshot
+            .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,
+            });
+        assert_eq!(snapshot.model(), model);
         let TranscriptSnapshot {
             ledger: _,
             id,
@@ -5863,6 +5881,8 @@ impl NativeStore {
         lease: &str,
         expires: u64,
     ) -> Value {
+        #[cfg(test)]
+        self.description_builds.fetch_add(1, Ordering::Relaxed);
         json!({"handle": LeaseHandle {owner_epoch: &self.owner_epoch, snapshot_id: &snapshot.id, generation: &snapshot.id, lease_id: lease},
             "canonical_path": snapshot.canonical_path.to_string_lossy().as_ref(),
             "source_id": format!("{}:{}", snapshot.stamp.identity.device, snapshot.stamp.identity.inode),
@@ -5879,8 +5899,7 @@ impl NativeStore {
         handle: &Value,
         context: &Value,
     ) -> Result<Arc<TranscriptSnapshot>, SnapshotError> {
-        self.pin_scope(handle, context)
-            .map(|(snapshot, _)| snapshot)
+        self.pin_record(handle, context).map(|scope| scope.snapshot)
     }
 
     pub fn validate_scope(&self, handle: &Value, context: &Value) -> Result<(), SnapshotError> {
@@ -5893,23 +5912,36 @@ impl NativeStore {
         handle: &Value,
         context: &Value,
     ) -> Result<(Arc<TranscriptSnapshot>, Value), SnapshotError> {
+        let scope = self.capture_scope(handle, context)?;
+        let description = self.description(
+            &scope.snapshot,
+            &scope.classifier,
+            str_field(handle, "lease_id")?,
+            scope.expires,
+        );
+        self.authority(context, Some(&scope.snapshot.canonical_path))?;
+        Ok((scope.snapshot, description))
+    }
+
+    fn pin_record(&self, handle: &Value, context: &Value) -> Result<LeasedScope, SnapshotError> {
+        let scope = self.capture_scope(handle, context)?;
+        self.authority(context, Some(&scope.snapshot.canonical_path))?;
+        Ok(scope)
+    }
+
+    fn capture_scope(&self, handle: &Value, context: &Value) -> Result<LeasedScope, SnapshotError> {
         self.authority(context, None)?;
-        let (snapshot, description) = {
+        let scope = {
             let mut state = self.lock_state();
             Self::prune(&mut state);
             let lease = self.lease(&state, handle, context)?;
-            (
-                Arc::clone(&lease.snapshot),
-                self.description(
-                    &lease.snapshot,
-                    &lease.classifier,
-                    str_field(handle, "lease_id")?,
-                    lease.expires,
-                ),
-            )
+            LeasedScope {
+                snapshot: Arc::clone(&lease.snapshot),
+                classifier: lease.classifier.clone(),
+                expires: lease.expires,
+            }
         };
-        self.authority(context, Some(&snapshot.canonical_path))?;
-        Ok((snapshot, description))
+        Ok(scope)
     }
 
     pub fn pin_scope_for_work(
@@ -5933,7 +5965,7 @@ impl NativeStore {
         handle: &Value,
         context: &Value,
         deadline: u64,
-    ) -> Result<RenewedScope, SnapshotError> {
+    ) -> Result<LeasedScope, SnapshotError> {
         #[cfg(test)]
         {
             let hook = self.pin_hook.lock().expect("pin hook").clone();
@@ -5950,7 +5982,7 @@ impl NativeStore {
                 "borrow deadline expired",
             ));
         }
-        let (snapshot, probe) = self.pin_scope(handle, context)?;
+        let scope = self.pin_record(handle, context)?;
         let mut state = self.lock_state();
         let lease = self.lease(&state, handle, context)?;
         let expires = lease.expires.max(deadline.min(lease.absolute_deadline));
@@ -5960,11 +5992,10 @@ impl NativeStore {
             .get_mut(str_field(handle, "lease_id")?)
             .expect("validated lease")
             .expires = expires;
-        Ok(RenewedScope {
-            snapshot,
+        Ok(LeasedScope {
+            snapshot: scope.snapshot,
             classifier,
             expires,
-            description_bytes: value_bytes(&probe),
         })
     }
 
@@ -7112,6 +7143,7 @@ impl NativeStore {
         let mut lines: Vec<(u64, Vec<Entry>)> = Vec::new();
         let mut events = 0usize;
         let mut exhausted = false;
+        let mut read_step = self.config.read_step.min(64 * 1024);
         loop {
             while events < count {
                 cancel.check(limits.deadline_unix_ms)?;
@@ -7134,11 +7166,7 @@ impl NativeStore {
                 }
                 break;
             }
-            let step = self
-                .config
-                .read_step
-                .min(budget - read)
-                .min(pending_start as usize);
+            let step = read_step.min(budget - read).min(pending_start as usize);
             if step == 0 {
                 exhausted = true;
                 break;
@@ -7152,6 +7180,7 @@ impl NativeStore {
             file.read_exact(&mut block).map_err(io_error)?;
             usage[1] += step as u64;
             read += step;
+            read_step = read_step.saturating_mul(2).min(self.config.read_step);
             block.extend_from_slice(&pending);
             pending = block;
             pending_start -= step as u64;
@@ -8764,6 +8793,12 @@ impl NativeStore {
         let claimant = str_field(context, "claimant")?;
         let lease_id = str_field(root_handle, "lease_id")?;
         let root_path = scope.snapshot.canonical_path.as_os_str().len();
+        let description_bytes = value_bytes(&self.description(
+            &scope.snapshot,
+            &scope.classifier,
+            lease_id,
+            scope.expires,
+        ));
         let mut reservation = self.reserve_projection(
             context,
             size_of::<GraphCursor>()
@@ -8773,7 +8808,7 @@ impl NativeStore {
                 + value_bytes(root_handle)
                 + size_of::<GraphNode>()
                 + root_path
-                + scope.description_bytes
+                + description_bytes
                 + set_growth(&HashSet::<SourceIdentity>::new(), 1)
                 + task_count * size_of::<GraphTask>()
                 + attachment_bytes
@@ -8781,7 +8816,7 @@ impl NativeStore {
         )?;
         #[cfg(test)]
         self.graph_records.fetch_add(1, Ordering::Relaxed);
-        let RenewedScope {
+        let LeasedScope {
             snapshot: root,
             classifier,
             expires,
@@ -9097,7 +9132,7 @@ impl NativeStore {
         usage: &mut [u64; 20],
     ) -> Result<GraphYield, SnapshotError> {
         cancel.check(graph.remaining.deadline_unix_ms)?;
-        self.pin_scope_for_work(
+        self.renew_scope_for_work(
             &graph.root_handle,
             &graph.context,
             graph.remaining.deadline_unix_ms,
@@ -9538,12 +9573,10 @@ impl NativeStore {
         let handle = view
             .get("handle")
             .ok_or_else(|| invalid("missing view handle"))?;
-        let (snapshot, description) =
-            self.pin_scope_for_work(handle, context, bound.deadline_unix_ms)?;
-        bound.deadline_unix_ms = bound
-            .deadline_unix_ms
-            .min(number(&description, "lease_expires_unix_ms")? as u64);
-        if !classifier_eq(&view["classifier"], &description["classifier"])? {
+        let scope = self.renew_scope_for_work(handle, context, bound.deadline_unix_ms)?;
+        let snapshot = scope.snapshot;
+        bound.deadline_unix_ms = bound.deadline_unix_ms.min(scope.expires);
+        if !classifier_eq(&view["classifier"], &scope.classifier)? {
             return Err(invalid("view classifier differs from leased generation"));
         }
         let mut page = bound;
@@ -9671,16 +9704,15 @@ impl NativeStore {
             .ok_or_else(|| invalid("missing windows_json"))?;
         let mut sessions = HashMap::new();
         for handle in handles.iter() {
-            let (snapshot, description) = self.pin_scope_for_work(
+            let scope = self.renew_scope_for_work(
                 handle
                     .get("handle")
                     .ok_or_else(|| invalid("missing handle"))?,
                 context,
                 bound.deadline_unix_ms,
             )?;
-            bound.deadline_unix_ms = bound
-                .deadline_unix_ms
-                .min(number(&description, "lease_expires_unix_ms")? as u64);
+            let snapshot = scope.snapshot;
+            bound.deadline_unix_ms = bound.deadline_unix_ms.min(scope.expires);
             let session = str_field(handle, "session_id")?;
             if session != snapshot.session_id {
                 return Err(invalid("hydration session differs from handle"));
@@ -12169,6 +12201,192 @@ mod tests {
             .collect()
     }
 
+    fn tail_with_small_step_reference(source: &Source, count: usize, budget: usize) -> Value {
+        let owner = context("a");
+        let request = tail_request(&source.path, count, budget);
+        let store = NativeStore::new(&json!({})).unwrap();
+        let response = store.request(&request, &owner, &Cancellation::default());
+        let reference = NativeStore::new(&json!({"max_read_bytes_per_step":4096})).unwrap();
+        let reference = reference.request(&request, &owner, &Cancellation::default());
+        assert_eq!(response["status"], reference["status"], "{response:?}");
+        assert_eq!(response["reason"], reference["reason"], "{response:?}");
+        assert_eq!(response["data"], reference["data"], "{response:?}");
+        response
+    }
+
+    #[test]
+    fn tail_default_steps_read_only_the_newest_event_window() {
+        let suffix = (0..256)
+            .map(|index| format!("{}\n", user_text(&index.to_string(), &"x".repeat(1400))))
+            .collect::<String>();
+        assert!((256 * 1024..448 * 1024).contains(&suffix.len()));
+        let prefix = format!("{}\n", " ".repeat(8 * 1024 * 1024));
+        let source = Source::new(&format!("{prefix}{suffix}"));
+        let response = tail_with_small_step_reference(&source, 256, 8 * 1024 * 1024);
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(
+            tail_uuids(&response),
+            (0..256).map(|index| index.to_string()).collect::<Vec<_>>()
+        );
+        assert_eq!(
+            response["data"]["source_bytes"].as_u64(),
+            Some((prefix.len() + suffix.len()) as u64)
+        );
+        assert_eq!(
+            response["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+        let read = response["usage"]["source_bytes_read"].as_u64().unwrap();
+        assert!(read >= suffix.len() as u64 && read <= 512 * 1024, "{read}");
+    }
+
+    #[test]
+    fn tail_grows_reads_for_a_long_partial_line() {
+        fn count_reads(store: &Arc<NativeStore>, reads: &Arc<AtomicUsize>) {
+            let next = Arc::downgrade(store);
+            let reads = Arc::clone(reads);
+            *store.read_hook.lock().unwrap() = Some(Arc::new(move || {
+                reads.fetch_add(1, Ordering::Relaxed);
+                count_reads(&next.upgrade().unwrap(), &reads);
+            }));
+        }
+
+        let prefix = format!("{}\n", " ".repeat(8 * 1024 * 1024));
+        let suffix = format!("{}\n", user_text("large", &"x".repeat(512 * 1024)));
+        let source = Source::new(&format!("{prefix}{suffix}"));
+        let owner = context("a");
+        let request = tail_request(&source.path, 1, 8 * 1024 * 1024);
+        let store = Arc::new(NativeStore::new(&json!({})).unwrap());
+        let reads = Arc::new(AtomicUsize::new(0));
+        count_reads(&store, &reads);
+        let response = store.request(&request, &owner, &Cancellation::default());
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(tail_uuids(&response), ["large"]);
+        assert_eq!(
+            response["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+        assert!(response["usage"]["source_bytes_read"].as_u64().unwrap() <= 1024 * 1024);
+        assert!(reads.load(Ordering::Relaxed) <= 4);
+        let bounded = NativeStore::new(&json!({"max_entry_bytes":256*1024})).unwrap();
+        let refused = bounded.request(&request, &owner, &Cancellation::default());
+        assert_eq!(
+            refused["status"].as_str(),
+            Some("entry_limit"),
+            "{refused:?}"
+        );
+    }
+
+    #[test]
+    fn tail_preserves_utf8_across_growing_read_boundaries() {
+        let mut split_scalars = 0;
+        for ending in ["", "\n"] {
+            let contents = format!(
+                "{}\n{}{ending}",
+                user("old"),
+                user_text("unicode", &"é".repeat(128 * 1024))
+            );
+            let boundary = contents.len() - 64 * 1024;
+            split_scalars += usize::from(contents.as_bytes()[boundary] & 0xc0 == 0x80);
+            let source = Source::new(&contents);
+            let response = tail_with_small_step_reference(&source, 1, 1024 * 1024);
+            assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+            assert_eq!(tail_uuids(&response), ["unicode"]);
+            assert_eq!(
+                response["data"]["window_start_byte"].as_u64(),
+                Some((user("old").len() + 1) as u64)
+            );
+        }
+        assert_eq!(split_scalars, 1);
+    }
+
+    #[test]
+    fn tail_read_budget_requires_the_oldest_line_delimiter() {
+        let prefix = format!("{}\n", user("old"));
+        let first = format!("{}\n", user_text("a", &"x".repeat(128 * 1024)));
+        let last = format!("{}\n", user_text("b", &"x".repeat(128 * 1024)));
+        let source = Source::new(&format!("{prefix}{first}{last}"));
+        let budget = first.len() + last.len();
+        let incomplete = tail_with_small_step_reference(&source, 2, budget);
+        assert_eq!(
+            incomplete["status"].as_str(),
+            Some("incomplete"),
+            "{incomplete:?}"
+        );
+        assert_eq!(
+            incomplete["reason"].as_str(),
+            Some("tail read budget exhausted")
+        );
+        assert!(incomplete["cursor"].is_null());
+        assert_eq!(tail_uuids(&incomplete), ["b"]);
+        assert_eq!(
+            incomplete["data"]["window_start_byte"].as_u64(),
+            Some((prefix.len() + first.len()) as u64)
+        );
+        let complete = tail_with_small_step_reference(&source, 2, budget + 1);
+        assert_eq!(complete["status"].as_str(), Some("ok"), "{complete:?}");
+        assert_eq!(tail_uuids(&complete), ["a", "b"]);
+        assert_eq!(
+            complete["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+    }
+
+    #[test]
+    fn tail_counts_metadata_events_and_skips_non_events_across_steps() {
+        let source = Source::new(&format!(
+            "{}\n{}\nnot json\n[]\nnull\n42\n{{\"type\":\"queue-operation\",\"operation\":\"enqueue\"}}\n{}\n",
+            user("a"),
+            " ".repeat(96 * 1024),
+            user_text("b", &"x".repeat(128 * 1024)),
+        ));
+        let response = tail_with_small_step_reference(&source, 3, 1024 * 1024);
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        let records = response["data"]["records_json"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|record| record.as_str().unwrap().to_owned())
+            .collect::<Vec<_>>();
+        let records = crate::snapshot_codec::decode_events(&records, 1024 * 1024).unwrap();
+        assert_eq!(records.len(), 3);
+        assert_eq!(records[0].event.meta().unwrap().uuid, "a");
+        assert!(matches!(&records[1].event, Entry::Other(other) if other.ty == "queue-operation"));
+        assert_eq!(records[2].event.meta().unwrap().uuid, "b");
+        assert_eq!(response["data"]["window_start_byte"].as_u64(), Some(0));
+    }
+
+    #[test]
+    fn tail_preserves_the_pinned_source_while_reads_grow() {
+        let prefix = format!("{}\n", user("old"));
+        let suffix = format!("{}\n", user_text("new", &"x".repeat(256 * 1024)));
+        let source = Source::new(&format!("{prefix}{suffix}"));
+        let path = source.path.clone();
+        let store = NativeStore::new(&json!({})).unwrap();
+        *store.read_hook.lock().unwrap() = Some(Arc::new(move || {
+            std::fs::OpenOptions::new()
+                .append(true)
+                .open(&path)
+                .unwrap()
+                .write_all(format!("{}\n", user("appended")).as_bytes())
+                .unwrap();
+        }));
+        let response = store.request(
+            &tail_request(&source.path, 1, 1024 * 1024),
+            &context("a"),
+            &Cancellation::default(),
+        );
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(tail_uuids(&response), ["new"]);
+        assert_eq!(
+            response["data"]["source_bytes"].as_u64(),
+            Some((prefix.len() + suffix.len()) as u64)
+        );
+        assert_eq!(
+            response["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+    }
     #[test]
     fn tail_returns_the_newest_events_reading_backwards_in_bounded_steps() {
         let source = Source::new(&users(0..50));
@@ -16144,6 +16362,77 @@ mod tests {
         store.assert_conserved();
     }
 
+    #[test]
+    fn repeated_root_predicates_keep_scope_metadata_typed() {
+        let skill = json!({"type":"assistant","uuid":"skill","sessionId":"s","timestamp":"2026-01-02T03:04:06Z","message":{"model":"m","content":[{"type":"tool_use","id":"skill","name":"Skill","input":{"skill":"skill-4"}}]}});
+        let source = Source::new(&format!("{}\n{skill}\n", user_text("prompt", "ready")));
+        let store = fact_budget_store(16 * 1024 * 1024);
+        let owner = context("a");
+        let template = acquire(&source.path);
+        let root = finish(
+            &store,
+            store.request(&template, &owner, &Cancellation::default()),
+            &owner,
+        );
+        let graph = finish(
+            &store,
+            store.request(&json!({"schema":SCHEMA,"id":"prepare","operation":"prepare_graph","view":{"handle":handle(&root),"classifier":{"id":"native","version":"1"},"selectors":[],"attachments":[]},"thread_ids":[],"roots":[],"direct_paths":[],"deadline_unix_ms":template["deadline_unix_ms"],"limits":template["limits"]}), &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(graph["status"].as_str(), Some("ok"), "{graph:?}");
+        let before = store.description_builds.load(Ordering::Relaxed);
+        for index in 0..24 {
+            let request = prepared_graph_request(
+                &graph,
+                &template,
+                json!([]),
+                json!({"kind":"has_skill","values":[format!("skill-{index}")],"subagents":true}),
+                None,
+            );
+            let answer = single_step(store.request(&request, &owner, &Cancellation::default()));
+            assert_eq!(value_of(&answer), Some(index == 4), "{answer:?}");
+        }
+        assert_eq!(store.description_builds.load(Ordering::Relaxed), before);
+        let (_, description) = store
+            .pin_scope_for_work(
+                &handle(&root),
+                &owner,
+                template["deadline_unix_ms"].as_u64().unwrap(),
+            )
+            .unwrap();
+        assert_eq!(store.description_builds.load(Ordering::Relaxed), before + 1);
+        assert_eq!(
+            description["classifier"],
+            json!({"id":"native","version":"1"})
+        );
+        assert_eq!(description["model"].as_str(), Some("m"));
+        assert_eq!(
+            description["canonical_path"].as_str(),
+            std::fs::canonicalize(&source.path).unwrap().to_str()
+        );
+        let later = json!({"type":"assistant","uuid":"later","sessionId":"s","timestamp":"2026-01-02T03:04:07Z","message":{"model":"later","content":[]}});
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&source.path)
+            .unwrap()
+            .write_all(format!("{later}\n").as_bytes())
+            .unwrap();
+        let newer = finish(
+            &store,
+            store.request(&acquire(&source.path), &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(
+            store.pin(&handle(&root), &owner).unwrap().model(),
+            Some("m")
+        );
+        assert_eq!(
+            store.pin(&handle(&newer), &owner).unwrap().model(),
+            Some("later")
+        );
+        store.assert_conserved();
+    }
+
     #[test]
     fn selected_root_slices_answer_has_override_within_their_view() {
         let source = Source::new(&format!(