v0.3.6-pre.007

2026-09-01 14:47:23 +02:00
parent be0032e76b
commit 138395ac35
11 changed files with 916 additions and 36 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 404
+# version: 405

 [workspace]
 resolver = "3"
 members = ["crates/ksp-app-config-desk", "crates/ksp-app-solprices-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-interface-lib", "crates/ksp-job-api", "crates/ksp-job-backfill-lib", "crates/ksp-logging-lib", "crates/ksp-offchain-transport-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-program-api", "crates/ksp-store-api", "crates/ksp-store-lib", "crates/ksp-store-postgres-lib", "crates/ksp-wallet-lib"]

 [workspace.package]
-version = "0.3.6-pre.6.fix.2"
+version = "0.3.6-pre.7"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"
--- a/crates/ksp-job-backfill-lib/src/error.rs
+++ b/crates/ksp-job-backfill-lib/src/error.rs
@@ -1,10 +1,12 @@
 // file: crates/ksp-job-backfill-lib/src/error.rs
-// version: 2
+// version: 3

 /// Error code used when a signature page violates a bounded discovery invariant.
 pub const ERROR_CODE_BACKFILL_DISCOVERY_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("job_backfill", "discovery_invalid");
 /// Error code used when paginated discovery cannot advance its exclusive RPC cursor safely.
 pub const ERROR_CODE_BACKFILL_DISCOVERY_STALLED: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("job_backfill", "discovery_stalled");
+/// Error code used when Store persistence returns an impossible Backfill state or targets a different network.
+pub const ERROR_CODE_BACKFILL_PERSISTENCE_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("job_backfill", "persistence_invalid");
 /// Error code used when deterministic Transport-to-RAW conversion violates the v1 contract.
 pub const ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("job_backfill", "raw_conversion_invalid");
 /// Error code used when one Backfill request violates its bounded admission contract.
--- a/crates/ksp-job-backfill-lib/src/lib.rs
+++ b/crates/ksp-job-backfill-lib/src/lib.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/src/lib.rs
-// version: 2
+// version: 3

 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -10,13 +10,14 @@
 //! This tranche owns explicit admission, network-scoped candidate identity, deterministic
 //! `getSignaturesForAddress` pagination and canonical RAW v1 conversion through observed
 //! `getTransaction`. Transport retains provider/endpoint selection and retry; Store retains
-//! durable idempotence and persistence. Persistence, concurrency, checkpointing, cancellation
+//! durable idempotence through the atomic Store facade. Concurrency, checkpointing, cancellation
 //! and concrete latest-value snapshots are added by later v0.3.6 tranches.

 mod constants;
 mod conversion;
 mod discovery;
 mod error;
+mod persistence;
 mod request;

 /// Result of hydrating one deterministic candidate through observed `getTransaction`.
@@ -43,12 +44,22 @@ pub use self::discovery::discover_backfill_candidates;
 pub use self::error::ERROR_CODE_BACKFILL_DISCOVERY_INVALID;
 /// Error code used when paginated discovery cannot advance its exclusive RPC cursor safely.
 pub use self::error::ERROR_CODE_BACKFILL_DISCOVERY_STALLED;
+/// Error code used when Store persistence returns an impossible Backfill state or targets a different network.
+pub use self::error::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID;
 /// Error code used when deterministic Transport-to-RAW conversion violates the v1 contract.
 pub use self::error::ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID;
 /// Error code used when one Backfill request violates its bounded admission contract.
 pub use self::error::ERROR_CODE_BACKFILL_REQUEST_INVALID;
 /// Error code used when one transaction signature text violates the bounded Base58-shape contract.
 pub use self::error::ERROR_CODE_BACKFILL_SIGNATURE_INVALID;
+/// Canonical entity disposition produced by one Backfill Store persistence attempt.
+pub use self::persistence::BackfillEntityPersistence;
+/// Observation disposition produced by one Backfill Store persistence attempt.
+pub use self::persistence::BackfillObservationPersistence;
+/// Stable Backfill projection of one hydration persistence result.
+pub use self::persistence::BackfillPersistenceOutcome;
+/// Persists one hydrated result through the backend-neutral atomic Store contract.
+pub use self::persistence::persist_backfill_hydration;
 /// Commitment levels intentionally admitted by the historical Backfill vertical.
 pub use self::request::BackfillCommitment;
 /// Fully explicit bounded request for one historical transaction Backfill Job.
--- a/crates/ksp-job-backfill-lib/src/persistence.rs
+++ b/crates/ksp-job-backfill-lib/src/persistence.rs
@@ -0,0 +1,201 @@
+// file: crates/ksp-job-backfill-lib/src/persistence.rs
+// version: 1
+
+/// Canonical entity disposition produced by one Backfill Store persistence attempt.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum BackfillEntityPersistence {
+    /// The canonical RAW transaction was inserted for the first time.
+    Inserted,
+    /// Identical canonical RAW transaction content was already durable.
+    AlreadyPresent,
+    /// A durable purge tombstone prevented normal Backfill rehydration.
+    SkippedPurged,
+    /// `getTransaction` returned JSON `null`, so no canonical Store write was attempted.
+    Missing,
+    /// Store reported divergent canonical content for the same network-scoped transaction identity.
+    Conflict,
+}
+
+/// Observation disposition produced by one Backfill Store persistence attempt.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum BackfillObservationPersistence {
+    /// The deterministic acquisition observation was inserted for the first time.
+    Inserted,
+    /// The same deterministic acquisition observation was already durable.
+    AlreadyPresent,
+    /// Store intentionally recorded no observation because normal persistence skipped a purged entity or detected a conflict.
+    NotRecorded,
+    /// No observation existed because hydration returned `Missing` before persistence.
+    NotApplicable,
+}
+
+/// Stable Backfill projection of one hydration persistence result.
+///
+/// The canonical transaction identity remains `(network, signature)`. Provider, endpoint and
+/// transport details can affect the persisted observation but never the transaction identity.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct BackfillPersistenceOutcome {
+    reference: ksp_store_lib::RawTransactionReference,
+    entity: BackfillEntityPersistence,
+    observation: BackfillObservationPersistence,
+}
+
+impl BackfillPersistenceOutcome {
+    /// Returns the network-scoped canonical transaction identity classified by this result.
+    #[must_use]
+    pub fn reference(&self) -> &ksp_store_lib::RawTransactionReference {
+        return &self.reference;
+    }
+
+    /// Returns the canonical transaction persistence disposition.
+    #[must_use]
+    pub const fn entity(&self) -> BackfillEntityPersistence {
+        return self.entity;
+    }
+
+    /// Returns the acquisition-observation persistence disposition.
+    #[must_use]
+    pub const fn observation(&self) -> BackfillObservationPersistence {
+        return self.observation;
+    }
+}
+
+/// Persists one hydrated Backfill result through the backend-neutral Store facade.
+///
+/// Available acquisitions use the existing atomic transaction-plus-observation Store contract in
+/// `Normal` mode. A durable purge is therefore respected and never rehydrated implicitly.
+/// `Missing` performs no Store write. Stable Store content conflicts are projected explicitly as
+/// [`BackfillEntityPersistence::Conflict`] rather than being silently treated as idempotent skips.
+/// Other Store failures remain errors.
+pub async fn persist_backfill_hydration(
+    store: &ksp_store_lib::Store,
+    hydration: crate::BackfillHydrationOutcome,
+) -> ksp_core_lib::Result<BackfillPersistenceOutcome> {
+    return persist_hydration_with_port(store, hydration).await;
+}
+
+trait RawTransactionPersistencePort: std::marker::Send + std::marker::Sync {
+    fn network_matches(&self, network: &ksp_store_lib::RawNetworkId) -> bool;
+
+    fn persist_acquisition<'a>(
+        &'a self,
+        transaction: ksp_store_lib::RawTransaction,
+        observation: ksp_store_lib::RawTransactionObservation,
+        mode: ksp_store_lib::RawTransactionAcquisitionMode,
+    ) -> ksp_store_lib::StoreApiFuture<'a, ksp_store_lib::Result<ksp_store_lib::RawAcquisitionWriteOutcome>>;
+}
+
+impl RawTransactionPersistencePort for ksp_store_lib::Store {
+    fn network_matches(&self, network: &ksp_store_lib::RawNetworkId) -> bool {
+        let snapshot = self.runtime_snapshot();
+        return snapshot.network() == network;
+    }
+
+    fn persist_acquisition<'a>(
+        &'a self,
+        transaction: ksp_store_lib::RawTransaction,
+        observation: ksp_store_lib::RawTransactionObservation,
+        mode: ksp_store_lib::RawTransactionAcquisitionMode,
+    ) -> ksp_store_lib::StoreApiFuture<'a, ksp_store_lib::Result<ksp_store_lib::RawAcquisitionWriteOutcome>> {
+        return ksp_store_lib::RawTransactionWrite::persist_raw_transaction_acquisition(self, transaction, observation, mode);
+    }
+}
+
+async fn persist_hydration_with_port<P>(port: &P, hydration: crate::BackfillHydrationOutcome) -> ksp_core_lib::Result<BackfillPersistenceOutcome>
+where
+    P: RawTransactionPersistencePort,
+{
+    let reference = hydration.reference().clone();
+    if !port.network_matches(reference.network()) {
+        return std::result::Result::Err(persistence_error("store.network"));
+    }
+    return match hydration {
+        crate::BackfillHydrationOutcome::Missing(_) => std::result::Result::Ok(BackfillPersistenceOutcome {
+            reference,
+            entity: BackfillEntityPersistence::Missing,
+            observation: BackfillObservationPersistence::NotApplicable,
+        }),
+        crate::BackfillHydrationOutcome::Available(acquisition) => {
+            let (transaction, observation) = acquisition.into_parts();
+            persist_available_with_port(port, reference, transaction, observation).await
+        },
+    };
+}
+
+async fn persist_available_with_port<P>(
+    port: &P,
+    reference: ksp_store_lib::RawTransactionReference,
+    transaction: ksp_store_lib::RawTransaction,
+    observation: ksp_store_lib::RawTransactionObservation,
+) -> ksp_core_lib::Result<BackfillPersistenceOutcome>
+where
+    P: RawTransactionPersistencePort,
+{
+    if !port.network_matches(reference.network()) {
+        return std::result::Result::Err(persistence_error("store.network"));
+    }
+    if transaction.reference() != &reference || observation.transaction() != &reference {
+        return std::result::Result::Err(persistence_error("acquisition.reference"));
+    }
+    let result = port.persist_acquisition(transaction, observation, ksp_store_lib::RawTransactionAcquisitionMode::Normal).await;
+    return match result {
+        std::result::Result::Ok(outcome) => map_store_outcome(reference, outcome),
+        std::result::Result::Err(error) => {
+            if error.code() == ksp_store_lib::ERROR_CODE_RAW_CONFLICT {
+                return std::result::Result::Ok(BackfillPersistenceOutcome {
+                    reference,
+                    entity: BackfillEntityPersistence::Conflict,
+                    observation: BackfillObservationPersistence::NotRecorded,
+                });
+            }
+            std::result::Result::Err(error)
+        },
+    };
+}
+
+fn map_store_outcome(
+    reference: ksp_store_lib::RawTransactionReference,
+    outcome: ksp_store_lib::RawAcquisitionWriteOutcome,
+) -> ksp_core_lib::Result<BackfillPersistenceOutcome> {
+    let entity = outcome.entity();
+    let observation = outcome.observation();
+    if entity == ksp_store_lib::RawEntityWriteOutcome::Inserted && observation == ksp_store_lib::RawObservationWriteOutcome::Inserted {
+        return std::result::Result::Ok(BackfillPersistenceOutcome {
+            reference,
+            entity: BackfillEntityPersistence::Inserted,
+            observation: BackfillObservationPersistence::Inserted,
+        });
+    }
+    if entity == ksp_store_lib::RawEntityWriteOutcome::AlreadyPresent && observation == ksp_store_lib::RawObservationWriteOutcome::Inserted {
+        return std::result::Result::Ok(BackfillPersistenceOutcome {
+            reference,
+            entity: BackfillEntityPersistence::AlreadyPresent,
+            observation: BackfillObservationPersistence::Inserted,
+        });
+    }
+    if entity == ksp_store_lib::RawEntityWriteOutcome::AlreadyPresent && observation == ksp_store_lib::RawObservationWriteOutcome::AlreadyPresent {
+        return std::result::Result::Ok(BackfillPersistenceOutcome {
+            reference,
+            entity: BackfillEntityPersistence::AlreadyPresent,
+            observation: BackfillObservationPersistence::AlreadyPresent,
+        });
+    }
+    if entity == ksp_store_lib::RawEntityWriteOutcome::SkippedPurged && observation == ksp_store_lib::RawObservationWriteOutcome::NotRecorded {
+        return std::result::Result::Ok(BackfillPersistenceOutcome {
+            reference,
+            entity: BackfillEntityPersistence::SkippedPurged,
+            observation: BackfillObservationPersistence::NotRecorded,
+        });
+    }
+    return std::result::Result::Err(persistence_error("store.outcome"));
+}
+
+fn persistence_error(field: &'static str) -> ksp_core_lib::Error {
+    return ksp_core_lib::Error::new(crate::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID, "invalid Backfill Store persistence state").with_context("field", field);
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/persistence.rs"]
+mod tests;
--- a/crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
+++ b/crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
@@ -1,10 +1,10 @@
 // file: crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
-// version: 2
+// version: 3

-//! Dependency firewall canaries for Backfill discovery and RAW v1 conversion.
+//! Dependency firewall canaries through Backfill Store persistence.

 #[test]
-fn pre_006_manifest_uses_only_planned_ksp_edges_and_backend_neutral_store() {
+fn pre_007_manifest_uses_only_planned_ksp_edges_and_backend_neutral_store() {
    let manifest = include_str!("../Cargo.toml");
    for required in [
        "ksp-core-lib = { path = \"../ksp-core-lib\" }",
@@ -36,7 +36,7 @@ fn pre_006_manifest_uses_only_planned_ksp_edges_and_backend_neutral_store() {
 }

 #[test]
-fn pre_006_production_sources_keep_transport_and_store_in_their_owned_layers() {
+fn pre_007_production_sources_keep_transport_and_store_in_their_owned_layers() {
    let non_conversion_sources = [
        include_str!("../src/constants.rs"),
        include_str!("../src/discovery.rs"),
@@ -62,6 +62,15 @@ fn pre_006_production_sources_keep_transport_and_store_in_their_owned_layers() {
    for forbidden in ["ksp_config_lib::", "ksp_interface_lib::", "ksp_store_api::", "ksp_store_postgres_lib::", "reqwest::", "std::env", "tonic::"] {
        assert!(!conversion.contains(forbidden), "forbidden RAW conversion path detected: {forbidden}");
    }
+    let persistence = include_str!("../src/persistence.rs");
+    assert!(persistence.contains("persist_raw_transaction_acquisition"));
+    assert!(persistence.contains("RawTransactionAcquisitionMode::Normal"));
+    assert!(persistence.contains("ERROR_CODE_RAW_CONFLICT"));
+    assert!(!persistence.contains("record_raw_transaction_observation"));
+    assert!(!persistence.contains("RawTransactionAcquisitionMode::ForceRehydrate"));
+    for forbidden in ["ksp_config_lib::", "ksp_interface_lib::", "ksp_store_api::", "ksp_store_postgres_lib::", "reqwest::", "std::env", "tonic::"] {
+        assert!(!persistence.contains(forbidden), "forbidden Store persistence path detected: {forbidden}");
+    }
    let discovery = include_str!("../src/discovery.rs");
    assert!(discovery.contains("get_signatures_for_address"));
    assert!(!discovery.contains("execute_standard_rpc"));
--- a/crates/ksp-job-backfill-lib/tests/public_api.rs
+++ b/crates/ksp-job-backfill-lib/tests/public_api.rs
@@ -1,7 +1,7 @@
 // file: crates/ksp-job-backfill-lib/tests/public_api.rs
-// version: 2
+// version: 3

-//! Public API canaries for bounded Backfill discovery and RAW v1 conversion.
+//! Public API canaries for bounded Backfill discovery, RAW v1 conversion and Store persistence.

 #[test]
 fn pre_005_request_scope_and_discovery_contracts_are_available_from_crate_root() {
@@ -86,3 +86,13 @@ fn pre_006_raw_conversion_contract_is_available_from_crate_root() {
    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "raw_conversion_invalid"));
    return;
 }
+
+#[test]
+fn pre_007_store_persistence_contract_is_available_from_crate_root() {
+    let _persist = ksp_job_backfill_lib::persist_backfill_hydration;
+    let _outcome: std::option::Option<ksp_job_backfill_lib::BackfillPersistenceOutcome> = std::option::Option::None;
+    let _entity = ksp_job_backfill_lib::BackfillEntityPersistence::AlreadyPresent;
+    let _observation = ksp_job_backfill_lib::BackfillObservationPersistence::AlreadyPresent;
+    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "persistence_invalid"));
+    return;
+}
--- a/crates/ksp-job-backfill-lib/tests/release_completeness.rs
+++ b/crates/ksp-job-backfill-lib/tests/release_completeness.rs
@@ -1,10 +1,10 @@
 // file: crates/ksp-job-backfill-lib/tests/release_completeness.rs
-// version: 2
+// version: 3

-//! Completeness canaries for the `pre.006` Backfill RAW conversion tranche.
+//! Completeness canaries through the `pre.007` Backfill Store persistence tranche.

 #[test]
-fn pre_006_production_module_inventory_is_exact() -> std::io::Result<()> {
+fn pre_007_production_module_inventory_is_exact() -> std::io::Result<()> {
    let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
    let entries = match std::fs::read_dir(source_root) {
        std::result::Result::Ok(value) => value,
@@ -32,12 +32,12 @@ fn pre_006_production_module_inventory_is_exact() -> std::io::Result<()> {
        }
    }
    names.sort_unstable();
-    assert_eq!(names, std::vec!["constants.rs", "conversion.rs", "discovery.rs", "error.rs", "lib.rs", "request.rs"]);
+    assert_eq!(names, std::vec!["constants.rs", "conversion.rs", "discovery.rs", "error.rs", "lib.rs", "persistence.rs", "request.rs"]);
    return std::result::Result::Ok(());
 }

 #[test]
-fn pre_006_surface_adds_raw_conversion_without_persistence_or_checkpoint_runtime() {
+fn pre_007_surface_adds_store_persistence_without_checkpoint_runtime() {
    let root = include_str!("../src/lib.rs");
    for required in [
        "BackfillCandidate",
@@ -56,11 +56,16 @@ fn pre_006_surface_adds_raw_conversion_without_persistence_or_checkpoint_runtime
        "RAW_TRANSACTION_FORMAT_ID",
        "RAW_TRANSACTION_FORMAT_VERSION",
        "ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID",
+        "BackfillPersistenceOutcome",
+        "BackfillEntityPersistence",
+        "BackfillObservationPersistence",
+        "persist_backfill_hydration",
+        "ERROR_CODE_BACKFILL_PERSISTENCE_INVALID",
    ] {
        assert!(root.contains(required), "required pre.006 public contract missing: {required}");
    }
-    for forbidden in ["persist_raw_transaction_acquisition", "BackfillCheckpoint", "BackfillJobHandle", "JobSnapshotSource"] {
-        assert!(!root.contains(forbidden), "later Backfill tranche leaked into pre.006: {forbidden}");
+    for forbidden in ["BackfillCheckpoint", "BackfillJobHandle", "JobSnapshotSource"] {
+        assert!(!root.contains(forbidden), "later Backfill tranche leaked into pre.007: {forbidden}");
    }
    assert!(!root.contains("pub mod "));
    return;
--- a/crates/ksp-job-backfill-lib/unit_tests/persistence.rs
+++ b/crates/ksp-job-backfill-lib/unit_tests/persistence.rs
@@ -0,0 +1,348 @@
+// file: crates/ksp-job-backfill-lib/unit_tests/persistence.rs
+// version: 1
+
+#[derive(Clone, Copy)]
+enum FakeResponse {
+    Outcome(ksp_store_lib::RawAcquisitionWriteOutcome),
+    Conflict,
+    Failure,
+}
+
+struct FakePersistencePort {
+    network: ksp_store_lib::RawNetworkId,
+    responses: std::sync::Mutex<std::collections::VecDeque<FakeResponse>>,
+    calls: std::sync::atomic::AtomicUsize,
+    normal_mode_only: std::sync::atomic::AtomicBool,
+}
+
+impl FakePersistencePort {
+    fn new(network: ksp_store_lib::RawNetworkId, responses: &[FakeResponse]) -> Self {
+        return Self {
+            network,
+            responses: std::sync::Mutex::new(responses.iter().copied().collect()),
+            calls: std::sync::atomic::AtomicUsize::new(0),
+            normal_mode_only: std::sync::atomic::AtomicBool::new(true),
+        };
+    }
+
+    fn calls(&self) -> usize {
+        return self.calls.load(std::sync::atomic::Ordering::SeqCst);
+    }
+
+    fn used_only_normal_mode(&self) -> bool {
+        return self.normal_mode_only.load(std::sync::atomic::Ordering::SeqCst);
+    }
+}
+
+impl super::RawTransactionPersistencePort for FakePersistencePort {
+    fn network_matches(&self, network: &ksp_store_lib::RawNetworkId) -> bool {
+        return &self.network == network;
+    }
+
+    fn persist_acquisition<'a>(
+        &'a self,
+        transaction: ksp_store_lib::RawTransaction,
+        observation: ksp_store_lib::RawTransactionObservation,
+        mode: ksp_store_lib::RawTransactionAcquisitionMode,
+    ) -> ksp_store_lib::StoreApiFuture<'a, ksp_store_lib::Result<ksp_store_lib::RawAcquisitionWriteOutcome>> {
+        self.calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        if mode != ksp_store_lib::RawTransactionAcquisitionMode::Normal {
+            self.normal_mode_only.store(false, std::sync::atomic::Ordering::SeqCst);
+        }
+        let result = if transaction.reference() != observation.transaction() {
+            std::result::Result::Err(ksp_core_lib::Error::new(
+                ksp_core_lib::ErrorCode::new("test", "reference_mismatch"),
+                "fake persistence reference mismatch",
+            ))
+        } else {
+            let response = match self.responses.lock() {
+                std::result::Result::Ok(mut responses) => responses.pop_front(),
+                std::result::Result::Err(_) => std::option::Option::None,
+            };
+            match response {
+                std::option::Option::Some(FakeResponse::Outcome(outcome)) => std::result::Result::Ok(outcome),
+                std::option::Option::Some(FakeResponse::Conflict) => {
+                    std::result::Result::Err(ksp_core_lib::Error::new(ksp_store_lib::ERROR_CODE_RAW_CONFLICT, "fake canonical content conflict"))
+                },
+                std::option::Option::Some(FakeResponse::Failure) | std::option::Option::None => {
+                    std::result::Result::Err(ksp_core_lib::Error::new(ksp_core_lib::ErrorCode::new("test", "store_failure"), "fake Store failure"))
+                },
+            }
+        };
+        return std::boxed::Box::pin(async move {
+            return result;
+        });
+    }
+}
+
+fn raw_network(value: &str) -> std::option::Option<ksp_store_lib::RawNetworkId> {
+    return match ksp_store_lib::RawNetworkId::new(value) {
+        std::result::Result::Ok(network) => std::option::Option::Some(network),
+        std::result::Result::Err(_) => std::option::Option::None,
+    };
+}
+
+fn raw_reference(network: &str, signature_byte: u8) -> std::option::Option<ksp_store_lib::RawTransactionReference> {
+    let network = match raw_network(network) {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return std::option::Option::None,
+    };
+    return std::option::Option::Some(ksp_store_lib::RawTransactionReference::new(network, ksp_store_lib::RawTransactionSignature::new([signature_byte; 64])));
+}
+
+fn raw_acquisition_parts(
+    network: &str,
+    signature_byte: u8,
+    observation_byte: u8,
+) -> std::option::Option<(ksp_store_lib::RawTransactionReference, ksp_store_lib::RawTransaction, ksp_store_lib::RawTransactionObservation)> {
+    let reference = match raw_reference(network, signature_byte) {
+        std::option::Option::Some(reference) => reference,
+        std::option::Option::None => return std::option::Option::None,
+    };
+    let format_id = match ksp_store_lib::RawFormatId::new(crate::RAW_TRANSACTION_FORMAT_ID) {
+        std::result::Result::Ok(format_id) => format_id,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let payload = ksp_store_lib::RawPayload::try_new(
+        format_id,
+        crate::RAW_TRANSACTION_FORMAT_VERSION,
+        std::vec![signature_byte].into_boxed_slice(),
+        ksp_store_lib::RawContentHash::new([signature_byte; 32]),
+    );
+    let payload = match payload {
+        std::result::Result::Ok(payload) => payload,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let received_at = match ksp_store_lib::RawTimestamp::from_unix_millis(1_700_000_000_000) {
+        std::result::Result::Ok(received_at) => received_at,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let provider = match ksp_store_lib::RawProvenanceCode::new("provider") {
+        std::result::Result::Ok(provider) => provider,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let protocol = match ksp_store_lib::RawProvenanceCode::new("solana.http.json_rpc") {
+        std::result::Result::Ok(protocol) => protocol,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let method = match ksp_store_lib::RawProvenanceCode::new("getTransaction") {
+        std::result::Result::Ok(method) => method,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let provenance = ksp_store_lib::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_lib::RawAcquisitionOrigin::Backfill, received_at);
+    let transaction = ksp_store_lib::RawTransaction::new(reference.clone(), 42, std::option::Option::None, payload);
+    let observation =
+        ksp_store_lib::RawTransactionObservation::new(ksp_store_lib::RawObservationKey::new([observation_byte; 32]), reference.clone(), provenance);
+    return std::option::Option::Some((reference, transaction, observation));
+}
+
+fn store_outcome(
+    entity: ksp_store_lib::RawEntityWriteOutcome,
+    observation: ksp_store_lib::RawObservationWriteOutcome,
+) -> ksp_store_lib::RawAcquisitionWriteOutcome {
+    return ksp_store_lib::RawAcquisitionWriteOutcome::new(entity, observation);
+}
+
+#[tokio::test]
+async fn pre_007_missing_skips_store_and_preserves_network_scoped_identity() {
+    let reference = match raw_reference("devnet", 1) {
+        std::option::Option::Some(reference) => reference,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let port = FakePersistencePort::new(network, &[]);
+    let result = super::persist_hydration_with_port(&port, crate::BackfillHydrationOutcome::Missing(reference.clone())).await;
+    assert!(result.is_ok());
+    if let std::result::Result::Ok(result) = result {
+        assert_eq!(result.reference(), &reference);
+        assert_eq!(result.entity(), crate::BackfillEntityPersistence::Missing);
+        assert_eq!(result.observation(), crate::BackfillObservationPersistence::NotApplicable);
+    }
+    assert_eq!(port.calls(), 0);
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_store_network_mismatch_is_rejected_before_any_write() {
+    let reference = match raw_reference("devnet", 2) {
+        std::option::Option::Some(reference) => reference,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("mainnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let port = FakePersistencePort::new(network, &[]);
+    let result = super::persist_hydration_with_port(&port, crate::BackfillHydrationOutcome::Missing(reference)).await;
+    assert!(result.is_err());
+    if let std::result::Result::Err(error) = result {
+        assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID);
+    }
+    assert_eq!(port.calls(), 0);
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_atomic_insert_maps_entity_and_observation_without_second_write() {
+    let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 3, 13) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let response = store_outcome(ksp_store_lib::RawEntityWriteOutcome::Inserted, ksp_store_lib::RawObservationWriteOutcome::Inserted);
+    let port = FakePersistencePort::new(network, &[FakeResponse::Outcome(response)]);
+    let result = super::persist_available_with_port(&port, reference.clone(), transaction, observation).await;
+    assert!(result.is_ok());
+    if let std::result::Result::Ok(result) = result {
+        assert_eq!(result.reference(), &reference);
+        assert_eq!(result.entity(), crate::BackfillEntityPersistence::Inserted);
+        assert_eq!(result.observation(), crate::BackfillObservationPersistence::Inserted);
+    }
+    assert_eq!(port.calls(), 1);
+    assert!(port.used_only_normal_mode());
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_existing_entity_distinguishes_new_from_idempotent_observation() {
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let first = store_outcome(ksp_store_lib::RawEntityWriteOutcome::AlreadyPresent, ksp_store_lib::RawObservationWriteOutcome::Inserted);
+    let second = store_outcome(ksp_store_lib::RawEntityWriteOutcome::AlreadyPresent, ksp_store_lib::RawObservationWriteOutcome::AlreadyPresent);
+    let port = FakePersistencePort::new(network, &[FakeResponse::Outcome(first), FakeResponse::Outcome(second)]);
+    let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 4, 14) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
+    assert!(result.is_ok());
+    if let std::result::Result::Ok(result) = result {
+        assert_eq!(result.entity(), crate::BackfillEntityPersistence::AlreadyPresent);
+        assert_eq!(result.observation(), crate::BackfillObservationPersistence::Inserted);
+    }
+    let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 4, 14) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let rerun = super::persist_available_with_port(&port, reference, transaction, observation).await;
+    assert!(rerun.is_ok());
+    if let std::result::Result::Ok(rerun) = rerun {
+        assert_eq!(rerun.entity(), crate::BackfillEntityPersistence::AlreadyPresent);
+        assert_eq!(rerun.observation(), crate::BackfillObservationPersistence::AlreadyPresent);
+    }
+    assert_eq!(port.calls(), 2);
+    assert!(port.used_only_normal_mode());
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_normal_backfill_respects_purged_tombstone_without_observation() {
+    let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 5, 15) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let response = store_outcome(ksp_store_lib::RawEntityWriteOutcome::SkippedPurged, ksp_store_lib::RawObservationWriteOutcome::NotRecorded);
+    let port = FakePersistencePort::new(network, &[FakeResponse::Outcome(response)]);
+    let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
+    assert!(result.is_ok());
+    if let std::result::Result::Ok(result) = result {
+        assert_eq!(result.entity(), crate::BackfillEntityPersistence::SkippedPurged);
+        assert_eq!(result.observation(), crate::BackfillObservationPersistence::NotRecorded);
+    }
+    assert!(port.used_only_normal_mode());
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_store_content_conflict_is_explicit_and_not_idempotent_success() {
+    let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 6, 16) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let port = FakePersistencePort::new(network, &[FakeResponse::Conflict]);
+    let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
+    assert!(result.is_ok());
+    if let std::result::Result::Ok(result) = result {
+        assert_eq!(result.entity(), crate::BackfillEntityPersistence::Conflict);
+        assert_eq!(result.observation(), crate::BackfillObservationPersistence::NotRecorded);
+        assert_ne!(result.entity(), crate::BackfillEntityPersistence::AlreadyPresent);
+    }
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_non_conflict_store_failure_propagates_unchanged() {
+    let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 7, 17) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let port = FakePersistencePort::new(network, &[FakeResponse::Failure]);
+    let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
+    assert!(result.is_err());
+    if let std::result::Result::Err(error) = result {
+        assert_eq!(error.code(), ksp_core_lib::ErrorCode::new("test", "store_failure"));
+    }
+    return;
+}
+
+#[test]
+fn pre_007_normal_mode_rejects_impossible_store_outcome_combinations() {
+    let reference = match raw_reference("devnet", 8) {
+        std::option::Option::Some(reference) => reference,
+        std::option::Option::None => return,
+    };
+    let impossible = [
+        store_outcome(ksp_store_lib::RawEntityWriteOutcome::Rehydrated, ksp_store_lib::RawObservationWriteOutcome::Inserted),
+        store_outcome(ksp_store_lib::RawEntityWriteOutcome::Inserted, ksp_store_lib::RawObservationWriteOutcome::AlreadyPresent),
+        store_outcome(ksp_store_lib::RawEntityWriteOutcome::SkippedPurged, ksp_store_lib::RawObservationWriteOutcome::Inserted),
+    ];
+    for outcome in impossible {
+        let result = super::map_store_outcome(reference.clone(), outcome);
+        assert!(result.is_err());
+        if let std::result::Result::Err(error) = result {
+            assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID);
+        }
+    }
+    return;
+}
+
+#[tokio::test]
+async fn pre_007_mismatched_transaction_observation_reference_is_rejected_before_store() {
+    let (reference, transaction, _) = match raw_acquisition_parts("devnet", 9, 19) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let (_, _, observation) = match raw_acquisition_parts("devnet", 10, 20) {
+        std::option::Option::Some(parts) => parts,
+        std::option::Option::None => return,
+    };
+    let network = match raw_network("devnet") {
+        std::option::Option::Some(network) => network,
+        std::option::Option::None => return,
+    };
+    let port = FakePersistencePort::new(network, &[]);
+    let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
+    assert!(result.is_err());
+    assert_eq!(port.calls(), 0);
+    return;
+}
--- a/deltas/0.3.6/pre.007.md
+++ b/deltas/0.3.6/pre.007.md
@@ -0,0 +1,286 @@
+<!-- file: deltas/0.3.6/pre.007.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.6-pre.007` — persistance Store atomique et idempotence Backfill
+
+## Base requise
+
+```text
+0.3.6-pre.006-fix.002 appliquée
+workspace.package.version = 0.3.6-pre.6.fix.2
+```
+
+Le gate opérateur fourni pour cette base confirme :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS / clean
+python3 scripts/audit_markdown_tables.py ...         PASS / clean (264 tables / 151 fichiers)
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS / aucun warning
+cargo test -p ksp-job-backfill-lib                   PASS
+  unitaires                                           20 PASS
+  dependency_boundary                                  2 PASS
+  public_api                                           3 PASS
+  release_completeness                                 2 PASS
+cargo tree -p ksp-job-backfill-lib --edges normal    exécuté
+cargo tree -p ksp-job-backfill-lib -e features       exécuté
+```
+
+## Objectif
+
+Matérialiser exclusivement `pre.007` du plan 027 : composer la persistance normale d'un résultat d'hydratation Backfill avec les contrats Store déjà existants, sans prélecture, sans second chemin d'écriture et sans ouvrir la concurrence, la frontier ou le checkpoint de `pre.008`.
+
+L'identité canonique reste :
+
+```text
+RawTransactionReference = (RawNetworkId, RawTransactionSignature)
+```
+
+Provider, endpoint et protocole ne participent toujours qu'à la provenance de l'observation.
+
+## Contrat public Backfill
+
+La tranche ajoute :
+
+```text
+persist_backfill_hydration
+BackfillPersistenceOutcome
+BackfillEntityPersistence
+BackfillObservationPersistence
+ERROR_CODE_BACKFILL_PERSISTENCE_INVALID
+```
+
+`BackfillPersistenceOutcome` conserve la référence réseau + signature et projette séparément l'état de l'entité canonique et celui de l'observation. Cette projection évite de réduire un conflit, une purge ou une nouvelle observation à un compteur `skip` ambigu.
+
+Dispositions entité :
+
+```text
+Inserted
+AlreadyPresent
+SkippedPurged
+Missing
+Conflict
+```
+
+Dispositions observation :
+
+```text
+Inserted
+AlreadyPresent
+NotRecorded
+NotApplicable
+```
+
+## Composition Store atomique
+
+Pour `BackfillHydrationOutcome::Available`, la bibliothèque consomme l'acquisition en mémoire puis appelle exclusivement :
+
+```text
+ksp_store_lib::RawTransactionWrite::persist_raw_transaction_acquisition
+```
+
+avec :
+
+```text
+RawTransactionAcquisitionMode::Normal
+```
+
+La transaction et son observation restent donc une seule opération logique atomique possédée par Store. La tranche n'appelle jamais `record_raw_transaction_observation` séparément et n'introduit aucune prélecture `get_raw_transaction` avant écriture.
+
+`ForceRehydrate` n'est pas exposé par le chemin Backfill normal.
+
+## Réseau
+
+Avant toute écriture, le réseau logique exposé par le snapshot du Store doit être identique au `RawNetworkId` de la référence hydratée. Un mismatch est rejeté par :
+
+```text
+ERROR_CODE_BACKFILL_PERSISTENCE_INVALID
+field = store.network
+```
+
+Ce contrôle n'utilise ni endpoint, ni provider, ni protocole comme identité.
+
+Une incohérence interne entre la référence annoncée, la transaction et l'observation est également rejetée avant soumission Store.
+
+## Outcomes Store admis
+
+En mode normal, les combinaisons Store suivantes sont acceptées et projetées explicitement :
+
+```text
+RawEntityWriteOutcome::Inserted
+ RawObservationWriteOutcome::Inserted
+    -> Inserted / Inserted
+
+RawEntityWriteOutcome::AlreadyPresent
+ RawObservationWriteOutcome::Inserted
+    -> AlreadyPresent / Inserted
+
+RawEntityWriteOutcome::AlreadyPresent
+ RawObservationWriteOutcome::AlreadyPresent
+    -> AlreadyPresent / AlreadyPresent
+
+RawEntityWriteOutcome::SkippedPurged
+ RawObservationWriteOutcome::NotRecorded
+    -> SkippedPurged / NotRecorded
+```
+
+`RawEntityWriteOutcome::Rehydrated` est impossible dans le chemin normal et est rejeté, comme toute autre combinaison incohérente.
+
+## Missing
+
+`BackfillHydrationOutcome::Missing(reference)` devient :
+
+```text
+Missing / NotApplicable
+```
+
+sans aucune écriture Store. La tranche ne persiste toujours ni observation `missing`, ni observation d'échec fabriquée ; ces contrats n'existent pas dans le Store RAW transaction actuel.
+
+## Conflit et erreurs
+
+Une erreur Store dont le code stable est :
+
+```text
+ERROR_CODE_RAW_CONFLICT
+```
+
+est projetée en :
+
+```text
+Conflict / NotRecorded
+```
+
+Elle reste donc visible et distincte de l'idempotence. Les tranches de frontier/snapshot pourront ensuite la traiter comme trou/échec sans parsing de message d'erreur.
+
+Toutes les autres erreurs Store sont propagées telles quelles.
+
+## Idempotence
+
+La même acquisition déterministe peut produire successivement :
+
+```text
+Inserted / Inserted
+AlreadyPresent / AlreadyPresent
+```
+
+sans doublon logique. Une entité déjà présente peut aussi recevoir une nouvelle observation légitime :
+
+```text
+AlreadyPresent / Inserted
+```
+
+La distinction repose entièrement sur les outcomes Store officiels ; Job ne reconstruit aucune logique d'idempotence physique.
+
+## Tests matérialisés
+
+La tranche ajoute **9 tests unitaires**, portant le total de `ksp-job-backfill-lib` à **29 unitaires** :
+
+- `Missing` ne soumet aucune écriture ;
+- mismatch réseau rejeté avant Store ;
+- insert atomique `Inserted/Inserted` ;
+- entité existante + nouvelle observation ;
+- relance idempotente `AlreadyPresent/AlreadyPresent` ;
+- purge normale `SkippedPurged/NotRecorded` ;
+- conflit Store explicite et non confondu avec idempotence ;
+- erreur Store non conflit propagée ;
+- combinaisons impossibles et mismatch transaction/observation rejetés.
+
+Une canarie publique supplémentaire porte les canaries d'intégration à **8** :
+
+```text
+dependency_boundary       2
+public_api                4
+release_completeness      2
+```
+
+Les canaries statiques verrouillent l'usage de l'écriture atomique, du mode `Normal`, l'absence d'écriture d'observation séparée, l'absence de `ForceRehydrate`, l'absence de backend Store direct et la fermeture du checkpoint/runtime de `pre.008`.
+
+## Fichiers ajoutés
+
+```text
+crates/ksp-job-backfill-lib/src/persistence.rs
+crates/ksp-job-backfill-lib/unit_tests/persistence.rs
+deltas/0.3.6/pre.007.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/src/error.rs
+crates/ksp-job-backfill-lib/src/lib.rs
+crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
+crates/ksp-job-backfill-lib/tests/public_api.rs
+crates/ksp-job-backfill-lib/tests/release_completeness.rs
+docs/plans/027-V0_3_6_JOB_API_BACKFILL_PLAN.md
+docs/validation/023-V0_3_6_JOB_API_BACKFILL.md
+```
+
+## Versions d'en-tête
+
+Les fichiers Rust/TOML modifiés incrémentent tous leur version d'en-tête exactement d'une unité :
+
+```text
+Cargo.toml                                                     404 -> 405
+crates/ksp-job-backfill-lib/src/error.rs                         2 -> 3
+crates/ksp-job-backfill-lib/src/lib.rs                           2 -> 3
+crates/ksp-job-backfill-lib/tests/dependency_boundary.rs         2 -> 3
+crates/ksp-job-backfill-lib/tests/public_api.rs                  2 -> 3
+crates/ksp-job-backfill-lib/tests/release_completeness.rs        2 -> 3
+```
+
+Les deux nouveaux fichiers Rust commencent à `version: 1`. Le plan 027 et la validation 023 passent de `12` à `13`. Le présent delta commence à `version: 1`.
+
+## Version workspace
+
+La tranche modifie du Rust :
+
+```text
+workspace.package.version = 0.3.6-pre.7
+delivery = 0.3.6-pre.007
+commit = v0.3.6-pre.007
+```
+
+Aucun tag prerelease.
+
+## Fichiers supprimés
+
+Aucun.
+
+## Frontières conservées
+
+- aucune prélecture Store avant hydratation/persistance ;
+- aucun backend Store direct ;
+- aucun `ForceRehydrate` ;
+- aucune persistence de missing/failed artificielle ;
+- aucune concurrence d'hydratation concrète ;
+- aucune frontier contiguë ;
+- aucun checkpoint/reprise runtime ;
+- aucun snapshot Backfill concret ;
+- aucune nouvelle dépendance ou feature ;
+- aucune modification Transport, Store, Job API, Config, README, USAGE, CHANGELOG ou ROADMAP ;
+- aucun code kbot3 copié.
+
+## Validations dans l'environnement d'assemblage
+
+L'environnement d'assemblage exécute les audits statiques et contrôles d'archive mais ne possède ni `cargo`, ni `rustc`, ni `rustfmt`. Les tests Rust matérialisés ne sont donc pas annoncés comme exécutés localement.
+
+## Gate opérateur demandé
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.3.6
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-job-backfill-lib
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib -e features
+```
+
+Résultat attendu : **29 tests unitaires + 8 canaries d'intégration**, aucun warning Clippy, et dépendance Store toujours limitée à `ksp-store-lib` avec `default-features = false`.
+
+## Questions ouvertes
+
+Aucune pour `pre.007`. `pre.008` reste fermé tant que ce gate n'est pas vert.
--- a/docs/plans/027-V0_3_6_JOB_API_BACKFILL_PLAN.md
+++ b/docs/plans/027-V0_3_6_JOB_API_BACKFILL_PLAN.md
@@ -1,5 +1,5 @@
 <!-- file: docs/plans/027-V0_3_6_JOB_API_BACKFILL_PLAN.md -->
-<!-- version: 12 -->
+<!-- version: 13 -->

 # Plan v0.3.6 — Job API et premier backfill RAW

@@ -466,13 +466,19 @@ Le fix conserve exactement la forme publique `BackfillHydrationOutcome::Availabl

 #### `pre.006-fix.002` — Auto-deref idiomatique des accesseurs RAW

-Le gate opérateur de `pre.006-fix.001` confirme les audits, `cargo check`, les 20 tests unitaires et les 7 canaries, mais Clippy émet encore deux warnings `clippy::explicit_auto_deref` dans les accesseurs `transaction()` et `observation()` de `BackfillRawAcquisition`. Le correctif supprime uniquement les déréférencements explicites `(*self.inner)` au profit de l'auto-deref de Rust lors de l'accès aux champs privés. La représentation avec une unique `Box`, les signatures publiques, la sémantique RAW/provenance et le coût d'allocation restent inchangés. La version workspace devient `0.3.6-pre.6.fix.2`.
+**Statut : réalisé ; gate opérateur vert.**
+
+Le gate opérateur de `pre.006-fix.001` confirme les audits, `cargo check`, les 20 tests unitaires et les 7 canaries, mais Clippy émet encore deux warnings `clippy::explicit_auto_deref` dans les accesseurs `transaction()` et `observation()` de `BackfillRawAcquisition`. Le correctif supprime uniquement les déréférencements explicites `(*self.inner)` au profit de l'auto-deref de Rust lors de l'accès aux champs privés. La représentation avec une unique `Box`, les signatures publiques, la sémantique RAW/provenance et le coût d'allocation restent inchangés. La version workspace devient `0.3.6-pre.6.fix.2`. Le gate opérateur de `fix.002` est intégralement vert : audits Rust/Markdown, `cargo check`, Clippy sans warning, 20 unitaires, 7 canaries d'intégration et arbres Cargo passent.

 ### `pre.007` — Persistance Store et idempotence

-**Statut : planifié.**
+**Statut : matérialisé ; gate opérateur à rejouer.**

-Budget cible : **15-20 min**. Entrée : RAW v1 figé. Composer l'écriture atomique Store normale et les outcomes distincts. Sortie : insert, already present, purge, observation, missing, conflit et relance idempotente couverts.
+Budget cible : **15-20 min**. Entrée : RAW v1 figé et gate `pre.006-fix.002` vert. La tranche ajoute `persist_backfill_hydration` et une projection Backfill explicite des outcomes Store sans créer de second contrat de persistance. Une acquisition disponible est consommée par l'unique capacité atomique `RawTransactionWrite::persist_raw_transaction_acquisition` via `ksp-store-lib`, toujours en `RawTransactionAcquisitionMode::Normal`; aucune prélecture Store, écriture d'observation séparée ou `ForceRehydrate` n'est introduite.
+
+Le réseau du Store est comparé à l'identité `(RawNetworkId, signature)` avant toute écriture. `Missing` n'effectue aucune écriture. Les outcomes Store valides sont projetés en dispositions entité/observation distinctes : `Inserted/Inserted`, `AlreadyPresent/Inserted`, `AlreadyPresent/AlreadyPresent` et `SkippedPurged/NotRecorded`. `ERROR_CODE_RAW_CONFLICT` devient un outcome Backfill `Conflict/NotRecorded`, distinct d'un succès idempotent ; les autres erreurs Store restent des erreurs. Les combinaisons impossibles en mode normal, dont `Rehydrated`, sont rejetées par `ERROR_CODE_BACKFILL_PERSISTENCE_INVALID`.
+
+La tranche matérialise 29 tests unitaires et 8 canaries d'intégration au total. Les doubles Store restent privés et déterministes ; ils couvrent insert, nouvelle observation sur entité existante, relance idempotente, purge normale, conflit, erreur Store, mismatch réseau et incohérence de référence. La frontière contiguë, la concurrence et le checkpoint restent fermés jusqu'à `pre.008`.

 ### `pre.008` — Concurrence, frontier et checkpoint

--- a/docs/validation/023-V0_3_6_JOB_API_BACKFILL.md
+++ b/docs/validation/023-V0_3_6_JOB_API_BACKFILL.md
@@ -1,5 +1,5 @@
 <!-- file: docs/validation/023-V0_3_6_JOB_API_BACKFILL.md -->
-<!-- version: 12 -->
+<!-- version: 13 -->

 # Validation v0.3.6 — Job API et premier backfill RAW

@@ -143,7 +143,7 @@ Aucune entrée absolue, traversée, avec séparateur inversé ou lien symbolique

 `pre.006-fix.001` conserve l'API publique de l'enum et introduit une seule indirection privée dans `BackfillRawAcquisition`. Aucun `#[allow]` n'est ajouté. Les getters et `into_parts` conservent leurs signatures, et une canarie vérifie que `BackfillRawAcquisition` reste de la taille d'un pointeur. Le gate opérateur du fix confirme ensuite les audits, `cargo check`, les 20 unitaires et les 7 canaries, mais Clippy signale encore deux `clippy::explicit_auto_deref` dans `transaction()` et `observation()`.

-`pre.006-fix.002` remplace uniquement `&(*self.inner).transaction` et `&(*self.inner).observation` par les accès auto-deref idiomatiques `&self.inner.transaction` et `&self.inner.observation`. La Box privée unique, l'API publique et tous les invariants RAW/provenance restent inchangés. Le gate Cargo de `fix.002` reste à rejouer par l'opérateur.
+`pre.006-fix.002` remplace uniquement `&(*self.inner).transaction` et `&(*self.inner).observation` par les accès auto-deref idiomatiques `&self.inner.transaction` et `&self.inner.observation`. La Box privée unique, l'API publique et tous les invariants RAW/provenance restent inchangés. Le gate opérateur de `fix.002` est intégralement vert : audits Rust/Markdown, `cargo check`, Clippy sans warning, 20 unitaires, 7 canaries d'intégration et arbres Cargo passent sur `0.3.6-pre.6.fix.2`.

 - [X] Identité logique future auditée : transaction/signature scoping par `RawNetworkId`, jamais par rôle/provider/endpoint/protocole.
 - [X] Le Store PostgreSQL actuel est mono-réseau via `ksp_store_identity`; un futur backend multi-réseaux devra préserver `(network, signature)` par clé/partition équivalente.
@@ -156,20 +156,22 @@ Aucune entrée absolue, traversée, avec séparateur inversé ou lien symbolique
 - [X] Block time négatif rejeté explicitement.
 - [X] Hash SHA-256 et taille calculés sur les bytes exacts.
 - [X] Provenance contient fournisseur, protocole, méthode, endpoint sûr, engagement et réception.
- [ ] Clé d'observation domain-separated et déterministe.
+- [X] Clé d'observation domain-separated et déterministe, couverte par le gate `pre.006-fix.002`.
 - [X] Endpoint différent produit une nouvelle observation légitime.

 ## 11. Persistance Store

- [ ] Dépendance unique vers `ksp-store-lib`, jamais vers backend ou API directement.
- [ ] Écriture atomique transaction plus observation en mode `Normal`.
- [ ] Aucune prélecture de présence avant hydratation.
- [ ] Entités insérée, déjà présente et purgée distinguées.
- [ ] Observations insérée, déjà présente et non enregistrée distinguées.
- [ ] `getTransaction = null` ne produit aucune écriture fabriquée.
- [ ] Conflit Store reste une erreur terminale visible.
- [ ] Même JobId et même endpoint donnent une relance idempotente.
- [ ] `ForceRehydrate` inaccessible depuis le chemin normal.
+`pre.007` matérialise la composition Store normale sans élargir les responsabilités. Le chemin public consomme un `BackfillHydrationOutcome`, contrôle d'abord le réseau logique du Store, puis utilise exclusivement l'écriture atomique transaction + observation de `ksp-store-lib`. `Missing` ne déclenche aucune écriture. Un conflit de contenu Store est converti en outcome Backfill explicite afin que les tranches de frontier/snapshot puissent le compter puis le traiter comme trou/échec, sans le confondre avec l'idempotence. Les tests Rust de cette tranche sont matérialisés mais restent à exécuter dans le gate opérateur.
+
+- [X] Dépendance unique vers `ksp-store-lib`, jamais vers backend ou API directement, confirmée par audit de manifeste/source.
+- [X] Écriture atomique transaction plus observation composée en mode `Normal` dans l'unique chemin de persistance.
+- [X] Aucune prélecture de présence avant hydratation ou persistance.
+- [ ] Entités insérée, déjà présente et purgée distinguées au gate Rust `pre.007`.
+- [ ] Observations insérée, déjà présente et non enregistrée distinguées au gate Rust `pre.007`.
+- [ ] `getTransaction = null` ne produit aucune écriture fabriquée au gate Rust `pre.007`.
+- [ ] Conflit Store reste un outcome terminal visible, distinct d'un succès idempotent, au gate Rust `pre.007`.
+- [ ] Même JobId et même endpoint donnent une relance idempotente au gate Rust `pre.007`.
+- [X] `ForceRehydrate` absent du chemin normal `pre.007` par audit de source.

 ## 12. Concurrence, frontière et checkpoint

@@ -203,7 +205,7 @@ Aucune entrée absolue, traversée, avec séparateur inversé ou lien symbolique
 - [X] Versions/features auditées : aucune nouvelle version externe ; `sha2` et `tokio` réutilisent les entrées workspace existantes, Tokio étant dev-only en `pre.005`.
 - [X] `pre.005` matérialise 11 tests unitaires et 6 canaries d’intégration ; le gate opérateur les exécute tous avec succès.
 - [X] `pre.006` matérialise 19 tests unitaires et 7 canaries d’intégration ; le gate opérateur les exécute tous avec succès, avec uniquement le warning Clippy corrigé par `pre.006-fix.001`.
- [ ] `cargo clippy --workspace --all-targets` warning-free sur `pre.006-fix.002`.
+- [X] `cargo clippy --workspace --all-targets` warning-free sur `pre.006-fix.002`.
 - [ ] `cargo fmt --all -- --check` vert.
 - [X] `scripts/audit_rust_workspace_rules.py` vert sur `pre.005` dans l'environnement d'assemblage et dans le gate opérateur.
 - [X] `scripts/audit_markdown_tables.py` vert sur `pre.005` dans le gate opérateur (264 tables / 147 fichiers, delta inclus).
@@ -215,7 +217,7 @@ Aucune entrée absolue, traversée, avec séparateur inversé ou lien symbolique

 ## 15. Preuves d'intégration et fermeture

- [ ] Fake Transport et fake Store déterministes sans backend direct.
+- [X] Fake Transport et fake Store déterministes sans backend direct matérialisés ; exécution du fake Store `pre.007` à confirmer au gate opérateur.
 - [ ] Vertical découverte, hydratation, conversion, persistance et observation couvert.
 - [ ] Smoke Devnet plus PostgreSQL configuré exécuté si l'environnement explicite est disponible.
 - [ ] Aucun endpoint payant, credential ou donnée sensible requis par les tests normaux.