Struct MigrationState 

pub struct MigrationState {
    pub format_version: u32,
    pub phase: Phase,
    pub source_path: PathBuf,
    pub source_fingerprint: String,
    pub target_model: String,
    pub target_dimension: usize,
    pub progress: BTreeMap<String, CollectionProgress>,
    pub embedder_witness: Option<String>,
}

What a prepared migration recorded, so a later run can decide whether to resume it.

Emphatically not a crate::migration::DiagnosisReport: a report answers “what is here”, a state asserts “a migration is under way and got this far”. A diagnosis never produces one.

Fields

format_version: u32

The shape of this state — see STATE_FORMAT_VERSION.

phase: Phase

How far the migration got.

source_path: PathBuf

The store being migrated.

source_fingerprint: String

The source’s fingerprint when the migration was prepared.

target_model: String

The model the migration is rebuilding against.

target_dimension: usize

The width that model produces.

progress: BTreeMap<String, CollectionProgress>

How far each collection’s rebuild got — exactly one entry per agent collection, always. A missing key would silently skip a collection’s rebuild; an extra one would journal work nobody will do. Both are refused by validation rather than tolerated.

embedder_witness: Option<String>

A digest of what the target embedder actually PRODUCES, not what it is called — sha256: over the vector it answers for a fixed sentinel sentence. Some exactly when the resolved regime is reembed, None under reuse, so the field also records the regime without a second field to drift from it.

This exists because MigrationState::may_resume’s model check compares NAMES, and a name is a claim: ollama pull updates a model’s weights in place under the same identifier. A run resumed across such an update would collide its replayed batch into run-one vectors and write run-two vectors after it — one store, one recorded model, two incompatible vector spaces, which is exactly what the model check says it prevents. Vectors do not lie about the embedder that made them.

Implementations

impl MigrationState

pub fn may_resume( &self, source_path: &Path, source_fingerprint: &str, target_model: &str, target_dimension: usize, ) -> Result<(), String>

Whether this state may be resumed against the source and target now in front of us.

Every refusal names both sides. A resume that silently adapted to a changed fingerprint would rebuild from a store that is no longer the one it inventoried; one that adapted to a changed model would produce a store whose vectors and whose recorded model disagree.

Errors

A message naming what changed and what the operator can do about it.

pub fn read(workspace: &Path) -> Result<Option<Self>, String>

Read a state from workspace, refusing one this build cannot act on.

The version is read out of the raw JSON BEFORE the state is deserialised, because a newer state may carry fields this build cannot parse — and “cannot parse” would otherwise surface as a corruption error instead of the version refusal it actually is.

Errors

The file is unreadable, is not JSON, or is stamped with a version newer from STATE_FORMAT_VERSION.

pub fn write( &self, workspace: &Path, lock: &MigrationLock, ) -> Result<(), String>

Atomically and durably replace the state in workspace.

The caller must hold lock. The complete JSON is written to a fixed sibling staging file, flushed and synced before one atomic promotion. The promotion is then made durable with the platform’s directory or write-through barrier. A pre-existing staging file is refused as evidence of an interrupted writer; it is never overwritten.

Errors

The lock does not guard this workspace, an existing state is invalid, staging is ambiguous, or any write/durability step fails.

Trait Implementations

impl Clone for MigrationState

fn clone(&self) -> MigrationState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MigrationState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MigrationState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MigrationState

impl PartialEq for MigrationState

fn eq(&self, other: &MigrationState) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for MigrationState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MigrationState