Function update_memory_status

packages/dashboard/src-tauri/src/db.rs:3245–3313

(
    conn: &mut Connection,
    memory_id: i64,
    new_status: &str,
)

}

pub fn update_memory_status(
    conn: &mut Connection,
    memory_id: i64,
    new_status: &str,
) -> Result<(), rusqlite::Error> {
    // Reject any status outside the canonical set before touching the DB. A
    // malformed call setting status="archive" (vs "archived") or any free string
    // would make the memory vanish from active/permanent/archived logic with no
    // valid epoch/delta interpretation.
    if !matches!(new_status, "active" | "permanent" | "archived") {
        return Err(rusqlite::Error::SqliteFailure(
            rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_CONSTRAINT),
            Some(format!(
                "Invalid memory status '{new_status}' (expected active, permanent, or archived)."
            )),
        ));
    }
    // Phase A: resolve the target row before opening a write transaction.
    let target = lookup_memory_mutation_target(conn, memory_id)?;
    // Any transition that CHANGES which memories enter or how they rank in the
    // m[0] baseline must bump the epoch to invalidate cached m[0]. That covers
    // every status change into an injectable status (`active`/`permanent`) from a
    // different status — including archived->active/permanent (restore) AND
    // active<->permanent (pin/unpin), since memory selection is permanent-first
    // under budget pressure, so pinning reorders the rendered set. Gating only on
    // archived-origin left active<->permanent invalidating nothing.
    let prior_status = target.status.as_deref();
    let into_injectable = new_status == "active" || new_status == "permanent";
    let needs_epoch_bump = into_injectable && prior_status != Some(new_status);
    let project_identity = if needs_epoch_bump {
        Some(normalize_stored_project_path(&target.project_path))
    } else {
        None
    };
    let is_archive = new_status == "archived" && prior_status != Some("archived");

    // Phase B: re-check the target row, mutate, and queue/bump in one tx.
    let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
    verify_memory_project_path_unchanged(&tx, memory_id, &target.project_path)?;
    tx.execute(
        "UPDATE memories SET status = ?1, updated_at = ?2 WHERE id = ?3",
        params![new_status, now_millis(), memory_id],
    )?;
    // Resolve workspace fan-out INSIDE the write transaction so a concurrent
    // add-member committing between Phase A and here can't leave a new member's
    // epoch un-bumped (it would then miss this restored memory).
    let epoch_bump_identities = if let Some(ref id) = project_identity {
        Some(crate::workspaces::workspace_member_identities_for_project(
            &tx, id,
        )?)
    } else {
        None
    };
    if let Some(identities) = epoch_bump_identities.as_ref() {
        crate::workspaces::bump_epochs_for_identities(&tx, identities)?;
    } else if is_archive {
        queue_memory_mutation(
            &tx,