Method rebuild_session_index

atomic-repository/src/repository/changes.rs:420–596

Rebuild session indexes from stored provenance graphs. Idempotent: existing `(session, provenance)` pairs are skipped, so a rebuilt repository never gains duplicate turns. Corrupt provenance files are reported in the result rather than aborting the rebuild. Returns `(indexed_count, skipped_existing, corrupt_count)`.

(&self)

    /// files are reported in the result rather than aborting the rebuild.
    /// Returns `(indexed_count, skipped_existing, corrupt_count)`.
    pub fn rebuild_session_index(&self) -> Result<(usize, usize, usize), RepositoryError> {
        let mut indexed = 0usize;
        let mut skipped = 0usize;
        let mut corrupt = 0usize;

        // Collect (hash, graph) pairs first so each write txn is short-lived.
        let mut graphs: Vec<(Hash, atomic_core::change::ProvenanceGraph)> = Vec::new();
        for result in self.change_store.iter_provenance_graphs() {
            match result {
                Ok(hash) => match self.load_provenance_graph(&hash) {
                    Ok(graph) => graphs.push((hash, graph)),
                    Err(_) => corrupt += 1,
                },
                Err(_) => corrupt += 1,
            }
        }

        // Group by session. The core index derives canonical turn order from
        // the complete set, independent of this ingestion order.
        let mut by_session: std::collections::BTreeMap<
            String,
            Vec<(Hash, atomic_core::change::ProvenanceGraph)>,
        > = std::collections::BTreeMap::new();
        let mut head_manifests = std::collections::BTreeMap::new();
        let mut fork_parents = std::collections::BTreeMap::new();
        for (hash, graph) in graphs {
            by_session
                .entry(graph.session_id.clone())
                .or_default()
                .push((hash, graph));
        }
        // Forked children can contain only inherited turns, whose provenance
        // files still name the parent session. Include both existing ledgers
        // and portable manifests so rebuild can create or migrate the child.
        {
            let txn = self
                .pristine
                .read_txn()
                .map_err(|e| RepositoryError::Database(e.to_string()))?;
            for record in txn
                .list_session_records()
                .map_err(|e| RepositoryError::Database(e.to_string()))?
            {
                if record.turn_count > 0 {
                    by_session.entry(record.session_id).or_default();
                }
            }
            for (head_session_id, head) in txn
                .list_session_heads()
                .map_err(|e| RepositoryError::Database(e.to_string()))?
            {
                match txn.get_session_manifest(&head) {
                    Ok(Some(manifest)) if manifest.session_id == head_session_id => {
                        if let (Some(parent_hash), Some(fork_turn)) =
                            (manifest.parent_session, manifest.fork_turn)
                        {
                            if let Ok(Some(parent)) = txn.get_session_manifest(&parent_hash) {
                                fork_parents.insert(