Session Persistence

Session Persistence

ctrlvim remembers what you had open — the way closing a VS Code window and reopening it restores your tabs, including edits you never saved. This is not a swapfile: ctrlvim-text's buffer storage deliberately dropped Neovim's swapfile/crash-recovery machinery (it's a rope, not a swapfile-backed B-tree). Session persistence is the modern replacement for that gap, built on top of the existing async job/timer infrastructure instead.

Two independent pieces, mirroring the split VS Code itself makes between window.restoreWindows and files.hotExit:

1. Tab / cursor restore

On a clean quit (:q, :qa, :qa!, or Ctrl-C — anything that sets App::should_quit), ctrlvim writes the current project's open-buffer list to disk. The next time you launch cvi in that same project with no file named on the command line, it reopens those buffers, restores the active tab, and restores cursor position per buffer.

cvi some/file.rs behaves like plain Vim — it does not also resurrect an unrelated stale window. Restore only happens on a bare cvi (or cvi some/dir/).

2. Hot-exit recovery (survives a crash, not just a clean quit)

A clean quit gives you a hook to flush state; kill -9 or a power loss doesn't. So for buffers with unsaved changes, ctrlvim also snapshots their live text to disk periodically while running (every 5 seconds, reusing the same poll-tick infrastructure that already drives background job/AI polling — see ctrlvim_async::TimerService).

On restore, any buffer that was marked modified loads from that snapshot instead of the (older) on-disk file — you get your edits back, still marked dirty, ready for :w. The snapshot is cleared automatically once you actually save.

Where it's stored

~/.local/state/ctrlvim/sessions/<sanitized-project-root>/
  index.tsv          # one line per open buffer: path, cursor line, cursor col, modified flag, active flag
  recovery/
    <sanitized-file-path>.txt   # live text of a dirty buffer, present only while it's unsaved

Same convention as the existing per-project pins store (~/.local/state/ctrlvim/pins/) and theme store — the project root is sanitized (non-alphanumeric → _) into the filename, so every project gets its own session file with no collisions.

Managing it from the dashboard

The SESSIONS panel (Dashboard → workspace) shows the current project's row with:

• A + marker (same orange used for a dirty tab in the tabline) when any open buffer has unsaved changes worth keeping — or clearing.
• An [X] control — press X while on the workspace section, or click the badge — that wipes this project's saved tab list and recovery snapshots via App::discard_session(). This only ever touches ctrlvim's own state directory; it never touches your actual files. If you keep editing afterward, the next periodic snapshot just writes fresh state again — it clears what's saved now, it doesn't turn saving off.

Implementation notes (for contributors)

• Buffer (in ctrlvim-tui/src/app.rs) gained a cursor: (usize, usize) field, updated in App::snapshot_active() alongside the existing text/modified caching, and restored in App::load_active_into_engine() via Session::set_cursor_clamped. This is also what fixed cursor position resetting to the top of the file on ordinary tab switches — a pre-existing gap, not something session persistence introduced.
• App::restore_session / App::save_session / App::tick_session_snapshot / App::write_session_state in crates/ctrlvim-tui/src/app.rs.
• Directory helpers (session_dir, sanitize_path_key) in crates/ctrlvim-tui/src/data.rs, following the exact pattern pins_path/pins_path_in already established.
• Wired into crates/ctrlvim-tui/src/main.rs: restore_session() after config load (only when no CLI files given), tick_session_snapshot() in the same poll-tick as poll_jobs/poll_ai, save_session() once after the main loop exits.