refactor(sessions)!: delete the Codex v1 source-cursor replay

crates/tracedecay-host-admission/src/lib.rs

@@ -8,8 +8,8 @@ use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
 use tracedecay_domain::{
-    CanonicalObservationIdV1, FactOwnerV1, ObservationScopeV1, ObservationSourceCursorV1,
-    ObservationSourceIdentityV1, RetrievalAnchorId, SanitizationReceiptV1,
+    FactOwnerV1, ObservationScopeV1, ObservationSourceCursorV1, ObservationSourceIdentityV1,
+    RetrievalAnchorId,
 };
 use tracedecay_store::observation::{CursorAdvanceOutcome, ObservationCursorAdvance};
 use tracedecay_store::{
@@ -32,8 +32,8 @@ use tracedecay_sessions::admission::{
 };
 use tracedecay_sessions::observation::{
     AdvanceNonDurableSourceCursorRequest, CaptureObservationOutcome, CaptureObservationRequest,
-    ExternalSourceProjectionRetryHandleV1, ExternalSourceProjectionStateV1, GetObservationRequest,
-    ObservationApplication, ObservationApplicationError, ObservationCancellation,
+    ExternalSourceProjectionRetryHandleV1, ExternalSourceProjectionStateV1, ObservationApplication,
+    ObservationApplicationError, ObservationCancellation,
 };
 use tracedecay_sessions::repository_provenance::RepositoryProvenanceAdmissionContext;
 use tracedecay_sessions::runtime::git_correlation::{
@@ -311,29 +311,6 @@ impl tracedecay_sessions::admission::HostAdmission for HostAdmissionFacade<'_> {
         Box::pin(HostAdmissionFacade::get_source_cursor(self, source, scope))
     }
 
-    fn observation_receipt<'a>(
-        &'a self,
-        provider: &'a str,
-        scope: &'a ObservationScopeV1,
-        observation_id: &'a CanonicalObservationIdV1,
-        cancellation: &'a ObservationCancellation,
-    ) -> tracedecay_sessions::admission::AdmissionFuture<'a, Option<SanitizationReceiptV1>> {
-        Box::pin(async move {
-            let application = self.application(provider, scope)?;
-            application
-                .get_observation(GetObservationRequest::new(
-                    observation_id.clone(),
-                    cancellation.clone(),
-                ))
-                .await
-                .map(|read| {
-                    read.observation()
-                        .map(|stored| stored.observation().receipt().clone())
-                })
-                .map_err(|error| classify_error(&error))
-        })
-    }
-
     fn drain_projection_queue<'a>(
         &'a self,
         provider: &'a str,

crates/tracedecay-sessions/src/admission/mod.rs

@@ -19,8 +19,7 @@ use std::pin::Pin;
 
 use serde::Serialize;
 use tracedecay_domain::{
-    CanonicalObservationIdV1, ObservationScopeV1, ObservationSourceCursorV1,
-    ObservationSourceIdentityV1, SanitizationReceiptV1,
+    ObservationScopeV1, ObservationSourceCursorV1, ObservationSourceIdentityV1,
 };
 use tracedecay_store::ParseOffset;
 use tracedecay_store::observation::{CursorAdvanceOutcome, ObservationCursorAdvance};
@@ -339,15 +338,6 @@ impl HostAdmissionOutcome {
             Some("parse_offset_conflict"),
         )
     }
-
-    #[hotpath::skip]
-    pub const fn observation_point_read_unavailable() -> Self {
-        Self::new(
-            HostAdmissionStatus::Unavailable,
-            true,
-            Some("observation_point_read_unavailable"),
-        )
-    }
 }
 
 pub(crate) fn is_admission_cancellation(
@@ -408,19 +398,6 @@ pub trait HostAdmission: Send + Sync {
         scope: &'a ObservationScopeV1,
     ) -> AdmissionFuture<'a, Option<ObservationSourceCursorV1>>;
 
-    /// Content-free point existence check for idempotent recovery. The
-    /// default is a typed unavailable state; production composition overrides
-    /// it with the canonical observation authority.
-    fn observation_receipt<'a>(
-        &'a self,
-        _provider: &'a str,
-        _scope: &'a ObservationScopeV1,
-        _observation_id: &'a CanonicalObservationIdV1,
-        _cancellation: &'a ObservationCancellation,
-    ) -> AdmissionFuture<'a, Option<SanitizationReceiptV1>> {
-        Box::pin(async { Err(HostAdmissionOutcome::observation_point_read_unavailable()) })
-    }
-
     /// Drains up to `max` queued projections for one provider.
     fn drain_projection_queue<'a>(
         &'a self,
@@ -607,8 +584,7 @@ pub(crate) mod test_support {
     type SessionBackfillPagePause = (Arc<tokio::sync::Barrier>, Arc<tokio::sync::Barrier>);
 
     use crate::observation::{
-        AdvanceNonDurableSourceCursorRequest, GetObservationRequest, ObservationApplication,
-        ObservationApplicationError,
+        AdvanceNonDurableSourceCursorRequest, ObservationApplication, ObservationApplicationError,
     };
 
     use super::*;
@@ -1136,28 +1112,6 @@ pub(crate) mod test_support {
             })
         }
 
-        fn observation_receipt<'a>(
-            &'a self,
-            _provider: &'a str,
-            _scope: &'a ObservationScopeV1,
-            observation_id: &'a CanonicalObservationIdV1,
-            cancellation: &'a ObservationCancellation,
-        ) -> AdmissionFuture<'a, Option<SanitizationReceiptV1>> {
-            Box::pin(async move {
-                self.application()?
-                    .get_observation(GetObservationRequest::new(
-                        observation_id.clone(),
-                        cancellation.clone(),
-                    ))
-                    .await
-                    .map(|read| {
-                        read.observation()
-                            .map(|stored| stored.observation().receipt().clone())
-                    })
-                    .map_err(Self::application_error)
-            })
-        }
-
         fn drain_projection_queue<'a>(
             &'a self,
             provider: &'a str,