cc-transcript 14.32.1__tar.gz → 14.33.1__tar.gz

{cc_transcript-14.32.1 → cc_transcript-14.33.1}/PKG-INFO

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

{cc_transcript-14.32.1 → cc_transcript-14.33.1}/cc_transcript/snapshot_schema/request.schema.json

@@ -2006,6 +2006,10 @@
           "title": "Origin",
           "type": "string"
         },
+        "thinking": {
+          "title": "Thinking",
+          "type": "boolean"
+        },
         "window": {
           "anyOf": [
             {
@@ -2024,7 +2028,8 @@
       "required": [
         "kind",
         "window",
-        "origin"
+        "origin",
+        "thinking"
       ],
       "title": "SignalTexts",
       "type": "object"

{cc_transcript-14.32.1 → cc_transcript-14.33.1}/pyproject.toml

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

@@ -1325,14 +1325,24 @@ impl NativeStore {
         context: &Value,
     ) -> Result<String, SnapshotError> {
         self.authority(context, None)?;
+        let definitions =
+            crate::toolcall::ToolRegistrySnapshot::specs_from_json(specs).map_err(invalid)?;
+        let fingerprint = crate::toolcall::ToolRegistrySnapshot::fingerprint_of(&definitions);
+        if self
+            .state
+            .lock()
+            .expect("snapshot state")
+            .registries
+            .contains_key(&fingerprint)
+        {
+            return Ok(fingerprint);
+        }
         let charge = crate::snapshot_memory::value_charge(specs);
         let reserve = (charge.owned_capacity_bytes + charge.opaque_dom_accounted_bytes)
             .saturating_mul(4)
             .saturating_add(64 * 1024);
         let mut reservation = self.reserve_projection(context, reserve)?;
-        let registry =
-            crate::toolcall::ToolRegistrySnapshot::from_specs_json(specs).map_err(invalid)?;
-        let fingerprint = registry.fingerprint().to_owned();
+        let registry = crate::toolcall::ToolRegistrySnapshot::from_specs(definitions);
         let allocations = registry.accounted_allocations();
         let bytes = allocations.iter().map(|(_, bytes)| *bytes).sum::<usize>()
             + allocations.capacity() * size_of::<(usize, usize)>()
@@ -11384,4 +11394,49 @@ mod tests {
         ));
         assert_eq!(state.transient_bytes, 0);
     }
+
+    #[test]
+    fn reregistering_an_interned_registry_reserves_nothing() {
+        let store = NativeStore::new(
+            &json!({"max_retained_bytes":8*1024*1024,"reserved_hook_accounted_bytes":8*1024*1024}),
+        )
+        .unwrap();
+        let hook = context("owner");
+        let mut review = hook.clone();
+        review.insert("admission", json!("review"));
+        let other_uid = json!({"claimant":"owner","admission":"hook","authority":{"kind":"user","effective_uid":"0"},"registry_generation":hook["registry_generation"]});
+        let specs = json!([{"name":"fetch","behaves_like":"Read","span_edit":null}]);
+        let reordered = json!([{"span_edit":null,"behaves_like":"Read","name":"fetch"}]);
+        let fingerprint = store.register_tool_registry(&specs, &hook).unwrap();
+        let registered = store.state.lock().unwrap().registries.len();
+        let first = Arc::clone(&store.state.lock().unwrap().registries[&fingerprint].snapshot);
+        assert_eq!(
+            store.register_tool_registry(&reordered, &review).unwrap(),
+            fingerprint
+        );
+        assert_eq!(
+            store
+                .register_tool_registry(&specs, &other_uid)
+                .unwrap_err()
+                .status,
+            Status::PermissionDenied
+        );
+        assert_eq!(
+            store
+                .register_tool_registry(
+                    &json!([{"name":"","behaves_like":"Read","span_edit":null}]),
+                    &hook
+                )
+                .unwrap_err()
+                .status,
+            Status::InvalidRequest
+        );
+        let state = store.state.lock().unwrap();
+        assert_eq!(state.registries.len(), registered);
+        assert!(Arc::ptr_eq(
+            &first,
+            &state.registries[&fingerprint].snapshot
+        ));
+        assert_eq!(state.transient_bytes, 0);
+    }
 }

{cc_transcript-14.32.1 → cc_transcript-14.33.1}/rust/crates/core/src/snapshot_projection.rs

@@ -1160,6 +1160,7 @@ fn signal_event<'a>(
     work: &mut Work<'a, '_>,
     index: usize,
     origin: &str,
+    thinking: bool,
 ) -> Result<Vec<Vec<&'a str>>, SnapshotError> {
     work.charge_range(index..index + 1)?;
     let event = work.snapshot.entry(index);
@@ -1193,7 +1194,7 @@ fn signal_event<'a>(
     for (ordinal, block) in event.blocks().iter().enumerate() {
         work.cancel.check(work.limits.deadline_unix_ms)?;
         match block {
-            ContentBlock::Thinking(text) if !text.is_empty() => plans.push(vec![text]),
+            ContentBlock::Thinking(text) if thinking && !text.is_empty() => plans.push(vec![text]),
             ContentBlock::ToolUse(tool) => {
                 let call = work
                     .snapshot
@@ -1258,6 +1259,9 @@ fn signal_query(
     if !["any", "assistant"].contains(&origin) {
         return Err(invalid("invalid signal origin"));
     }
+    let thinking = field(query, "thinking")?
+        .as_bool()
+        .ok_or_else(|| invalid("thinking must be boolean"))?;
     let window = field(query, "window")?;
     let mut plans = Vec::new();
     if window.as_str() == Some("current_turn") {
@@ -1272,7 +1276,7 @@ fn signal_query(
                 .max(work.snapshot.activity.turn_bounds(turn).unwrap().start);
         }
         for index in range {
-            plans.extend(signal_event(work, index, origin)?);
+            plans.extend(signal_event(work, index, origin, thinking)?);
         }
     } else {
         let count = count(query, "window")?;
@@ -1282,7 +1286,7 @@ fn signal_query(
             if length >= count {
                 break;
             }
-            let texts = signal_event(work, index, origin)?;
+            let texts = signal_event(work, index, origin, thinking)?;
             length += texts.len();
             events.push(texts);
         }
@@ -2973,7 +2977,7 @@ mod tests {
         let all = run(
             &snap,
             &request(
-                json!({"kind":"signal_texts","window":"current_turn","origin":"any"}),
+                json!({"kind":"signal_texts","window":"current_turn","origin":"any","thinking":true}),
                 json!([]),
             ),
         );
@@ -2998,7 +3002,7 @@ mod tests {
         let last = run(
             &snap,
             &request(
-                json!({"kind":"signal_texts","window":3,"origin":"assistant"}),
+                json!({"kind":"signal_texts","window":3,"origin":"assistant","thinking":true}),
                 json!([]),
             ),
         );
@@ -3009,6 +3013,29 @@ mod tests {
             .map(|value| value.as_str().unwrap())
             .collect();
         assert_eq!(actual, ["finding failure", "second", "todo subject"]);
+        let prose = run(
+            &snap,
+            &request(
+                json!({"kind":"signal_texts","window":"current_turn","origin":"assistant","thinking":false}),
+                json!([]),
+            ),
+        );
+        let actual: Vec<_> = prose.data["values"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|value| value.as_str().unwrap())
+            .collect();
+        assert_eq!(
+            actual,
+            [
+                "visible",
+                "task details",
+                "finding failure",
+                "second",
+                "todo subject"
+            ]
+        );
     }
 
     #[test]
@@ -3025,7 +3052,7 @@ mod tests {
         let result = run(
             &snap,
             &request(
-                json!({"kind":"signal_texts","window":10,"origin":"any"}),
+                json!({"kind":"signal_texts","window":10,"origin":"any","thinking":true}),
                 json!([]),
             ),
         );
@@ -3039,7 +3066,7 @@ mod tests {
         let zero = run(
             &snap,
             &request(
-                json!({"kind":"signal_texts","window":0,"origin":"any"}),
+                json!({"kind":"signal_texts","window":0,"origin":"any","thinking":true}),
                 json!([]),
             ),
         );

{cc_transcript-14.32.1 → cc_transcript-14.33.1}/rust/crates/core/src/toolcall.rs

@@ -127,15 +127,21 @@ pub struct ToolRegistrySnapshot {
 
 impl ToolRegistrySnapshot {
     pub fn from_specs(specs: HashMap<String, McpToolSpec>) -> Arc<Self> {
-        let value = sonic_rs::to_value(&specs).expect("tool registry serialization");
+        let fingerprint = Self::fingerprint_of(&specs);
+        Arc::new(Self { specs, fingerprint })
+    }
+
+    pub fn fingerprint_of(specs: &HashMap<String, McpToolSpec>) -> String {
+        let value = sonic_rs::to_value(specs).expect("tool registry serialization");
         let canonical = crate::ids::canonical_json(&value).expect("tool registry canonicalization");
-        Arc::new(Self {
-            specs,
-            fingerprint: format!("{:x}", Sha256::digest(canonical.as_bytes())),
-        })
+        format!("{:x}", Sha256::digest(canonical.as_bytes()))
     }
 
     pub fn from_specs_json(value: &Value) -> Result<Arc<Self>, String> {
+        Ok(Self::from_specs(Self::specs_from_json(value)?))
+    }
+
+    pub fn specs_from_json(value: &Value) -> Result<HashMap<String, McpToolSpec>, String> {
         let definitions = value
             .as_array()
             .ok_or_else(|| "tool registry definitions must be a list".to_string())?;
@@ -163,20 +169,18 @@ impl ToolRegistrySnapshot {
         }
         let definitions: Vec<ToolRegistryDefinition> =
             sonic_rs::from_value(value).map_err(|error| error.to_string())?;
-        Ok(Self::from_specs(
-            definitions
-                .into_iter()
-                .map(|definition| {
-                    (
-                        definition.name,
-                        McpToolSpec {
-                            behaves_like: definition.behaves_like,
-                            span_edit: definition.span_edit,
-                        },
-                    )
-                })
-                .collect(),
-        ))
+        Ok(definitions
+            .into_iter()
+            .map(|definition| {
+                (
+                    definition.name,
+                    McpToolSpec {
+                        behaves_like: definition.behaves_like,
+                        span_edit: definition.span_edit,
+                    },
+                )
+            })
+            .collect())
     }
 
     pub fn capture_scoped() -> Option<Arc<Self>> {
@@ -2396,6 +2400,22 @@ mod tests {
         assert_eq!(first.fingerprint(), reordered.fingerprint());
         assert_ne!(first.fingerprint(), changed.fingerprint());
         assert_eq!(first.fingerprint().len(), 64);
+        for (raw, constructed) in [
+            (
+                r#"[{"name":"reader","behaves_like":"Read","span_edit":null},{"name":"writer","behaves_like":"Edit","span_edit":{"path":"file","content":"body","delete":null}}]"#,
+                &first,
+            ),
+            (
+                r#"[{"name":"reader","behaves_like":"Read","span_edit":null},{"name":"writer","behaves_like":"Edit","span_edit":{"path":"file","content":"changed","delete":null}}]"#,
+                &changed,
+            ),
+        ] {
+            let specs = ToolRegistrySnapshot::specs_from_json(&obj(raw)).unwrap();
+            assert_eq!(
+                ToolRegistrySnapshot::fingerprint_of(&specs),
+                constructed.fingerprint()
+            );
+        }
         assert_eq!(
             ToolRegistrySnapshot::from_specs_json(&obj("[]"))
                 .unwrap()