feat(cli): move runtime state to XDG state dirs (#1152)

* feat(cli): move runtime state to XDG state dirs

Store audit, session registry, and rollback data under
/nono/ (default ~/.local/state/nono/) on all platforms.
Keep read fallback and one-time deprecation warnings for ~/.nono/ until v1.0.0.

Signed-off-by: Aleksy Siek <aleksy@alwaysfurther.ai>

* fix: review changes

Signed-off-by: Aleksy Siek <aleksy@alwaysfurther.ai>

---------

Signed-off-by: Aleksy Siek <aleksy@alwaysfurther.ai>

Author: SequeI

crates/nono-cli/src/audit_ledger.rs

@@ -1,4 +1,5 @@
 use crate::audit_session::audit_root;
+use crate::state_paths;
 use nix::fcntl::{Flock, FlockArg};
 use nono::audit::{
     LedgerRecord, LedgerVerificationResult, append_session_to_ledger_file,
@@ -9,7 +10,7 @@ use nono::undo::SessionMetadata;
 use nono::{NonoError, Result};
 use std::fs::OpenOptions;
 use std::io::BufReader;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 const AUDIT_LEDGER_FILENAME: &str = "ledger.ndjson";
 const AUDIT_LEDGER_LOCK_FILENAME: &str = "ledger.lock";
@@ -27,6 +28,7 @@ pub(crate) fn append_session(metadata: &SessionMetadata) -> Result<LedgerRecord>
 
     let path = root.join(AUDIT_LEDGER_FILENAME);
     let _lock = LedgerLock::acquire(root.join(AUDIT_LEDGER_LOCK_FILENAME))?;
+    state_paths::maybe_migrate_legacy_audit_ledger()?;
     let mut file = OpenOptions::new()
         .create(true)
         .read(true)
@@ -45,7 +47,29 @@ pub(crate) fn append_session(metadata: &SessionMetadata) -> Result<LedgerRecord>
 pub(crate) fn verify_session_in_ledger(
     metadata: &SessionMetadata,
 ) -> Result<LedgerVerificationResult> {
-    let root = audit_root()?;
+    let primary = audit_root()?;
+    let result = verify_session_in_ledger_at_root(&primary, metadata)?;
+    if result.session_found {
+        return Ok(result);
+    }
+
+    if let Ok(legacy) = state_paths::legacy_audit_root()
+        && legacy != primary
+    {
+        let legacy_ledger = legacy.join(AUDIT_LEDGER_FILENAME);
+        if legacy_ledger.exists() {
+            state_paths::warn_legacy_audit_path(&legacy);
+            return verify_session_in_ledger_at_root(&legacy, metadata);
+        }
+    }
+
+    Ok(result)
+}
+
+fn verify_session_in_ledger_at_root(
+    root: &Path,
+    metadata: &SessionMetadata,
+) -> Result<LedgerVerificationResult> {
     let path = root.join(AUDIT_LEDGER_FILENAME);
     if !path.exists() {
         return missing_ledger_verification_result(metadata);
@@ -125,8 +149,11 @@ mod tests {
     fn ledger_appends_and_verifies_session_digest() {
         let _env_lock = ENV_LOCK.lock().unwrap();
         let tmp = tempfile::tempdir().unwrap();
+        let state = tmp.path().join("state");
+        std::fs::create_dir_all(&state).unwrap();
         let home = tmp.path().to_string_lossy().to_string();
-        let _env = EnvVarGuard::set_all(&[("HOME", &home)]);
+        let state_str = state.to_string_lossy().to_string();
+        let _env = EnvVarGuard::set_all(&[("HOME", &home), ("XDG_STATE_HOME", &state_str)]);
 
         let meta = sample_metadata("20260421-200000-11111");
         append_session(&meta).unwrap();
@@ -142,8 +169,11 @@ mod tests {
     fn ledger_rejects_malformed_session_id() {
         let _env_lock = ENV_LOCK.lock().unwrap();
         let tmp = tempfile::tempdir().unwrap();
+        let state = tmp.path().join("state");
+        std::fs::create_dir_all(&state).unwrap();
         let home = tmp.path().to_string_lossy().to_string();
-        let _env = EnvVarGuard::set_all(&[("HOME", &home)]);
+        let state_str = state.to_string_lossy().to_string();
+        let _env = EnvVarGuard::set_all(&[("HOME", &home), ("XDG_STATE_HOME", &state_str)]);
 
         let meta = sample_metadata("real-token\\|real-key");
         let err = match append_session(&meta) {

crates/nono-cli/src/audit_session.rs

@@ -1,10 +1,12 @@
 //! Session discovery and management for the audit system.
 //!
-//! Audit sessions are stored in `~/.nono/audit/`. For backwards
-//! compatibility, the audit commands also read legacy audit metadata from
-//! `~/.nono/rollbacks/` when no migrated audit entry exists yet.
+//! Audit sessions are stored under `$XDG_STATE_HOME/nono/audit/` (default
+//! `~/.local/state/nono/audit/`). For backwards compatibility, reads also
+//! check `~/.nono/audit/` until v1.0.0, and legacy audit metadata under
+//! `~/.nono/rollbacks/` (or the canonical rollback root) when no migrated
+//! audit entry exists yet.
 
-use crate::rollback_session;
+use crate::state_paths;
 use nono::undo::{SessionMetadata, SnapshotManager};
 use nono::{NonoError, Result};
 use std::collections::BTreeSet;
@@ -27,10 +29,9 @@ pub struct SessionInfo {
     pub is_stale: bool,
 }
 
-/// Get the audit root directory (`~/.nono/audit/`)
+/// Get the canonical audit root directory (`$XDG_STATE_HOME/nono/audit/`).
 pub fn audit_root() -> Result<PathBuf> {
-    let home = dirs::home_dir().ok_or(NonoError::HomeNotFound)?;
-    Ok(home.join(".nono").join("audit"))
+    state_paths::audit_root()
 }
 
 /// Discover all audit sessions.
@@ -42,14 +43,12 @@ pub fn discover_sessions() -> Result<Vec<SessionInfo>> {
     let mut sessions = Vec::new();
     let mut seen_ids = BTreeSet::new();
     let primary_root = audit_root()?;
+    let legacy_roots = state_paths::LegacyRootSet::resolve()?;
 
-    for root in [
-        Some(primary_root.clone()),
-        rollback_session::rollback_root().ok(),
-    ] {
-        let Some(root) = root else {
-            continue;
-        };
+    let mut roots: Vec<PathBuf> = state_paths::audit_discovery_roots()?;
+    roots.extend(state_paths::rollback_discovery_roots()?);
+
+    for root in roots {
         if !root.exists() {
             continue;
         }
@@ -86,6 +85,7 @@ pub fn discover_sessions() -> Result<Vec<SessionInfo>> {
                 continue;
             }
 
+            legacy_roots.warn_if_legacy_audit_data_read(&dir);
             sessions.push(build_session_info(dir, metadata));
         }
     }
@@ -98,12 +98,11 @@ pub fn discover_sessions() -> Result<Vec<SessionInfo>> {
 pub fn load_session(session_id: &str) -> Result<SessionInfo> {
     validate_session_id(session_id)?;
     let primary_root = audit_root()?;
-    let roots = [
-        Some(primary_root.clone()),
-        rollback_session::rollback_root().ok(),
-    ];
+    let legacy_roots = state_paths::LegacyRootSet::resolve()?;
+    let mut roots: Vec<PathBuf> = state_paths::audit_discovery_roots()?;
+    roots.extend(state_paths::rollback_discovery_roots()?);
 
-    for root in roots.into_iter().flatten() {
+    for root in roots {
         let dir = root.join(session_id);
         if !dir.exists() {
             continue;
@@ -129,6 +128,7 @@ pub fn load_session(session_id: &str) -> Result<SessionInfo> {
             continue;
         }
 
+        legacy_roots.warn_if_legacy_audit_data_read(&dir);
         return Ok(build_session_info(dir, metadata));
     }
 
@@ -242,8 +242,11 @@ mod tests {
     fn discover_sessions_excludes_rollback_backed_entries() {
         let _env_lock = ENV_LOCK.lock().unwrap();
         let tmp = tempfile::tempdir().unwrap();
+        let state = tmp.path().join("state");
+        fs::create_dir_all(&state).unwrap();
         let home = tmp.path().to_string_lossy().to_string();
-        let _env = EnvVarGuard::set_all(&[("HOME", &home)]);
+        let state_str = state.to_string_lossy().to_string();
+        let _env = EnvVarGuard::set_all(&[("HOME", &home), ("XDG_STATE_HOME", &state_str)]);
 
         let audit_dir = audit_root().unwrap().join("20260421-111111-10001");
         fs::create_dir_all(&audit_dir).unwrap();
@@ -267,7 +270,7 @@ mod tests {
         )
         .unwrap();
 
-        let legacy_audit_dir = rollback_session::rollback_root()
+        let legacy_audit_dir = state_paths::legacy_rollback_root()
             .unwrap()
             .join("20260421-111111-10002");
         fs::create_dir_all(&legacy_audit_dir).unwrap();
@@ -291,7 +294,7 @@ mod tests {
         )
         .unwrap();
 
-        let rollback_dir = rollback_session::rollback_root()
+        let rollback_dir = state_paths::legacy_rollback_root()
             .unwrap()
             .join("20260421-111111-10003");
         fs::create_dir_all(&rollback_dir).unwrap();
@@ -325,4 +328,95 @@ mod tests {
         assert!(ids.contains(&"20260421-111111-10002"));
         assert!(!ids.contains(&"20260421-111111-10003"));
     }
+
+    #[test]
+    fn discover_sessions_reads_legacy_audit_root() {
+        let _env_lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let tmp = tempfile::tempdir().unwrap();
+        let state = tmp.path().join("state");
+        fs::create_dir_all(&state).unwrap();
+        let home = tmp.path().to_string_lossy().to_string();
+        let state_str = state.to_string_lossy().to_string();
+        let _env = EnvVarGuard::set_all(&[("HOME", &home), ("XDG_STATE_HOME", &state_str)]);
+
+        let legacy_audit_dir = state_paths::legacy_audit_root()
+            .unwrap()
+            .join("20260421-111111-20001");
+        fs::create_dir_all(&legacy_audit_dir).unwrap();
+        SnapshotManager::write_session_metadata(
+            &legacy_audit_dir,
+            &SessionMetadata {
+                session_id: "20260421-111111-20001".to_string(),
+                started: "2026-04-21T11:11:11+01:00".to_string(),
+                ended: Some("2026-04-21T11:11:12+01:00".to_string()),
+                command: vec!["/bin/echo".to_string()],
+                executable_identity: None,
+                tracked_paths: vec![PathBuf::from("/tmp/work")],
+                snapshot_count: 0,
+                exit_code: Some(0),
+                merkle_roots: Vec::new(),
+                network_events: Vec::new(),
+                audit_event_count: 1,
+                audit_integrity: None,
+                audit_attestation: None,
+            },
+        )
+        .unwrap();
+
+        let sessions = discover_sessions().unwrap();
+        let ids: Vec<_> = sessions
+            .iter()
+            .map(|s| s.metadata.session_id.as_str())
+            .collect();
+        assert!(ids.contains(&"20260421-111111-20001"));
+        assert!(is_legacy_audit_only_session(
+            sessions
+                .iter()
+                .find(|s| s.metadata.session_id == "20260421-111111-20001")
+                .expect("legacy session")
+        ));
+    }
+
+    #[test]
+    fn discover_sessions_does_not_warn_when_legacy_audit_root_is_empty() {
+        let _env_lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let tmp = tempfile::tempdir().unwrap();
+        let state = tmp.path().join("state");
+        fs::create_dir_all(&state).unwrap();
+        let home = tmp.path().to_string_lossy().to_string();
+        let state_str = state.to_string_lossy().to_string();
+        let _env = EnvVarGuard::set_all(&[("HOME", &home), ("XDG_STATE_HOME", &state_str)]);
+
+        let legacy_root = state_paths::legacy_audit_root().unwrap();
+        fs::create_dir_all(&legacy_root).unwrap();
+        fs::write(legacy_root.join("ledger.ndjson"), b"{}\n").unwrap();
+
+        let canonical_dir = state_paths::audit_root()
+            .unwrap()
+            .join("20260421-111111-30001");
+        fs::create_dir_all(&canonical_dir).unwrap();
+        SnapshotManager::write_session_metadata(
+            &canonical_dir,
+            &SessionMetadata {
+                session_id: "20260421-111111-30001".to_string(),
+                started: "2026-04-21T11:11:11+01:00".to_string(),
+                ended: Some("2026-04-21T11:11:12+01:00".to_string()),
+                command: vec!["/bin/echo".to_string()],
+                executable_identity: None,
+                tracked_paths: vec![PathBuf::from("/tmp/work")],
+                snapshot_count: 0,
+                exit_code: Some(0),
+                merkle_roots: Vec::new(),
+                network_events: Vec::new(),
+                audit_event_count: 1,
+                audit_integrity: None,
+                audit_attestation: None,
+            },
+        )
+        .unwrap();
+
+        let sessions = discover_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert!(is_primary_audit_session(&sessions[0].dir));
+    }
 }

crates/nono-cli/src/cli.rs

@@ -1699,7 +1699,7 @@ pub struct RunArgs {
     pub skip_dir: Vec<String>,
 
     /// Override the rollback snapshot destination directory.
-    /// By default, snapshots are stored in ~/.nono/rollbacks/.
+    /// By default, snapshots are stored in $XDG_STATE_HOME/nono/rollbacks/.
     /// The destination must be within a path already granted write access
     /// by --allow (or profile); nono will fail with a clear error if not.
     /// Useful for Docker volume mounts or shared storage paths.

crates/nono-cli/src/config/mod.rs

@@ -63,12 +63,9 @@ pub fn user_config_dir() -> Option<PathBuf> {
     dirs::config_dir().map(|p| p.join("nono"))
 }
 
-/// Get the user state directory path (for version tracking)
-#[allow(dead_code)]
+/// Get the user state directory path (for version tracking and runtime state)
 pub fn user_state_dir() -> Option<PathBuf> {
-    dirs::state_dir()
-        .or_else(dirs::data_local_dir)
-        .map(|p| p.join("nono"))
+    crate::state_paths::user_state_dir().ok()
 }
 
 // ============================================================================

crates/nono-cli/src/launch_runtime.rs

@@ -432,7 +432,7 @@ fn validate_rollback_destination(
 
     Err(NonoError::ConfigParse(format!(
         "--rollback-dest '{}' is not covered by sandbox write permissions. \
-         Add --allow {} to grant access, or omit --rollback-dest to use the default path (~/.nono/rollbacks/).",
+         Add --allow {} to grant access, or omit --rollback-dest to use the default path ($XDG_STATE_HOME/nono/rollbacks/).",
         dest.display(),
         dest.display()
     )))

crates/nono-cli/src/main.rs

@@ -65,6 +65,7 @@ mod session_commands;
 mod setup;
 mod startup_prompt;
 mod startup_runtime;
+mod state_paths;
 mod supervised_runtime;
 mod terminal_approval;
 mod theme;

crates/nono-cli/src/protected_paths.rs

@@ -1,7 +1,7 @@
 //! Protection for nono's own state paths.
 //!
 //! These checks enforce a hard fail if initial sandbox capabilities overlap
-//! with internal CLI state roots (currently `~/.nono`).
+//! with internal CLI state roots (`~/.nono` and `$XDG_STATE_HOME/nono`).
 
 use nono::{CapabilitySet, NonoError, Result, try_canonicalize};
 use std::path::{Path, PathBuf};
@@ -17,12 +17,11 @@ pub struct ProtectedRoots {
 impl ProtectedRoots {
     /// Build protected roots from current defaults.
     ///
-    /// Today this protects the full `~/.nono` subtree.
+    /// Protects both the legacy `~/.nono` tree and the canonical `$XDG_STATE_HOME/nono`
+    /// runtime state directory (audit, sessions, rollbacks).
     pub fn from_defaults() -> Result<Self> {
-        let home = dirs::home_dir().ok_or(NonoError::HomeNotFound)?;
-        let state_root = try_canonicalize(&home.join(".nono"));
         Ok(Self {
-            roots: vec![state_root],
+            roots: crate::state_paths::protected_state_roots()?,
         })
     }
 

crates/nono-cli/src/proxy_runtime.rs

@@ -369,20 +369,17 @@ pub(crate) fn start_proxy_runtime(
 }
 
 /// Choose the directory the proxy will write the TLS-intercept trust bundle
-/// into. Conventionally `~/.nono/sessions/<random>/`, kept owner-only.
+/// into. Conventionally `$XDG_STATE_HOME/nono/sessions/<random>/`, kept owner-only.
 ///
 /// Returns `Ok(None)` if no `HOME` is set (rare edge cases like CI). We log
 /// a warning rather than failing because TLS interception is opt-in: a
 /// missing directory just means CONNECTs to L7-bearing routes will get the
 /// usual 403, which is a coherent fallback rather than a hard error.
 fn prepare_intercept_ca_dir() -> Result<Option<PathBuf>> {
-    let home = match dirs::home_dir() {
-        Some(h) => h,
-        None => {
-            warn!(
-                "no $HOME found; skipping TLS-intercept setup (CONNECTs to L7-bearing routes \
-                 will be denied with 403)"
-            );
+    let dir = match crate::session::ensure_sessions_dir() {
+        Ok(base) => base,
+        Err(e) => {
+            warn!("cannot resolve session registry for TLS-intercept setup: {e}; skipping");
             return Ok(None);
         }
     };
@@ -396,10 +393,7 @@ fn prepare_intercept_ca_dir() -> Result<Option<PathBuf>> {
         .map(|d| d.subsec_nanos())
         .unwrap_or(0);
     let suffix = format!("{}-{:09}", pid, nanos);
-    let dir = home
-        .join(".nono")
-        .join("sessions")
-        .join(format!("intercept-{}", suffix));
+    let dir = dir.join(format!("intercept-{suffix}"));
     if let Err(e) = std::fs::create_dir_all(&dir) {
         warn!(
             "failed to create TLS-intercept dir '{}': {}; skipping interception",