From 44b248bf6d9050dccec9e59c2564c27facea2340 Mon Sep 17 00:00:00 2001 From: damocles Date: Sun, 22 Nov 2026 16:59:24 +0100 Subject: [PATCH] hive-agent: drop the legacy todos/reminders db migration --- .../agent-state/persistence.md | 4 +- hive-agent/src/db_migrate.rs | 294 ------------------ hive-agent/src/main.rs | 20 +- hive-agent/src/paths.rs | 18 -- 4 files changed, 4 insertions(+), 332 deletions(-) delete mode 100644 hive-agent/src/db_migrate.rs diff --git a/docs/4-implementation/agent-state/persistence.md b/docs/4-implementation/agent-state/persistence.md index 00a5eeed7..1c0a2a35d 100644 --- a/docs/4-implementation/agent-state/persistence.md +++ b/docs/4-implementation/agent-state/persistence.md @@ -187,9 +187,7 @@ Under `/var/lib/hyperhive/agents//`: `hive-forge-notify` — upsert keyed todos here over the harness's in-agent socket, `HIVE_AGENT_SOCKET`; the harness merges them into `get_loose_ends` output and clears a row on `mark_todo_done`). - At boot, `db_migrate::run` creates this file from - `hyperhive-todos.sqlite` and `hyperhive-reminders.sqlite` when those - are present. Also backs the `mcp__hyperhive__remind` queue. + Also backs the `mcp__hyperhive__remind` queue. The harness itself is also a producer, not just the socket server: boot wiring's `spawn_todo_socket` starts `todo_server::run` (the diff --git a/hive-agent/src/db_migrate.rs b/hive-agent/src/db_migrate.rs deleted file mode 100644 index 9c8941d32..000000000 --- a/hive-agent/src/db_migrate.rs +++ /dev/null @@ -1,294 +0,0 @@ -//! One-time on-boot migration from the pre-db-consolidation per-concern -//! sqlite files (`hyperhive-todos.sqlite`, `hyperhive-reminders.sqlite`) -//! into the single consolidated `hyperhive-state.sqlite` (mara: "not yet -//! another sqlite ... add it to one of the existing ones"). Idempotent + best -//! effort: `run` is called once in `main.rs`, before anything opens the -//! consolidated db — a fresh harness boot with no legacy files (or one that -//! already migrated) is a silent no-op, and a failed step leaves its legacy -//! file in place to be retried on the next boot. -//! -//! Two legacy shapes fold in: -//! - `hyperhive-todos.sqlite` already has exactly the `todos` table the -//! consolidated db wants and nothing touches it during the rename window -//! (this runs before the todo/reminder subsystems start), so a plain -//! filesystem rename is correct and cheap — no sqlite involved. -//! - `hyperhive-reminders.sqlite`'s `reminders` table then gets copied in via -//! `ATTACH DATABASE` + `INSERT INTO ... SELECT`, preserving row ids (a -//! reminder id an agent saw in a `get_loose_ends` call just before the -//! migrating boot must still `cancel` correctly after it), and the legacy -//! file is removed once the copy lands. - -use std::path::Path; - -use anyhow::{Context, Result}; -use rusqlite::{Connection, params}; - -/// Fold the legacy `legacy_todos`/`legacy_reminders` files (if present) into -/// the single consolidated `state_db` path. The legacy todos file is only -/// renamed in while `state_db` does not exist yet; the legacy reminders file -/// is copied in whenever it is still on disk, so a copy that failed on one -/// boot is retried on the next. -/// -/// # Errors -/// -/// Propagates filesystem rename / sqlite attach-copy failures. Callers -/// treat this as best-effort (log and continue) — `Todos`/`Reminders::open` -/// against `state_db` still work standalone either way (todos would simply -/// start empty rather than inheriting the legacy rows). A failed todos -/// rename or reminders copy leaves its legacy file in place and is retried -/// on the next boot, and so is a failed `remove_file(legacy_reminders)`. -/// A retry skips rows already present with the same content, but a legacy -/// row that was copied and then cancelled or pruned from the consolidated -/// db comes back, which is the cost of retrying at all. -pub fn run(state_db: &Path, legacy_todos: &Path, legacy_reminders: &Path) -> Result<()> { - if !state_db.exists() && legacy_todos.exists() { - std::fs::rename(legacy_todos, state_db).with_context(|| { - format!( - "rename legacy todos db {} -> {}", - legacy_todos.display(), - state_db.display() - ) - })?; - } - if legacy_reminders.exists() { - // Ensure `state_db` exists and has the `reminders` schema — either - // the rename above already brought a todos-only db across (no - // `reminders` table yet), or there was no legacy todos file at all - // and this creates `state_db` fresh. - crate::reminders::Reminders::open(state_db) - .context("apply reminders schema to consolidated db")?; - migrate_reminders_rows(state_db, legacy_reminders) - .context("copy legacy reminders rows into consolidated db")?; - std::fs::remove_file(legacy_reminders).with_context(|| { - format!("remove legacy reminders db {}", legacy_reminders.display()) - })?; - } - Ok(()) -} - -/// Copy every row of the legacy `reminders` table into `state_db`'s table -/// of the same name, preserving `id`. Uses a scratch `ATTACH DATABASE` so -/// the copy is one sqlite statement rather than a row-by-row read/insert -/// loop. -fn migrate_reminders_rows(state_db: &Path, legacy_reminders: &Path) -> Result<()> { - let conn = Connection::open(state_db) - .with_context(|| format!("open consolidated db {}", state_db.display()))?; - conn.execute( - "ATTACH DATABASE ?1 AS legacy", - params![legacy_reminders.to_string_lossy()], - ) - .context("attach legacy reminders db")?; - let copied = conn - .query_row("SELECT COUNT(*) FROM main.reminders", [], |row| { - row.get::<_, i64>(0) - }) - .context("count consolidated reminders") - .and_then(|existing| { - // Ids are kept while the table is empty (the first-boot case an - // id seen just before the upgrade relies on). A retry after the - // harness already stored reminders of its own cannot reuse them: - // a colliding id would silently drop the legacy row. Those rows - // are appended under fresh ids instead, skipping any that are - // already there with the same content. - let sql = if existing == 0 { - "INSERT INTO reminders (id, message, file_path, due_at, created_at, sent_at) \ - SELECT id, message, file_path, due_at, created_at, sent_at FROM legacy.reminders;" - } else { - "INSERT INTO reminders (message, file_path, due_at, created_at, sent_at) \ - SELECT l.message, l.file_path, l.due_at, l.created_at, l.sent_at \ - FROM legacy.reminders l WHERE NOT EXISTS ( \ - SELECT 1 FROM main.reminders r WHERE r.message = l.message \ - AND r.due_at = l.due_at AND r.created_at = l.created_at \ - AND r.file_path IS l.file_path);" - }; - conn.execute_batch(sql) - .context("copy legacy reminders rows") - }); - // DETACH regardless of the copy's outcome so the connection doesn't - // leak the attachment on an early return via `?` inside this fn. - let detach = conn.execute("DETACH DATABASE legacy", []); - copied?; - detach.context("detach legacy reminders db")?; - Ok(()) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{reminders::Reminders, todos::Todos}; - - #[test] - fn no_legacy_files_is_a_noop() { - let dir = tempfile::tempdir().unwrap(); - let state = dir.path().join("hyperhive-state.sqlite"); - let todos = dir.path().join("hyperhive-todos.sqlite"); - let reminders = dir.path().join("hyperhive-reminders.sqlite"); - run(&state, &todos, &reminders).unwrap(); - assert!(!state.exists(), "nothing to migrate, nothing created"); - } - - #[test] - fn an_existing_state_db_leaves_a_legacy_todos_file_alone() { - let dir = tempfile::tempdir().unwrap(); - let state = dir.path().join("hyperhive-state.sqlite"); - let legacy_todos = dir.path().join("hyperhive-todos.sqlite"); - std::fs::write(&legacy_todos, b"should be left alone").unwrap(); - Todos::open(&state).unwrap(); - run( - &state, - &legacy_todos, - &dir.path().join("hyperhive-reminders.sqlite"), - ) - .unwrap(); - assert_eq!( - std::fs::read(&legacy_todos).unwrap(), - b"should be left alone", - "already-migrated boot must not touch a leftover legacy file" - ); - } - - #[test] - fn renames_legacy_todos_into_state_db() { - let dir = tempfile::tempdir().unwrap(); - let legacy_todos = dir.path().join("hyperhive-todos.sqlite"); - let state = dir.path().join("hyperhive-state.sqlite"); - { - let store = Todos::open(&legacy_todos).unwrap(); - store - .upsert("matrix", Some("!a:x"), "1 unread", None, false) - .unwrap(); - } - run( - &state, - &legacy_todos, - &dir.path().join("hyperhive-reminders.sqlite"), - ) - .unwrap(); - assert!(!legacy_todos.exists(), "renamed away"); - let migrated = Todos::open(&state).unwrap(); - let rows = migrated.list(None).unwrap(); - assert_eq!(rows.len(), 1); - assert_eq!(rows[0].summary, "1 unread"); - } - - #[test] - fn copies_legacy_reminders_preserving_ids() { - let dir = tempfile::tempdir().unwrap(); - let legacy_reminders = dir.path().join("hyperhive-reminders.sqlite"); - let state = dir.path().join("hyperhive-state.sqlite"); - let orig_id = { - let store = Reminders::open(&legacy_reminders).unwrap(); - store.store("check on x", None, 1000).unwrap() - }; - run( - &state, - &dir.path().join("hyperhive-todos.sqlite"), - &legacy_reminders, - ) - .unwrap(); - assert!(!legacy_reminders.exists(), "removed after copy"); - let migrated = Reminders::open(&state).unwrap(); - let pending = migrated.list_pending().unwrap(); - assert_eq!(pending.len(), 1); - assert_eq!(pending[0].id, orig_id, "id preserved across the copy"); - assert_eq!(pending[0].due_at.timestamp(), 1000); - } - - /// A copy that fails after `state_db` was created must be retried on the - /// next boot, not abandoned because the consolidated db now exists. - #[test] - fn a_failed_reminders_copy_is_retried_once_the_state_db_exists() { - let dir = tempfile::tempdir().unwrap(); - let legacy_reminders = dir.path().join("hyperhive-reminders.sqlite"); - let state = dir.path().join("hyperhive-state.sqlite"); - let legacy_todos = dir.path().join("hyperhive-todos.sqlite"); - std::fs::write(&legacy_reminders, b"not a sqlite file").unwrap(); - - run(&state, &legacy_todos, &legacy_reminders).unwrap_err(); - assert!(state.exists(), "the failed copy still created the db"); - assert!(legacy_reminders.exists(), "legacy file kept for a retry"); - - std::fs::remove_file(&legacy_reminders).unwrap(); - Reminders::open(&legacy_reminders) - .unwrap() - .store("ping", None, 500) - .unwrap(); - run(&state, &legacy_todos, &legacy_reminders).unwrap(); - - assert!(!legacy_reminders.exists(), "removed after the retry"); - assert_eq!( - Reminders::open(&state) - .unwrap() - .list_pending() - .unwrap() - .len(), - 1 - ); - } - - /// The harness boots after a failed copy and stores reminders of its own, - /// so their ids overlap the legacy ones. The retry must keep both sets. - #[test] - fn a_retry_keeps_legacy_reminders_whose_ids_collide_with_new_ones() { - let dir = tempfile::tempdir().unwrap(); - let legacy_reminders = dir.path().join("hyperhive-reminders.sqlite"); - let state = dir.path().join("hyperhive-state.sqlite"); - let legacy_todos = dir.path().join("hyperhive-todos.sqlite"); - std::fs::write(&legacy_reminders, b"not a sqlite file").unwrap(); - run(&state, &legacy_todos, &legacy_reminders).unwrap_err(); - Reminders::open(&state) - .unwrap() - .store("new while degraded", None, 900) - .unwrap(); - - std::fs::remove_file(&legacy_reminders).unwrap(); - { - let legacy = Reminders::open(&legacy_reminders).unwrap(); - legacy.store("legacy one", None, 100).unwrap(); - legacy.store("legacy two", None, 200).unwrap(); - } - run(&state, &legacy_todos, &legacy_reminders).unwrap(); - - let messages: Vec = Reminders::open(&state) - .unwrap() - .list_pending() - .unwrap() - .into_iter() - .map(|r| r.message) - .collect(); - assert_eq!(messages.len(), 3, "got {messages:?}"); - for expected in ["new while degraded", "legacy one", "legacy two"] { - assert!(messages.iter().any(|m| m == expected), "missing {expected}"); - } - } - - #[test] - fn folds_both_legacy_files_into_one_consolidated_db() { - let dir = tempfile::tempdir().unwrap(); - let legacy_todos = dir.path().join("hyperhive-todos.sqlite"); - let legacy_reminders = dir.path().join("hyperhive-reminders.sqlite"); - let state = dir.path().join("hyperhive-state.sqlite"); - { - Todos::open(&legacy_todos) - .unwrap() - .upsert("bash", None, "task done", None, false) - .unwrap(); - Reminders::open(&legacy_reminders) - .unwrap() - .store("ping", None, 500) - .unwrap(); - } - run(&state, &legacy_todos, &legacy_reminders).unwrap(); - assert!(!legacy_todos.exists()); - assert!(!legacy_reminders.exists()); - assert_eq!(Todos::open(&state).unwrap().list(None).unwrap().len(), 1); - assert_eq!( - Reminders::open(&state) - .unwrap() - .list_pending() - .unwrap() - .len(), - 1 - ); - } -} diff --git a/hive-agent/src/main.rs b/hive-agent/src/main.rs index 367f537db..efc4a7a7a 100644 --- a/hive-agent/src/main.rs +++ b/hive-agent/src/main.rs @@ -14,7 +14,6 @@ mod boot_announce; mod claude_credentials; mod claude_md_watch; mod claude_usage_watch; -mod db_migrate; mod disk_watch; mod events; mod harness_state; @@ -561,26 +560,13 @@ async fn serve_main(socket: &Path, poll_ms: u64) -> Result<()> { }); // Before the first turn, so claude's own auto-load finds `AGENTS.md`. agents_md_migrate::run(&paths::state_dir()); + // Messages made inside this container rather than by the broker: + // reminders and the swarm UI's operator input. + let (local_msg_tx, local_msg_rx) = tokio::sync::mpsc::unbounded_channel(); // Harness-local reminders fire into an mpsc channel the serve loop races // against the broker long-poll (see `reminder_timer`). Best-effort: it // parks forever instead of closing the channel when the store can't open. // Opened before the todo socket, which shares the same `Arc`. - // Fold the pre-consolidation per-concern db files into the single - // `hyperhive-state.sqlite`, if this is the first boot since the - // upgrade — see `db_migrate` module docs. Best-effort: a failure here - // just leaves the legacy file(s) in place to retry next boot, so the - // subsystems below still start (`Todos`/`Reminders::open` create the - // schema fresh if nothing migrated across). - if let Err(e) = db_migrate::run( - &paths::state_db(), - &paths::legacy_todos_db(), - &paths::legacy_reminders_db(), - ) { - tracing::warn!(error = ?e, "legacy db_migrate failed — continuing with fresh/partial state db"); - } - // Messages made inside this container rather than by the broker: - // reminders and the swarm UI's operator input. - let (local_msg_tx, local_msg_rx) = tokio::sync::mpsc::unbounded_channel(); let reminder_store = open_reminders(); let (todo_wake, todos_store) = start_local_inputs(reminder_store, local_msg_tx, &bus, &interrupted); diff --git a/hive-agent/src/paths.rs b/hive-agent/src/paths.rs index 28f8e18b0..ca9fd83ee 100644 --- a/hive-agent/src/paths.rs +++ b/hive-agent/src/paths.rs @@ -50,29 +50,11 @@ pub fn harness_dir() -> PathBuf { /// here from the now-removed ask/answer mechanism — nothing opens or /// writes it, and any rows in it are harmless leftovers, not a store to /// migrate or clean up. -/// -/// A one-time boot migration (`db_migrate::run`) folds the older -/// `hyperhive-todos.sqlite` / `hyperhive-reminders.sqlite` files into this -/// path on first boot after an upgrade. #[must_use] pub fn state_db() -> PathBuf { harness_dir().join("hyperhive-state.sqlite") } -/// Legacy pre-consolidation todos db path, consulted only by -/// [`crate::db_migrate`] on the first boot after the upgrade. -#[must_use] -pub fn legacy_todos_db() -> PathBuf { - harness_dir().join("hyperhive-todos.sqlite") -} - -/// Legacy pre-consolidation reminders db path, consulted only by -/// [`crate::db_migrate`] on the first boot after the upgrade. -#[must_use] -pub fn legacy_reminders_db() -> PathBuf { - harness_dir().join("hyperhive-reminders.sqlite") -} - /// Per-turn config dir for the regenerated claude-{mcp-config,settings, /// system-prompt} files the harness drops before each turn. Set by /// systemd via `RuntimeDirectory = "hive-config"`: a per-service runtime