Skip to content

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

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 retries
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.md
index 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% |
## Refresh
diff --git a/docs/coverage/CORE.md b/docs/coverage/CORE.md
index 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.0
Confidence 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 |