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

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

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

{cc_transcript-14.45.12 → cc_transcript-14.45.13}/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.13" # 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.13}/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),
         })
     }
 
@@ -8764,6 +8795,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 +8810,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 +8818,7 @@ impl NativeStore {
         )?;
         #[cfg(test)]
         self.graph_records.fetch_add(1, Ordering::Relaxed);
-        let RenewedScope {
+        let LeasedScope {
             snapshot: root,
             classifier,
             expires,
@@ -9097,7 +9134,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 +9575,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 +9706,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"));
@@ -16144,6 +16178,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!(

{cc_transcript-14.45.12 → cc_transcript-14.45.13}/rust/crates/core/src/snapshot_activity.rs

@@ -4,6 +4,7 @@ use std::ops::Range;
 use std::sync::Arc;
 
 use crate::activity::{lift_session_index_tail, lower_edit, Hunk, LiftedSession, ToolUse, Turn};
+use crate::parse::pushed_capacity;
 #[cfg(test)]
 use crate::snapshot::NativeStore;
 #[cfg(test)]
@@ -53,12 +54,77 @@ pub(crate) struct ResultPosition {
     charge: MemoryCharge,
 }
 
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub(crate) struct ActivityShape {
+    pub calls: usize,
+    pub call_name_bytes: usize,
+    pub paths: usize,
+    pub path_bytes: usize,
+    pub edits: usize,
+    pub edit_path_bytes: usize,
+    pub commands: usize,
+    pub command_bytes: usize,
+    pub skills: usize,
+    pub skill_bytes: usize,
+    pub prose_bytes: usize,
+    pub tool_name_slots: usize,
+    pub tool_name_bytes: usize,
+}
+
+impl ActivityShape {
+    fn include_entry(&mut self, entry: &Entry) {
+        match entry {
+            Entry::User(user) => {
+                self.prose_bytes += user.content.text_len()
+                    + user
+                        .tool_results()
+                        .map(|result| result.content.len())
+                        .sum::<usize>();
+            }
+            Entry::Assistant(assistant) => {
+                self.prose_bytes += crate::types::joined_text_len(&assistant.blocks);
+                self.tool_name_slots += pushed_capacity(entry.tool_uses().count());
+                self.tool_name_bytes +=
+                    entry.tool_uses().map(|tool| tool.name.len()).sum::<usize>();
+            }
+            Entry::System(system) => {
+                self.prose_bytes += system.content.as_ref().map_or(0, String::len);
+            }
+            _ => {}
+        }
+    }
+
+    fn include_call(&mut self, call: &ToolCall, edits: &[(String, Vec<Hunk>)]) {
+        let paths = call.file_paths();
+        self.calls += 1;
+        self.call_name_bytes += call.name().len();
+        self.paths += paths.len();
+        self.path_bytes += paths.iter().map(|path| path.len()).sum::<usize>();
+        self.edits += edits.len();
+        self.edit_path_bytes += edits.iter().map(|(path, _)| path.len()).sum::<usize>();
+        match call {
+            ToolCall::Bash(bash) => {
+                self.commands += 1;
+                self.command_bytes += bash.command.len();
+            }
+            ToolCall::Skill(skill) => {
+                self.skills += 1;
+                self.skill_bytes += skill.skill.len();
+            }
+            _ => {}
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct ActivityIndex {
     entries: usize,
     turns: Arc<Vec<Arc<CachedTurn>>>,
     uuids: Arc<HashMap<String, usize>>,
     results: Arc<HashMap<String, ResultPosition>>,
+    shape: ActivityShape,
+    started_unix_ms: Option<i64>,
+    last_model_event: Option<usize>,
     work: ActivityWork,
 }
 
@@ -101,8 +167,12 @@ impl ActivityIndex {
             ..ActivityWork::default()
         };
         for (local, entry) in entries.iter().enumerate() {
+            next.shape.include_entry(entry);
             let event = first_new_index + local;
             if let Some(meta) = entry.meta() {
+                if next.started_unix_ms.is_none() {
+                    next.started_unix_ms = Some(meta.timestamp.timestamp_millis());
+                }
                 if !next.uuids.contains_key(&meta.uuid) {
                     if Arc::strong_count(&next.uuids) > 1 {
                         next.work.copied_index_entries += next.uuids.len();
@@ -110,6 +180,10 @@ impl ActivityIndex {
                     Arc::make_mut(&mut next.uuids).insert(meta.uuid.clone(), event);
                 }
             }
+            if matches!(entry, Entry::Assistant(assistant) if assistant.model != crate::types::SYNTHETIC_MODEL)
+            {
+                next.last_model_event = Some(event);
+            }
             if let Entry::User(user) = entry {
                 for (ordinal, block) in user.blocks().iter().enumerate() {
                     let ContentBlock::ToolResult(result) = block else {
@@ -149,6 +223,7 @@ impl ActivityIndex {
                     };
                     let call = parse_tool_call(&tool.name, &tool.input);
                     let edits = lower_edit(&call);
+                    next.shape.include_call(&call, &edits);
                     let id = tool.id.clone();
                     let accounted_bytes = size_of::<CachedCall>()
                         + id.capacity()
@@ -204,6 +279,18 @@ impl ActivityIndex {
         self.entries
     }
 
+    pub(crate) fn shape(&self) -> ActivityShape {
+        self.shape
+    }
+
+    pub(crate) fn started_unix_ms(&self) -> Option<i64> {
+        self.started_unix_ms
+    }
+
+    pub(crate) fn last_model_event(&self) -> Option<usize> {
+        self.last_model_event
+    }
+
     pub fn turn_count(&self) -> usize {
         self.turns.len()
     }
@@ -436,6 +523,9 @@ impl ActivityIndex {
             turns,
             uuids,
             results,
+            shape: _,
+            started_unix_ms: _,
+            last_model_event: _,
             work: _,
         } = self;
         let mut allocations = vec![
@@ -1084,11 +1174,14 @@ mod tests {
     #[test]
     fn every_append_boundary_matches_full_lift() {
         let entries = [
+            entry(r#"{"type":"mode","sessionId":"s","mode":"plan"}"#),
             tools(),
             user("u", "first"),
             tools(),
             user("v", "second"),
             results(),
+            entry(&sonic_rs::json!({"type":"assistant","uuid":"synthetic","sessionId":"s","timestamp":"2026-01-02T03:04:08Z","message":{"model":crate::types::SYNTHETIC_MODEL,"content":[{"type":"text","text":"synthetic"}]}}).to_string()),
+            user("tail", "trailing prose"),
         ];
         let refs: Vec<_> = entries.iter().collect();
         for boundary in 0..=refs.len() {
@@ -1096,9 +1189,69 @@ mod tests {
             let next = prior.append(&refs, boundary, None);
             parity(&next, &refs, None);
             parity(&prior, &refs[..boundary], None);
+            assert_eq!(next.shape(), ActivityIndex::new(&refs, None).shape());
+            assert_eq!(
+                next.started_unix_ms(),
+                refs.iter()
+                    .find_map(|entry| entry.meta())
+                    .map(|meta| meta.timestamp.timestamp_millis())
+            );
+            assert_eq!(
+                next.last_model_event(),
+                refs.iter().rposition(|entry| matches!(entry, Entry::Assistant(assistant) if assistant.model != crate::types::SYNTHETIC_MODEL))
+            );
+            assert_eq!(
+                prior.started_unix_ms(),
+                refs[..boundary]
+                    .iter()
+                    .find_map(|entry| entry.meta())
+                    .map(|meta| meta.timestamp.timestamp_millis())
+            );
+            assert_eq!(
+                prior.last_model_event(),
+                refs[..boundary].iter().rposition(|entry| matches!(entry, Entry::Assistant(assistant) if assistant.model != crate::types::SYNTHETIC_MODEL))
+            );
+            assert_eq!(
+                prior.shape(),
+                ActivityIndex::new(&refs[..boundary], None).shape()
+            );
         }
     }
 
+    #[test]
+    fn metadata_is_local_to_each_window_and_immutable_prefix() {
+        let entries = [
+            sonic_rs::json!({"type":"user","uuid":"outside","sessionId":"s","timestamp":"2026-01-02T03:04:01Z","message":{"content":"outside"}}),
+            sonic_rs::json!({"type":"assistant","uuid":"before","sessionId":"s","timestamp":"2026-01-02T03:04:02Z","message":{"model":"before","content":[]}}),
+            sonic_rs::json!({"type":"mode","sessionId":"s","mode":"plan"}),
+            sonic_rs::json!({"type":"user","uuid":"inside","sessionId":"s","timestamp":"2026-01-02T03:04:08Z","message":{"content":"inside"}}),
+            sonic_rs::json!({"type":"assistant","uuid":"model","sessionId":"s","timestamp":"2026-01-02T03:04:09Z","message":{"model":"inside","content":[]}}),
+            sonic_rs::json!({"type":"user","uuid":"tail","sessionId":"s","timestamp":"2026-01-02T03:04:10Z","message":{"content":"tail"}}),
+            sonic_rs::json!({"type":"assistant","uuid":"after","sessionId":"s","timestamp":"2026-01-02T03:04:11Z","message":{"model":"after","content":[]}}),
+        ].map(|value| entry(&value.to_string()));
+        let refs: Vec<_> = entries.iter().collect();
+        let global = ActivityIndex::new(&refs, None);
+        for range in [0..5, 2..6, 3..6, 2..4] {
+            let window = &refs[range.clone()];
+            let first = window
+                .iter()
+                .find_map(|entry| entry.meta())
+                .map(|meta| meta.timestamp.timestamp_millis());
+            let model = window.iter().rposition(|entry| matches!(entry, Entry::Assistant(assistant) if assistant.model != crate::types::SYNTHETIC_MODEL));
+            for boundary in 0..=window.len() {
+                let prior = ActivityIndex::new(&window[..boundary], None);
+                let next = prior.append(window, boundary, None);
+                assert_eq!(next.started_unix_ms(), first, "{range:?} {boundary}");
+                assert_eq!(next.last_model_event(), model, "{range:?} {boundary}");
+                assert_eq!(prior.last_model_event(), window[..boundary].iter().rposition(|entry| matches!(entry, Entry::Assistant(assistant) if assistant.model != crate::types::SYNTHETIC_MODEL)));
+            }
+        }
+        let window = ActivityIndex::new(&refs[2..6], None);
+        assert_ne!(window.started_unix_ms(), global.started_unix_ms());
+        assert_eq!(window.last_model_event(), Some(2));
+        assert_eq!(global.last_model_event(), Some(6));
+    }
+
     #[test]
     fn custom_classifier_and_empty_append_preserve_semantics() {
         let entries = [user("u", "first"), tools(), user("v", "second"), results()];
@@ -1109,6 +1262,13 @@ mod tests {
         parity(&next, &refs, Some(&flags));
         let unchanged = next.append(&refs, refs.len(), Some(&flags));
         assert_eq!(unchanged.work(), ActivityWork::default());
+        assert_eq!(unchanged.shape(), next.shape());
+        assert_eq!(unchanged.started_unix_ms(), next.started_unix_ms());
+        assert_eq!(unchanged.last_model_event(), next.last_model_event());
+        assert_eq!(
+            next.shape(),
+            ActivityIndex::new(&refs, Some(&flags)).shape()
+        );
         assert!(Arc::ptr_eq(&next.turns[0], &unchanged.turns[0]));
         assert!(Arc::ptr_eq(&next.uuids, &unchanged.uuids));
         assert!(Arc::ptr_eq(&next.results, &unchanged.results));