YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
fix(storage): recover interrupted Windows migration retries (#7808)
Ezra Ellettebf4a25f752de
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/health.rs b/apps/screenpipe-app-tauri/src-tauri/src/health.rsindex 89cd554bc..4e73e2d51 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/health.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/health.rs@@ -1110,7 +1110,7 @@ fn respawn_engine_if_crashed(warn!("embedded engine unreachable for {} checks while recording should be ON \- — auto-respawning ({} attempts in the last {}s)",+ — requesting recording recovery ({} requests in the last {}s)",consecutive_failures,server_respawns.len(),SERVER_RESPAWN_WINDOW.as_secs()diff --git a/apps/screenpipe-app-tauri/src-tauri/src/recording.rs b/apps/screenpipe-app-tauri/src-tauri/src/recording.rsindex 47e3191e2..1683d6f2f 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/recording.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/recording.rs@@ -1197,7 +1197,9 @@ pub async fn retry_screenpipe(.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();- let Some(_lifecycle_guard) = retry::admit(+ let data_dir = crate::db_relaunch::active_data_dir();+ let Some(_lifecycle_guard) = retry::admit_logged(+ &data_dir,&state.server_lifecycle,&state.wants_recording,&crate::process_exit::QUIT_REQUESTED,@@ -1207,7 +1209,7 @@ pub async fn retry_screenpipe(return Ok(());};retry::run(- &crate::db_relaunch::active_data_dir(),+ &data_dir,&state.wants_recording,spawn_screenpipe_inner(&state, app),)diff --git a/apps/screenpipe-app-tauri/src-tauri/src/recording/retry.rs b/apps/screenpipe-app-tauri/src-tauri/src/recording/retry.rsindex dd267f1c8..84d1dea48 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/recording/retry.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/recording/retry.rs@@ -39,16 +39,41 @@ pub(super) fn admit<'a>(quit_requested: &AtomicBool,last_spawn: &AtomicU64,now: u64,-) -> Option<MutexGuard<'a, ()>> {- let guard = lifecycle.try_lock().ok()?;- if !wants_recording.load(Ordering::SeqCst) || quit_requested.load(Ordering::SeqCst) {- return None;+) -> Result<MutexGuard<'a, ()>, &'static str> {+ let guard = lifecycle+ .try_lock()+ .map_err(|_| "recording lifecycle is busy")?;+ if !wants_recording.load(Ordering::SeqCst) {+ return Err("recording is not intended");+ }+ if quit_requested.load(Ordering::SeqCst) {+ return Err("application quit was requested");}let last = last_spawn.load(Ordering::SeqCst);if last > 0 && now.saturating_sub(last) < super::RESTART_COOLDOWN_SECS {- return None;+ return Err("recording restart cooldown is active");+ }+ Ok(guard)+}++/// A watchdog request is not an admitted restart. Keep skipped requests in+/// the same support evidence as startup failures so repeated scheduling cannot+/// conceal a held lifecycle or a cancelled recording intent.+pub(super) fn admit_logged<'a>(+ data_dir: &std::path::Path,+ lifecycle: &'a Mutex<()>,+ wants_recording: &AtomicBool,+ quit_requested: &AtomicBool,+ last_spawn: &AtomicU64,+ now: u64,+) -> Option<MutexGuard<'a, ()>> {+ match admit(lifecycle, wants_recording, quit_requested, last_spawn, now) {+ Ok(guard) => Some(guard),+ Err(reason) => {+ super::recovery_log::append(data_dir, "retry_skipped", reason);+ None+ }}- Some(guard)}/// A pause may complete after retry admission but before a healthy server's@@ -70,11 +95,25 @@ mod tests {let dir = tempfile::tempdir().unwrap();let intent = AtomicBool::new(true);let failure = run(dir.path(), &intent, async {- // Exercise a real startup prerequisite failure, retaining its OS- // cause rather than replacing it with a generic retry error.- std::fs::read(dir.path().join("missing-config"))- .map(|_| ())- .map_err(|error| format!("recording configuration unavailable: {error}"))+ // Exercise DatabaseManager's actual failed-open path and the same+ // native cause formatter used by ServerCore during recovery.+ let parent = dir.path().join("blocked-startup");+ std::fs::write(&parent, b"not a directory").unwrap();+ match screenpipe_db::DatabaseManager::new(+ parent.join("db.sqlite").to_str().unwrap(),+ Default::default(),+ )+ .await+ {+ Ok(db) => {+ db.close().await;+ panic!("startup cannot open a database below a regular file")+ }+ Err(error) => Err(format!(+ "operation=database_manager_init; {}",+ screenpipe_db::database_error_diagnostic(&error)+ )),+ }}).await.unwrap_err();@@ -104,6 +143,7 @@ mod tests {assert!(report.contains("retry_started: recording recovery admitted"));assert!(report.contains("retry_failed: startup failed; capture_intended=true"));assert!(report.contains(&failure));+ assert!(report.contains("operation=database_manager_init; sqlite_code="));assert!(report.contains("retry_completed: startup command completed; capture_intended=false"));@@ -111,6 +151,80 @@ mod tests {assert!(!intent.load(Ordering::SeqCst));}+ #[tokio::test]+ async fn skipped_recovery_reaches_support_and_records_after_lifecycle_release() {+ let dir = tempfile::tempdir().unwrap();+ let lifecycle = Mutex::new(());+ let intent = AtomicBool::new(true);+ let quit = AtomicBool::new(false);+ let last_spawn = AtomicU64::new(0);+ let held = lifecycle.lock().await;+ assert!(admit_logged(dir.path(), &lifecycle, &intent, &quit, &last_spawn, 100).is_none());+ assert!(intent.load(Ordering::SeqCst));+ drop(held);++ let admitted = admit_logged(dir.path(), &lifecycle, &intent, &quit, &last_spawn, 100)+ .expect("a released lifecycle must admit the next recovery");+ let path = dir.path().join("db.sqlite");+ run(dir.path(), &intent, async {+ let db = screenpipe_db::DatabaseManager::new(path.to_str().unwrap(), Default::default())+ .await+ .map_err(|error| error.to_string())?;+ let result = db.execute_raw_sql_write(+ "INSERT INTO frames(id,timestamp,full_text) VALUES(1,'2026-10-28T12:00:00Z','recorded after lifecycle release')",+ ).await.map_err(|error| error.to_string());+ db.close().await;+ result.map(|_| ())+ })+ .await+ .unwrap();+ drop(admitted);++ // A later pause must still suppress recovery rather than publish intent.+ intent.store(false, Ordering::SeqCst);+ assert!(admit_logged(dir.path(), &lifecycle, &intent, &quit, &last_spawn, 100).is_none());+ intent.store(true, Ordering::SeqCst);+ quit.store(true, Ordering::SeqCst);+ assert!(admit_logged(dir.path(), &lifecycle, &intent, &quit, &last_spawn, 100).is_none());+ quit.store(false, Ordering::SeqCst);+ last_spawn.store(100, Ordering::SeqCst);+ assert!(admit_logged(dir.path(), &lifecycle, &intent, &quit, &last_spawn, 100).is_none());+ intent.store(false, Ordering::SeqCst);+ for day in 1..=7 {+ std::fs::write(+ dir.path()+ .join(format!("screenpipe-app.2026-10-{day:02}.log")),+ "app restarted; [email protected]\n",+ )+ .unwrap();+ }+ let report =+ crate::diagnostic_logs::collect_redacted_from_dirs(&[dir.path().to_path_buf()])+ .await+ .unwrap();+ assert!(report.contains("retry_skipped: recording lifecycle is busy"));+ assert!(report.contains("retry_skipped: recording is not intended"));+ assert!(report.contains("retry_skipped: application quit was requested"));+ assert!(report.contains("retry_skipped: recording restart cooldown is active"));+ assert!(report.contains("retry_started: recording recovery admitted"));+ assert!(+ report.contains("retry_completed: startup command completed; capture_intended=true")+ );+ assert!(!report.contains("[email protected]"));+ assert!(!intent.load(Ordering::SeqCst));++ let reopened =+ screenpipe_db::DatabaseManager::new(path.to_str().unwrap(), Default::default())+ .await+ .unwrap();+ let rows = reopened+ .query_raw_sql("SELECT full_text FROM frames WHERE id=1")+ .await+ .unwrap();+ assert_eq!(rows[0]["full_text"], "recorded after lifecycle release");+ reopened.close().await;+ }+#[test]fn pause_after_a_webview_observed_recording_cancels_native_retry() {let lifecycle = Mutex::new(());@@ -124,7 +238,7 @@ mod tests {&AtomicU64::new(0),100)- .is_none());+ .is_err());assert!(!intent.load(Ordering::SeqCst));assert!(lifecycle.try_lock().is_ok());}@@ -136,12 +250,12 @@ mod tests {let quit = AtomicBool::new(false);let last = AtomicU64::new(0);let first = admit(&lifecycle, &intent, &quit, &last, 100).unwrap();- assert!(admit(&lifecycle, &intent, &quit, &last, 100).is_none());+ assert!(admit(&lifecycle, &intent, &quit, &last, 100).is_err());// Successful startup sets the shared cooldown before releasing the slot.last.store(100, Ordering::SeqCst);drop(first);- assert!(admit(&lifecycle, &intent, &quit, &last, 100).is_none());- assert!(admit(&lifecycle, &intent, &quit, &last, 130).is_some());+ assert!(admit(&lifecycle, &intent, &quit, &last, 100).is_err());+ assert!(admit(&lifecycle, &intent, &quit, &last, 130).is_ok());}#[test]@@ -156,7 +270,7 @@ mod tests {&AtomicU64::new(0),100)- .is_none());+ .is_err());intent.store(false, Ordering::SeqCst);drop(guard);assert!(admit(@@ -166,7 +280,7 @@ mod tests {&AtomicU64::new(0),100)- .is_none());+ .is_err());}#[test]@@ -179,7 +293,7 @@ mod tests {&AtomicU64::new(0),100)- .is_none());+ .is_err());assert!(lifecycle.try_lock().is_ok());}@@ -190,9 +304,9 @@ mod tests {let quit = AtomicBool::new(false);let last = AtomicU64::new(100);for now in [99, 100, 129] {- assert!(admit(&lifecycle, &intent, &quit, &last, now).is_none());+ assert!(admit(&lifecycle, &intent, &quit, &last, now).is_err());}- assert!(admit(&lifecycle, &intent, &quit, &last, 130).is_some());+ assert!(admit(&lifecycle, &intent, &quit, &last, 130).is_ok());}#[test]diff --git a/apps/screenpipe-app-tauri/src-tauri/src/server_core.rs b/apps/screenpipe-app-tauri/src-tauri/src/server_core.rsindex 471beb239..0adf82294 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/server_core.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/server_core.rs@@ -445,7 +445,7 @@ impl ServerCore {// immediately — retrying would just delay the user-visible error.const DB_LOCK_RETRY_DELAYS_SECS: &[u64] = &[0, 2, 5];let db = {- let mut last_err: Option<String> = None;+ let mut first_err: Option<String> = None;let mut built = None;for (attempt_idx, delay) in DB_LOCK_RETRY_DELAYS_SECS.iter().enumerate() {if *delay > 0 {@@ -463,7 +463,10 @@ impl ServerCore {break;}Err(e) => {- let s = e.to_string();+ let s = format!(+ "operation=database_manager_init; {}",+ screenpipe_db::database_error_diagnostic(&e)+ );let is_lock =s.contains("database is locked") || s.contains("database is busy");if is_lock && attempt_idx + 1 < DB_LOCK_RETRY_DELAYS_SECS.len() {@@ -474,21 +477,20 @@ impl ServerCore {DB_LOCK_RETRY_DELAYS_SECS.len(),e);- last_err = Some(s);+ first_err.get_or_insert(s);continue;}// Final failure — either non-lock error or exhausted retrieslet msg = if is_lock {format!(- "Database is locked by another process (likely Spotlight, \- Time Machine, antivirus, or iCloud/OneDrive sync). After \- {} attempts the lock did not clear. Close backup/sync tools \- and relaunch. Underlying error: {}",+ "Database remained busy after {} startup attempts. The lock \+ owner is unknown; recording recovery will retry. First \+ retained failure: {}",DB_LOCK_RETRY_DELAYS_SECS.len(),- e+ first_err.as_deref().unwrap_or(&s))} else {- format!("Failed to initialize database: {}", e)+ format!("Failed to initialize database: {s}")};crate::health::set_boot_error(&msg);return Err(msg);@@ -501,7 +503,7 @@ impl ServerCore {// All attempts returned lock errors and we exhausted the loop.// The branch above handles the last-attempt case, but defensively// handle the case where the loop exited without a match.- let e = last_err.unwrap_or_else(|| "unknown error".to_string());+ let e = first_err.unwrap_or_else(|| "unknown error".to_string());let msg = format!("Database is locked — exhausted all {} retry attempts. {}",DB_LOCK_RETRY_DELAYS_SECS.len(),diff --git a/crates/screenpipe-db/src/bin/screenpipe-storage.rs b/crates/screenpipe-db/src/bin/screenpipe-storage.rsindex b3d1ef664..7d61f2d19 100644--- a/crates/screenpipe-db/src/bin/screenpipe-storage.rs+++ b/crates/screenpipe-db/src/bin/screenpipe-storage.rs@@ -16,8 +16,13 @@ async fn main() -> anyhow::Result<()> {if args.next().is_some() {anyhow::bail!("unexpected storage command argument");}- let result =- screenpipe_db::storage::run_command(&command, &root, destination.as_deref()).await?;+ // Poll the storage command on the runtime worker stack rather than the+ // comparatively small Windows main-thread stack. Migration fault tests+ // exercise its deepest path and must reach the injected process exit.+ let result = tokio::spawn(async move {+ screenpipe_db::storage::run_command(&command, &root, destination.as_deref()).await+ })+ .await??;println!("{}", serde_json::to_string(&result)?);Ok(())}diff --git a/crates/screenpipe-db/src/lib.rs b/crates/screenpipe-db/src/lib.rsindex e3002e9a2..03131ea7f 100644--- a/crates/screenpipe-db/src/lib.rs+++ b/crates/screenpipe-db/src/lib.rs@@ -60,6 +60,7 @@ pub use recovery::{verify_fresh_sqlite_recovery_candidate, DatabaseHealthError, QuarantineHealthProbe,RecoveryVerification,};+pub use sqlite_error::database_error_diagnostic;/// Retry database availability without exhausting a permanent failure budget.pub const SQLITE_ACCESS_RETRY_DELAY: std::time::Duration = std::time::Duration::from_secs(60);diff --git a/crates/screenpipe-db/src/sqlite_error.rs b/crates/screenpipe-db/src/sqlite_error.rsindex 3233fca70..5c57d6823 100644--- a/crates/screenpipe-db/src/sqlite_error.rs+++ b/crates/screenpipe-db/src/sqlite_error.rs@@ -6,6 +6,25 @@ pub(crate) fn is_sqlite_hard_fault_code(code: i32) -> bool {screenpipe_sqlite_coordinator::is_sqlite_hard_fault_code(code)}+/// Bounded native cause metadata for ordinary support evidence. SQLite does+/// not always expose the underlying filesystem status; retain the extended+/// SQLite code and the OS code independently whenever either is available.+pub fn database_error_diagnostic(error: &sqlx::Error) -> String {+ let sqlite_code = match error {+ sqlx::Error::Database(database) => database.code().map(|code| code.into_owned()),+ _ => None,+ };+ let os_code = match error {+ sqlx::Error::Io(io) => io.raw_os_error(),+ _ => None,+ };+ format!(+ "sqlite_code={}; os_code={}; cause={error}",+ sqlite_code.as_deref().unwrap_or("unavailable"),+ os_code.map_or_else(|| "unavailable".to_owned(), |code| code.to_string())+ )+}+/// Exact extended SQLite result code when available. Keeping 522 instead of/// collapsing it to primary code 10 makes the process-wide quarantine useful/// for incident diagnosis while retaining message fallbacks for wrapped errors.@@ -76,6 +95,41 @@ pub(crate) fn is_sqlite_busy_error(e: &sqlx::Error) -> bool {mod tests {use super::*;+ #[test]+ fn native_open_failure_retains_available_os_code() {+ let root = tempfile::tempdir().unwrap();+ let missing = root.path().join("missing").join("db.sqlite");+ let io = std::fs::File::open(missing).unwrap_err();+ let expected = io+ .raw_os_error()+ .expect("native open failure has an OS code");+ let detail = database_error_diagnostic(&sqlx::Error::Io(io));+ assert!(detail.contains(&format!("os_code={expected}")));+ assert!(detail.contains("sqlite_code=unavailable"));+ assert!(detail.contains("cause="));+ }++ #[tokio::test]+ async fn native_sqlite_open_failure_retains_result_code() {+ use sqlx::Connection;++ let root = tempfile::tempdir().unwrap();+ let error = sqlx::SqliteConnection::connect_with(+ &sqlx::sqlite::SqliteConnectOptions::new()+ .filename(root.path())+ .create_if_missing(false),+ )+ .await+ .unwrap_err();+ let expected = match &error {+ sqlx::Error::Database(database) => database.code().unwrap().into_owned(),+ other => panic!("expected a native SQLite open failure, got {other}"),+ };+ let detail = database_error_diagnostic(&error);+ assert!(detail.contains(&format!("sqlite_code={expected}")));+ assert!(detail.contains("cause="));+ }+#[test]fn fatal_message_recognizes_ioerr_and_corruption() {assert!(is_fatal_sqlite_message("disk i/o error"));diff --git a/crates/screenpipe-db/src/storage/lifecycle.rs b/crates/screenpipe-db/src/storage/lifecycle.rsindex a6bb8aae6..3bab6e72c 100644--- a/crates/screenpipe-db/src/storage/lifecycle.rs+++ b/crates/screenpipe-db/src/storage/lifecycle.rs@@ -931,6 +931,30 @@ async fn migrate_observed(super::diagnostics::stage("closing_retry_history");db.close().await;let (receipts, searches) = refreshed?;+ if path == source_path {+ // A recovered recording generation has written a fresh WAL. Prove+ // that no reader still owns it and copy every committed page back+ // before the source is snapshotted and renamed. On Windows the WAL+ // otherwise survives long enough for the safety check below to+ // reject every explicit conversion retry.+ let mut exclusive = sqlx::SqliteConnection::connect_with(+ &sqlx::sqlite::SqliteConnectOptions::new()+ .filename(&source_path)+ .create_if_missing(false)+ .pragma("locking_mode", "EXCLUSIVE")+ .busy_timeout(std::time::Duration::from_secs(5)),+ )+ .await?;+ let check = async {+ sqlx::raw_sql("BEGIN EXCLUSIVE; COMMIT;")+ .execute(&mut exclusive)+ .await?;+ super::schema::construction_checkpoint(&mut exclusive).await+ }+ .await;+ exclusive.close().await?;+ check?;+ }journal.source = receipts;super::diagnostics::tables(&journal.source);journal.search_receipts = searches;diff --git a/docs/COVERAGE.md b/docs/COVERAGE.mdindex 106b148c8..f47417827 100644--- a/docs/COVERAGE.md+++ b/docs/COVERAGE.md@@ -38,15 +38,15 @@ results and `cargo llvm-cov` data on top when judging release confidence.- Mapped suites: 37- Mapped Rust files: 402-- Active test blocks: 3929+- Active test blocks: 3931- Ignored/manual test blocks: 188-- Weighted coverage points: 3236.6+- Weighted coverage points: 3238.0| Platform | Suites | Active tests | Ignored tests | Weighted points | Layers | Flows | Critical score || --- | --- | --- | --- | --- | --- | --- | --- |-| windows | 33 | 3766 | 170 | 3163.6 | 21 | 11 | 100% |-| macos | 32 | 3809 | 149 | 3158.9 | 22 | 11 | 100% |-| linux | 29 | 3344 | 145 | 2781.9 | 20 | 11 | 100% |+| windows | 33 | 3768 | 170 | 3165.0 | 21 | 11 | 100% |+| macos | 32 | 3811 | 149 | 3160.3 | 22 | 11 | 100% |+| linux | 29 | 3346 | 145 | 2783.3 | 20 | 11 | 100% |## Refreshdiff --git a/docs/coverage/CORE.md b/docs/coverage/CORE.mdindex 250581a57..85facdcb2 100644--- a/docs/coverage/CORE.md+++ b/docs/coverage/CORE.md@@ -9,10 +9,10 @@ confidence, and criticality.- Tracked crates: screenpipe-engine, screenpipe-db, screenpipe-sqlite-coordinator, screenpipe-audio, screenpipe-screen, screenpipe-a11y, screenpipe-fs- Mapped suites: 37- Mapped Rust files: 402-- Active test blocks: 3929+- Active test blocks: 3931- Ignored/manual test blocks: 188-- Declared test blocks: 4117-- Weighted coverage points: 3236.6+- Declared test blocks: 4119+- Weighted coverage points: 3238.0Confidence weights: strong=1.0, partial=0.7, conditional=0.4, smoke=0.3.Criticality weights: high=1.0, medium=0.7, low=0.4.@@ -23,16 +23,16 @@ are explicitly enabled in a runtime lane.| Platform | Suites | Active tests | Ignored tests | Weighted points | Layers | Flows | Critical score || --- | --- | --- | --- | --- | --- | --- | --- |-| windows | 33 | 3766 | 170 | 3163.6 | 21 | 11 | 100% |-| macos | 32 | 3809 | 149 | 3158.9 | 22 | 11 | 100% |-| linux | 29 | 3344 | 145 | 2781.9 | 20 | 11 | 100% |+| windows | 33 | 3768 | 170 | 3165.0 | 21 | 11 | 100% |+| macos | 32 | 3811 | 149 | 3160.3 | 22 | 11 | 100% |+| linux | 29 | 3346 | 145 | 2783.3 | 20 | 11 | 100% |## Crate Summary| Crate | Suites | Integration files | Source unit files | Active tests | Ignored tests | Weighted points | Flows || --- | --- | --- | --- | --- | --- | --- | --- || screenpipe-engine | 12 | 22 | 131 | 1876 | 53 | 1443.9 | 10 |-| screenpipe-db | 5 | 69 | 29 | 638 | 32 | 607.8 | 9 |+| screenpipe-db | 5 | 69 | 29 | 640 | 32 | 609.2 | 9 || screenpipe-sqlite-coordinator | 1 | 0 | 3 | 27 | 0 | 27.0 | 2 || screenpipe-audio | 8 | 29 | 54 | 706 | 56 | 617.0 | 5 || screenpipe-screen | 6 | 9 | 19 | 278 | 9 | 246.4 | 4 |@@ -66,14 +66,14 @@ bun run coverage:core -- --llvm-cov-summary ../../docs/coverage/core-llvm-cov-su| audio | 10 suites / 844 active / 60 ignored / 755.0 pts | 9 suites / 838 active / 60 ignored / 750.8 pts | 8 suites / 759 active / 59 ignored / 695.5 pts || audio-device | 2 suites / 243 active / 10 ignored / 219.3 pts | 2 suites / 243 active / 10 ignored / 219.3 pts | 1 suites / 164 active / 9 ignored / 164.0 pts || configuration | 2 suites / 153 active / 3 ignored / 138.7 pts | 2 suites / 153 active / 3 ignored / 138.7 pts | 2 suites / 153 active / 3 ignored / 138.7 pts |-| database | 7 suites / 594 active / 28 ignored / 563.8 pts | 7 suites / 594 active / 28 ignored / 563.8 pts | 7 suites / 594 active / 28 ignored / 563.8 pts |+| database | 7 suites / 596 active / 28 ignored / 565.2 pts | 7 suites / 596 active / 28 ignored / 565.2 pts | 7 suites / 596 active / 28 ignored / 565.2 pts || db-search | 2 suites / 120 active / 9 ignored / 120.0 pts | 2 suites / 120 active / 9 ignored / 120.0 pts | 2 suites / 120 active / 9 ignored / 120.0 pts || engine-lifecycle | 6 suites / 274 active / 1 ignored / 244.8 pts | 6 suites / 274 active / 1 ignored / 244.8 pts | 6 suites / 270 active / 9 ignored / 243.9 pts || local-api | 3 suites / 491 active / 12 ignored / 347.6 pts | 3 suites / 491 active / 12 ignored / 347.6 pts | 3 suites / 491 active / 12 ignored / 347.6 pts || meeting | 6 suites / 1762 active / 32 ignored / 1440.7 pts | 6 suites / 1762 active / 32 ignored / 1440.7 pts | 4 suites / 1408 active / 28 ignored / 1110.4 pts || ocr | 4 suites / 141 active / 7 ignored / 130.8 pts | 4 suites / 134 active / 7 ignored / 128.6 pts | 3 suites / 125 active / 6 ignored / 119.6 pts || os-integration | 1 suites / 6 active / 0 ignored / 1.7 pts | 1 suites / 6 active / 0 ignored / 1.7 pts | - |-| performance | 13 suites / 1710 active / 86 ignored / 1509.8 pts | 14 suites / 1835 active / 94 ignored / 1559.8 pts | 13 suites / 1710 active / 86 ignored / 1509.8 pts |+| performance | 13 suites / 1712 active / 86 ignored / 1511.2 pts | 14 suites / 1837 active / 94 ignored / 1561.2 pts | 13 suites / 1712 active / 86 ignored / 1511.2 pts || pipes | 1 suites / 554 active / 3 ignored / 387.8 pts | 1 suites / 554 active / 3 ignored / 387.8 pts | 1 suites / 554 active / 3 ignored / 387.8 pts || privacy | 5 suites / 1016 active / 42 ignored / 818.9 pts | 5 suites / 1072 active / 21 ignored / 820.6 pts | 5 suites / 974 active / 14 ignored / 783.8 pts || real-app | - | 1 suites / 125 active / 8 ignored / 50.0 pts | - |@@ -133,7 +133,7 @@ bun run coverage:core -- --llvm-cov-summary ../../docs/coverage/core-llvm-cov-su| audio-windows-parakeet-provider | screenpipe-audio | windows | audio, transcription | audio-record-transcribe | high | partial | unit | 1 | 6 | 0 | Registers existing CPU override, eligible adapter selection, DXGI ordinal, error fallback and adapter determinism tests. Windows-only; manifest registration does not verify execution on physical GPU hardware. || db-accessibility-ui-events | screenpipe-db | windows, macos, linux | database, configuration, accessibility, ui-events, performance | settings-to-engine-config, accessibility-ui-events, performance-liveness | medium | partial | integration | 7 | 28 | 2 | Elements bulk insert, on-screen filtering, UI event batching, DB tier config, and ignored heavy-read real-DB probes. || db-audio-meetings-speakers | screenpipe-db | windows, macos, linux | database, audio, meeting, speaker | audio-record-transcribe, audio-device-health, meeting-live-notes | high | strong | integration | 19 | 135 | 4 | Audio transcript dedupe, live meeting mirroring, end-generation and open-meeting invariants, liveness, and speaker reassignment coverage. |-| db-runtime-reliability | screenpipe-db | windows, macos, linux | database, performance | performance-liveness | high | partial | mixed | 18 | 53 | 7 | SQLite hard-fault classification, failpoint VFS injection, fresh-identity recovery verification with integrity/FK/write canaries, query cancellation, close-severs-connections regressions, multi-pool WAL parity, runtime version pinning, and WAL chaos plus memory-pressure probes, plus read-only quarantine self-heal verification for transient IOERR faults. |+| db-runtime-reliability | screenpipe-db | windows, macos, linux | database, performance | performance-liveness | high | partial | mixed | 18 | 55 | 7 | SQLite hard-fault classification, failpoint VFS injection, fresh-identity recovery verification with integrity/FK/write canaries, query cancellation, close-severs-connections regressions, multi-pool WAL parity, runtime version pinning, and WAL chaos plus memory-pressure probes, plus read-only quarantine self-heal verification for transient IOERR faults. || db-search-indexing | screenpipe-db | windows, macos, linux | db-search, ocr, accessibility, performance | local-api-search, capture-ocr-pipeline, accessibility-ui-events, performance-liveness | high | strong | mixed | 14 | 107 | 4 | FTS, tokenizer, OCR snapshot search, query planning, ordering, accessibility search, and contention coverage. || db-timeline-frames | screenpipe-db | windows, macos, linux | database, timeline, storage, performance | timeline-streaming, performance-liveness | high | strong | mixed | 40 | 315 | 15 | Frame/audio joins, timeline query shape, suggestions frames, write queue, DB primitives (src/db.rs split into src/db/ modules), feedback record upserts, media eviction anti-join regressions, SAF output registry, semantic storage, and timeline performance. || engine-api-routes | screenpipe-engine | windows, macos, linux | local-api, timeline, meeting, transcription | local-api-search, timeline-streaming, meeting-live-notes, audio-record-transcribe | high | partial | mixed | 46 | 438 | 7 | Route/unit coverage for search, health, streaming, meetings, time/timezone, and transcription. Legacy endpoint/websocket tests require local data and remain ignored. |@@ -294,7 +294,7 @@ bun run coverage:core -- --llvm-cov-summary ../../docs/coverage/core-llvm-cov-su| db-timeline-frames | screenpipe-db | src/db/truncation_tests.rs | source | 1 | 0 | 1 || db-runtime-reliability | screenpipe-db | src/failpoint_vfs.rs | source | 4 | 0 | 4 || db-runtime-reliability | screenpipe-db | src/recovery.rs | source | 5 | 0 | 5 |-| db-runtime-reliability | screenpipe-db | src/sqlite_error.rs | source | 5 | 0 | 5 |+| db-runtime-reliability | screenpipe-db | src/sqlite_error.rs | source | 7 | 0 | 7 || db-timeline-frames | screenpipe-db | src/storage/bulk/elements/lifecycle.rs | source | 2 | 0 | 2 || db-timeline-frames | screenpipe-db | src/storage/bulk/tests.rs | source | 11 | 0 | 11 || db-timeline-frames | screenpipe-db | src/storage/diagnostics.rs | source | 7 | 0 | 7 |