style: denser readable formatting (rustfmt 140, compact CSS rules)

Reduce line count without one-file minification: wider rustfmt for
daemon-rs and compact leaf CSS declaration blocks while preserving
selectors and behavior. Tests remain green.

Co-authored-by: AdityaG <AdityaVG13@users.noreply.github.com>

Author: cursoragent

daemon-rs/rustfmt.toml

@@ -0,0 +1,8 @@
+edition = "2021"
+max_width = 140
+use_small_heuristics = "Max"
+fn_params_layout = "Compressed"
+struct_lit_width = 80
+struct_variant_width = 80
+array_width = 100
+chain_width = 100

daemon-rs/src/admin/mod.rs

@@ -11,15 +11,8 @@ pub struct RollbackStats {
     pub applied: bool,
     pub already_rolled_back: bool,
 }
-pub fn rollback_session_by_id(
-    conn: &Connection,
-    session_id: &str,
-    apply: bool,
-) -> rusqlite::Result<RollbackStats> {
-    let mut stats = RollbackStats {
-        session_id: session_id.to_string(),
-        ..Default::default()
-    };
+pub fn rollback_session_by_id(conn: &Connection, session_id: &str, apply: bool) -> rusqlite::Result<RollbackStats> {
+    let mut stats = RollbackStats { session_id: session_id.to_string(), ..Default::default() };
     let session_row: Option<(String, String)> = conn
         .query_row(
             "SELECT agent, started_at FROM sessions
@@ -70,9 +63,7 @@ pub fn rollback_session_by_id(
     )?;
     stats.memories_affected = active_memories;
     stats.decisions_affected = active_decisions;
-    stats.already_rolled_back = active_memories == 0
-        && active_decisions == 0
-        && (prior_rolled_memories > 0 || prior_rolled_decisions > 0);
+    stats.already_rolled_back = active_memories == 0 && active_decisions == 0 && (prior_rolled_memories > 0 || prior_rolled_decisions > 0);
     if !apply {
         return Ok(stats);
     }

daemon-rs/src/admin/tests/mod.rs

@@ -82,64 +82,29 @@ fn dry_run_counts_without_writing() {
     assert_eq!(stats.memories_affected, 2);
     assert_eq!(stats.decisions_affected, 1);
     assert!(!stats.applied);
-    let active: i64 = conn
-        .query_row(
-            "SELECT COUNT(*) FROM memories WHERE status = 'active'",
-            [],
-            |r| r.get(0),
-        )
-        .unwrap();
+    let active: i64 = conn.query_row("SELECT COUNT(*) FROM memories WHERE status = 'active'", [], |r| r.get(0)).unwrap();
     assert_eq!(active, 2);
 }
 #[test]
 fn apply_flips_statuses_and_excludes_older_rows() {
     let conn = setup();
     seed_session(&conn, "claude", "sess-1", "2026-04-24T00:00:00Z");
     seed_memory(&conn, "claude", "old", "2026-04-23T23:59:00Z", "active");
-    seed_memory(
-        &conn,
-        "codex",
-        "other-agent",
-        "2026-04-24T00:05:00Z",
-        "active",
-    );
+    seed_memory(&conn, "codex", "other-agent", "2026-04-24T00:05:00Z", "active");
     seed_memory(&conn, "claude", "m1", "2026-04-24T00:05:00Z", "active");
     seed_memory(&conn, "claude", "m2", "2026-04-24T00:10:00Z", "active");
-    seed_memory(
-        &conn,
-        "claude",
-        "pre-rolled",
-        "2026-04-24T00:07:00Z",
-        ROLLED_BACK_STATUS,
-    );
+    seed_memory(&conn, "claude", "pre-rolled", "2026-04-24T00:07:00Z", ROLLED_BACK_STATUS);
     seed_decision(&conn, "claude", "d1", "2026-04-24T00:06:00Z");
     let stats = rollback_session_by_id(&conn, "sess-1", true).unwrap();
-    assert_eq!(
-        stats.memories_affected, 2,
-        "only the 2 active in-session memories"
-    );
+    assert_eq!(stats.memories_affected, 2, "only the 2 active in-session memories");
     assert_eq!(stats.decisions_affected, 1);
     assert!(stats.applied);
-    let old_status: String = conn
-        .query_row("SELECT status FROM memories WHERE text = 'old'", [], |r| {
-            r.get(0)
-        })
-        .unwrap();
+    let old_status: String = conn.query_row("SELECT status FROM memories WHERE text = 'old'", [], |r| r.get(0)).unwrap();
     assert_eq!(old_status, "active");
-    let other_status: String = conn
-        .query_row(
-            "SELECT status FROM memories WHERE text = 'other-agent'",
-            [],
-            |r| r.get(0),
-        )
-        .unwrap();
+    let other_status: String = conn.query_row("SELECT status FROM memories WHERE text = 'other-agent'", [], |r| r.get(0)).unwrap();
     assert_eq!(other_status, "active");
     let rolled: i64 = conn
-        .query_row(
-            "SELECT COUNT(*) FROM memories WHERE source_agent = 'claude' AND status = ?1",
-            params![ROLLED_BACK_STATUS],
-            |r| r.get(0),
-        )
+        .query_row("SELECT COUNT(*) FROM memories WHERE source_agent = 'claude' AND status = ?1", params![ROLLED_BACK_STATUS], |r| r.get(0))
         .unwrap();
     assert_eq!(rolled, 3); // pre-rolled + 2 freshly rolled
 }

daemon-rs/src/aging.rs

@@ -35,11 +35,7 @@ fn age_memories_to_recent(conn: &Connection) -> usize {
         )
         .and_then(|mut stmt| {
             let mapped = stmt.query_map(params![FRESH_DAYS], |row| {
-                Ok((
-                    row.get::<_, i64>(0)?,
-                    row.get::<_, String>(1)?,
-                    row.get::<_, Option<String>>(2)?,
-                ))
+                Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?, row.get::<_, Option<String>>(2)?))
             })?;
             Ok(mapped.flatten().collect())
         })
@@ -51,9 +47,10 @@ fn age_memories_to_recent(conn: &Connection) -> usize {
             }
         }
         let compressed = compress_to_key_points(&text);
-        let _=conn.execute(
-"UPDATE memories SET compressed_text = ?1, age_tier = 'recent', updated_at = datetime('now') WHERE id = ?2",params![compressed,id]
-,);
+        let _ = conn.execute(
+            "UPDATE memories SET compressed_text = ?1, age_tier = 'recent', updated_at = datetime('now') WHERE id = ?2",
+            params![compressed, id],
+        );
         count += 1;
     }
     count
@@ -69,11 +66,7 @@ fn age_memories_to_old(conn: &Connection) -> usize {
         )
         .and_then(|mut stmt| {
             let mapped = stmt.query_map(params![RECENT_DAYS], |row| {
-                Ok((
-                    row.get::<_, i64>(0)?,
-                    row.get::<_, String>(1)?,
-                    row.get::<_, Option<String>>(2)?,
-                ))
+                Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?, row.get::<_, Option<String>>(2)?))
             })?;
             Ok(mapped.flatten().collect())
         })
@@ -85,20 +78,23 @@ fn age_memories_to_old(conn: &Connection) -> usize {
             }
         }
         let compressed = compress_to_one_liner(&text);
-        let _=conn.
-execute("UPDATE memories SET compressed_text = ?1, age_tier = 'old', updated_at = datetime('now') WHERE id = ?2",params![
-compressed,id],);
+        let _ = conn.execute(
+            "UPDATE memories SET compressed_text = ?1, age_tier = 'old', updated_at = datetime('now') WHERE id = ?2",
+            params![compressed, id],
+        );
         count += 1;
     }
     count
 }
 fn archive_ancient_memories(conn: &Connection) -> usize {
     conn.execute(
-"UPDATE memories SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
+        "UPDATE memories SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
          WHERE status = 'active' AND pinned = 0 \
          AND age_tier = 'old' \
-         AND julianday('now') - julianday(COALESCE(updated_at, created_at)) > ?1"
-,params![OLD_DAYS],).unwrap_or(0)
+         AND julianday('now') - julianday(COALESCE(updated_at, created_at)) > ?1",
+        params![OLD_DAYS],
+    )
+    .unwrap_or(0)
 }
 fn age_decisions_to_recent(conn: &Connection) -> usize {
     let mut count = 0;
@@ -111,11 +107,7 @@ fn age_decisions_to_recent(conn: &Connection) -> usize {
         )
         .and_then(|mut stmt| {
             let mapped = stmt.query_map(params![FRESH_DAYS], |row| {
-                Ok((
-                    row.get::<_, i64>(0)?,
-                    row.get::<_, String>(1)?,
-                    row.get::<_, Option<String>>(2)?,
-                ))
+                Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?, row.get::<_, Option<String>>(2)?))
             })?;
             Ok(mapped.flatten().collect())
         })
@@ -126,9 +118,10 @@ fn age_decisions_to_recent(conn: &Connection) -> usize {
             None => decision,
         };
         let compressed = compress_to_key_points(&full);
-        let _=conn.
-execute("UPDATE decisions SET compressed_text = ?1, age_tier = 'recent', updated_at = datetime('now') WHERE id = ?2",params![
-compressed,id],);
+        let _ = conn.execute(
+            "UPDATE decisions SET compressed_text = ?1, age_tier = 'recent', updated_at = datetime('now') WHERE id = ?2",
+            params![compressed, id],
+        );
         count += 1;
     }
     count
@@ -144,11 +137,7 @@ fn age_decisions_to_old(conn: &Connection) -> usize {
         )
         .and_then(|mut stmt| {
             let mapped = stmt.query_map(params![RECENT_DAYS], |row| {
-                Ok((
-                    row.get::<_, i64>(0)?,
-                    row.get::<_, String>(1)?,
-                    row.get::<_, Option<String>>(2)?,
-                ))
+                Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?, row.get::<_, Option<String>>(2)?))
             })?;
             Ok(mapped.flatten().collect())
         })
@@ -159,27 +148,26 @@ fn age_decisions_to_old(conn: &Connection) -> usize {
             None => decision,
         };
         let compressed = compress_to_one_liner(&full);
-        let _=conn
-.execute("UPDATE decisions SET compressed_text = ?1, age_tier = 'old', updated_at = datetime('now') WHERE id = ?2",params![
-compressed,id],);
+        let _ = conn.execute(
+            "UPDATE decisions SET compressed_text = ?1, age_tier = 'old', updated_at = datetime('now') WHERE id = ?2",
+            params![compressed, id],
+        );
         count += 1;
     }
     count
 }
 fn archive_ancient_decisions(conn: &Connection) -> usize {
     conn.execute(
-"UPDATE decisions SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
+        "UPDATE decisions SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
          WHERE status = 'active' AND pinned = 0 \
          AND age_tier = 'old' \
-         AND julianday('now') - julianday(COALESCE(updated_at, created_at)) > ?1"
-,params![OLD_DAYS],).unwrap_or(0)
+         AND julianday('now') - julianday(COALESCE(updated_at, created_at)) > ?1",
+        params![OLD_DAYS],
+    )
+    .unwrap_or(0)
 }
 fn compress_to_key_points(text: &str) -> String {
-    let sentences: Vec<&str> = text
-        .split(['.', '\n'])
-        .map(|s| s.trim())
-        .filter(|s| s.len() > 5)
-        .collect();
+    let sentences: Vec<&str> = text.split(['.', '\n']).map(|s| s.trim()).filter(|s| s.len() > 5).collect();
     if sentences.len() <= 2 {
         return text.chars().take(300).collect();
     }
@@ -218,52 +206,55 @@ fn compress_to_key_points(text: &str) -> String {
     }
 }
 fn compress_to_one_liner(text: &str) -> String {
-    let first_sentence = text
-        .split(['.', '\n'])
-        .map(|s| s.trim())
-        .find(|s| s.len() > 5)
-        .unwrap_or(text);
+    let first_sentence = text.split(['.', '\n']).map(|s| s.trim()).find(|s| s.len() > 5).unwrap_or(text);
     first_sentence.chars().take(120).collect()
 }
 fn gc_low_score(conn: &Connection) -> usize {
     let mut count = 0usize;
-    count+=conn.execute
-(
-"UPDATE memories SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
+    count += conn
+        .execute(
+            "UPDATE memories SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
          WHERE status = 'active' AND pinned = 0 \
          AND score < ?1 \
-         AND julianday('now') - julianday(COALESCE(last_accessed, created_at)) > ?2"
-,params![GC_SCORE_THRESHOLD,GC_MIN_DAYS],).unwrap_or(0);
-    count+=conn.execute(
-"UPDATE decisions SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
+         AND julianday('now') - julianday(COALESCE(last_accessed, created_at)) > ?2",
+            params![GC_SCORE_THRESHOLD, GC_MIN_DAYS],
+        )
+        .unwrap_or(0);
+    count += conn
+        .execute(
+            "UPDATE decisions SET status = 'archived', age_tier = 'ancient', updated_at = datetime('now') \
          WHERE status = 'active' AND pinned = 0 \
          AND score < ?1 \
-         AND julianday('now') - julianday(COALESCE(last_accessed, created_at)) > ?2"
-,params![GC_SCORE_THRESHOLD,GC_MIN_DAYS],).unwrap_or(0);
+         AND julianday('now') - julianday(COALESCE(last_accessed, created_at)) > ?2",
+            params![GC_SCORE_THRESHOLD, GC_MIN_DAYS],
+        )
+        .unwrap_or(0);
     if count > 0 {
         eprintln!("[aging] GC archived {count} low-score entries (score < {GC_SCORE_THRESHOLD})");
     }
     count
 }
 fn cleanup_orphaned_embeddings(conn: &Connection) -> usize {
     let mut count = 0usize;
-    count+=conn.execute(
-"DELETE FROM embeddings WHERE target_type = 'memory' \
-         AND NOT EXISTS (SELECT 1 FROM memories m WHERE m.id = embeddings.target_id AND m.status = 'active')"
-,[],).unwrap_or(0);
-    count+=conn.execute(
-"DELETE FROM embeddings WHERE target_type = 'decision' \
-         AND NOT EXISTS (SELECT 1 FROM decisions d WHERE d.id = embeddings.target_id AND d.status = 'active')"
-,[],).unwrap_or(0);
+    count += conn
+        .execute(
+            "DELETE FROM embeddings WHERE target_type = 'memory' \
+         AND NOT EXISTS (SELECT 1 FROM memories m WHERE m.id = embeddings.target_id AND m.status = 'active')",
+            [],
+        )
+        .unwrap_or(0);
+    count += conn
+        .execute(
+            "DELETE FROM embeddings WHERE target_type = 'decision' \
+         AND NOT EXISTS (SELECT 1 FROM decisions d WHERE d.id = embeddings.target_id AND d.status = 'active')",
+            [],
+        )
+        .unwrap_or(0);
     count
 }
 pub fn get_display_text(text: &str, compressed_text: &Option<String>, age_tier: &str) -> String {
     match age_tier {
         "fresh" => text.to_string(),
-        _ => compressed_text
-            .as_ref()
-            .filter(|c| !c.is_empty())
-            .cloned()
-            .unwrap_or_else(|| text.to_string()),
+        _ => compressed_text.as_ref().filter(|c| !c.is_empty()).cloned().unwrap_or_else(|| text.to_string()),
     }
 }