fix: surface real DB errors in delete_rule_inner instead of swallowing them

Addresses review nit on #200. The previous
`.ok().and_then(|s| s.query_row(..).ok())` pattern silently conflated
three cases:
  1. row exists → Some(rule) ✓
  2. row absent (QueryReturnedNoRows) → None ✓
  3. real DB error (lock contention, corruption, IO) → None ✗
     → DB delete proceeds, disk file leaks

Switch to an explicit match on rusqlite::Error so only
QueryReturnedNoRows maps to None; every other error is returned before
the DELETE runs. Same treatment for rule_writer::delete_rule_file — its
existing file-exists guard already handles the legitimate "disk file
already gone" case, so any error it raises now is a real IO/permission
failure worth surfacing.

Adds test_delete_rule_missing_id_is_not_an_error to pin the
QueryReturnedNoRows arm. 2015/2015 lib tests pass.

Author: prefrontalsys

src-tauri/src/commands/rules.rs

@@ -139,23 +139,33 @@ pub fn update_rule(
     stmt.query_row([id], row_to_rule).map_err(|e| e.to_string())
 }
 
-/// Inner helper for [`delete_rule`]: drops the DB row and best-effort
-/// removes the backing `.md` file under `{home}/.claude/rules/<name>.md`.
+/// Inner helper for [`delete_rule`]: drops the DB row and removes the
+/// backing `.md` file under `{home}/.claude/rules/<name>.md`.
 /// Factored out so tests can pass a temp dir in place of `~`.
+///
+/// Error handling: a missing row is not an error (the rule is effectively
+/// gone — DB delete no-ops, disk delete is skipped). Any other lookup error
+/// (lock contention, corruption, etc.) is surfaced *before* the DB delete,
+/// so we never orphan the disk file by nulling out the DB row without
+/// knowing the filename.
 fn delete_rule_inner(conn: &rusqlite::Connection, id: i64, home: &Path) -> Result<(), String> {
     let query = format!("SELECT {} FROM rules WHERE id = ?", RULE_SELECT_FIELDS);
-    let rule: Option<Rule> = conn
+    let rule: Option<Rule> = match conn
         .prepare(&query)
-        .ok()
-        .and_then(|mut s| s.query_row([id], row_to_rule).ok());
+        .and_then(|mut s| s.query_row([id], row_to_rule))
+    {
+        Ok(r) => Some(r),
+        Err(rusqlite::Error::QueryReturnedNoRows) => None,
+        Err(e) => return Err(e.to_string()),
+    };
 
     conn.execute("DELETE FROM rules WHERE id = ?", [id])
         .map_err(|e| e.to_string())?;
 
     if let Some(rule) = rule {
-        // Best-effort — if the file is already gone (user deleted by hand) we
-        // still want the DB delete to succeed.
-        let _ = rule_writer::delete_rule_file(home, &rule);
+        // `delete_rule_file` already treats a missing file as success; any
+        // error returned here is a real IO/permission failure worth surfacing.
+        rule_writer::delete_rule_file(home, &rule).map_err(|e| e.to_string())?;
     }
 
     Ok(())
@@ -611,6 +621,18 @@ mod tests {
         assert_eq!(row_count, 0, "db row should be removed");
     }
 
+    #[test]
+    fn test_delete_rule_missing_id_is_not_an_error() {
+        // A delete targeting an ID that isn't in the DB must return Ok —
+        // the "rule is gone" end state is already satisfied. This exercises
+        // the `QueryReturnedNoRows` arm of delete_rule_inner.
+        let db = setup_test_db();
+        let temp_dir = tempfile::TempDir::new().unwrap();
+
+        let result = delete_rule_inner(db.conn(), 99_999, temp_dir.path());
+        assert!(result.is_ok(), "missing row should not error");
+    }
+
     #[test]
     fn test_delete_rule_succeeds_when_file_absent() {
         let db = setup_test_db();