fix: retain annotated compaction history and honor non-System input policy

crates/session-store/src/input_metadata.rs

@@ -238,11 +238,20 @@ impl HistoryInputMetadata {
     }
 
     pub fn public_use_policy(&self) -> protocol::SessionEntryUsePolicy {
-        let has_public = self.public.is_some();
         protocol::SessionEntryUsePolicy {
-            observation_readable: has_public
-                && self.usage.observation == InputObservationUse::Readable,
-            memory_evidence: has_public && self.usage.memory_evidence == InputEvidenceUse::Include,
+            observation_readable: self.usage.observation == InputObservationUse::Readable,
+            memory_evidence: self.usage.memory_evidence == InputEvidenceUse::Include,
+        }
+    }
+
+    pub fn public_system_use_policy(&self) -> protocol::SessionEntryUsePolicy {
+        if self.public.is_some() {
+            self.public_use_policy()
+        } else {
+            protocol::SessionEntryUsePolicy {
+                observation_readable: false,
+                memory_evidence: false,
+            }
         }
     }
 

crates/session-store/src/public_material.rs

@@ -903,12 +903,12 @@ fn canonical_body(
         if allowed == crate::InputEvidenceUse::Exclude {
             return None;
         }
-        let public = input.public_item()?;
         if let LoggedItem::Message {
             role: LoggedRole::System,
             ..
         } = &entry.item
         {
+            let public = input.public_item()?;
             return Some(CanonicalBody::Message {
                 origin: &entry.metadata.origin,
                 role: LoggedRole::System,
@@ -917,7 +917,6 @@ fn canonical_body(
                 }]),
             });
         }
-        return None;
     }
     match &entry.item {
         LoggedItem::Message {

crates/session-store/src/public_snapshot.rs

@@ -1627,7 +1627,7 @@ pub(crate) fn project_session_snapshot_for_segment(
                     .metadata
                     .input_metadata
                     .as_ref()
-                    .map(crate::HistoryInputMetadata::public_use_policy),
+                    .map(crate::HistoryInputMetadata::public_system_use_policy),
             )),
             LogEntry::RunYielded {
                 ts,
@@ -1795,11 +1795,19 @@ fn history_entry(
     data: SessionSnapshotEntryData,
 ) -> SessionSnapshotEntry {
     SessionSnapshotEntry {
-        use_policy: entry
-            .metadata
-            .input_metadata
-            .as_ref()
-            .map(crate::HistoryInputMetadata::public_use_policy),
+        use_policy: entry.metadata.input_metadata.as_ref().map(|input| {
+            if matches!(
+                entry.item,
+                LoggedItem::Message {
+                    role: LoggedRole::System,
+                    ..
+                }
+            ) {
+                input.public_system_use_policy()
+            } else {
+                input.public_use_policy()
+            }
+        }),
         entry_id: entry.metadata.entry_id.0.clone(),
         timestamp,
         provenance: provenance(&entry.metadata.origin),
@@ -1927,21 +1935,29 @@ pub fn session_tool_attachment_id(
 
 fn project_history_item(entry: &LoggedHistoryEntry) -> Option<SessionSnapshotEntryData> {
     if let Some(input) = &entry.metadata.input_metadata {
-        if !matches!(
+        if matches!(
             entry.item,
             LoggedItem::Message {
                 role: LoggedRole::System,
                 ..
             }
         ) {
+            let public = input.public_projection();
+            return Some(SessionSnapshotEntryData::SystemItem {
+                item_kind: public.kind.clone(),
+                content: public.body.clone(),
+                data: Some(
+                    serde_json::to_value(public).expect("public system input is serializable"),
+                ),
+            });
+        }
+        let usage = input.usage();
+        if usage.recording_material == crate::InputEvidenceUse::Exclude
+            && usage.memory_evidence == crate::InputEvidenceUse::Exclude
+            && usage.observation == crate::InputObservationUse::Hidden
+        {
             return None;
         }
-        let public = input.public_projection();
-        return Some(SessionSnapshotEntryData::SystemItem {
-            item_kind: public.kind.clone(),
-            content: public.body.clone(),
-            data: Some(serde_json::to_value(public).expect("public system input is serializable")),
-        });
     }
     project_item(&entry.metadata.entry_id.0, &entry.item)
 }