Function migrate

src/db/migrations.rs:287–332

Runs all pending migrations up to `LATEST_VERSION`. Acquires an EXCLUSIVE transaction to prevent concurrent writers from interleaving schema changes. Each migration is applied and the version is bumped inside the same transaction. Returns `true` if any migrations were applied, `false` if already up-to-date.

(conn: &Connection)

/// is bumped inside the same transaction.
/// Returns `true` if any migrations were applied, `false` if already up-to-date.
pub async fn migrate(conn: &Connection) -> Result<bool> {
    let current = get_version(conn).await?;
    debug_assert!(
        current <= LATEST_VERSION,
        "database version {current} is ahead of code version {LATEST_VERSION}"
    );
    if current >= LATEST_VERSION {
        enable_incremental_auto_vacuum(conn, "migrate", true).await?;
        return Ok(false);
    }

    eprintln!("[tracedecay] migrating database schema v{current} → v{LATEST_VERSION}…");

    // BEGIN EXCLUSIVE blocks other writers (including other MCP servers or
    // post-commit hooks) until we COMMIT. Readers using WAL mode are not
    // blocked.
    conn.execute("BEGIN EXCLUSIVE", ())
        .await
        .map_err(|e| TraceDecayError::Database {
            message: format!("failed to acquire exclusive lock: {e}"),
            operation: "migrate".to_string(),
        })?;

    // Re-read inside the lock in case another process migrated between our
    // check and the lock acquisition.
    let current = get_version(conn).await?;

    let result = run_migrations(conn, current).await;

    match result {
        Ok(()) => {
            conn.execute("COMMIT", ())
                .await
                .map_err(|e| TraceDecayError::Database {
                    message: format!("failed to commit migrations: {e}"),
                    operation: "migrate".to_string(),
                })?;
            enable_incremental_auto_vacuum(conn, "migrate", true).await?;
            Ok(true)
        }
        Err(e) => {
            let _ = conn.execute("ROLLBACK", ()).await;
            Err(e)
        }
    }
}

/// Applies migrations sequentially from `current` up to `LATEST_VERSION`.
async fn run_migrations(conn: &Connection, current: u32) -> Result<()> {