diff --git a/docs/superpowers/plans/2026-07-09-library-snapshot-instant-startup.md b/docs/superpowers/plans/2026-07-09-library-snapshot-instant-startup.md
new file mode 100644
index 0000000..c996cd2
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-09-library-snapshot-instant-startup.md
@@ -0,0 +1,479 @@
+# Persistent Library Snapshot — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make the desktop GUI render the last-known library instantly at launch from a persisted snapshot, then background-rescan and swap in the fresh result.
+
+**Architecture:** Serialize the scanned `Vec<library::Channel>` to a JSON blob in a new one-row-per-root SQLite table. On desktop launch, load and seed `self.library` before spawning the (unchanged) background scan thread. The scan stays authoritative and swaps in truth via the existing `library_load_rx` drain, so the snapshot is a display optimization that can only be briefly stale, never wrong.
+
+**Tech Stack:** Rust, rusqlite (r2d2 pool), serde / serde_json (already dependencies), eframe/egui.
+
+## Global Constraints
+
+- Desktop GUI only. Do **not** touch `web.rs` startup or the web in-memory snapshot machinery.
+- Snapshot writes and loads are **error-swallowing / non-fatal** — a failure just means no fresh snapshot next launch (same tolerance as `info_cache_put_many`).
+- The background scan runs unchanged and remains authoritative.
+- New DB schema goes in `init_schema()` as idempotent `CREATE TABLE IF NOT EXISTS` (no migration framework in this repo).
+- Never commit `cookies.txt`, `config.toml`, or `catacomb.db` (gitignored).
+- Commits are SSH-signed: `export SSH_AUTH_SOCK=/tmp/luna-ssh-agent.sock` before `git commit`. End commit messages with `Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>`.
+- Spec: `docs/superpowers/specs/2026-07-09-library-snapshot-instant-startup-design.md`.
+
+---
+
+### Task 1: DB snapshot persistence layer
+
+Make the library structs serializable and add save/load to the DB, fully tested headlessly. Derives are scaffolding for the persistence API, so they live in this task.
+
+**Files:**
+- Modify: `src/library.rs` — add `Serialize, Deserialize` derives to `Subtitle`, `Video`, `Playlist`, `ChannelMeta`, `Channel`; add `#[serde(default)]` to `Video` and `Channel` fields for forward-compat.
+- Modify: `src/database.rs` — add `library_snapshot` table to `init_schema()`; add `save_library_snapshot` + `load_library_snapshot`; add unit tests.
+
+**Interfaces:**
+- Produces:
+  - `Database::save_library_snapshot(&self, root: &std::path::Path, library: &[crate::library::Channel])` — serializes to JSON, `INSERT OR REPLACE` into `library_snapshot`. Error-swallowing (returns `()`).
+  - `Database::load_library_snapshot(&self, root: &std::path::Path) -> Option<Vec<crate::library::Channel>>` — `None` on missing row **or** deserialize failure.
+
+- [ ] **Step 1: Add serde derives to the library structs**
+
+In `src/library.rs`, confirm the serde import at the top of the file (add if absent):
+
+```rust
+use serde::{Deserialize, Serialize};
+```
+
+Change each derive line as follows:
+
+```rust
+// Subtitle
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Subtitle {
+```
+
+```rust
+// Playlist
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Playlist {
+```
+
+```rust
+// ChannelMeta
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ChannelMeta {
+```
+
+For `Video`, add the derives **and** `#[serde(default)]` on every field so old snapshots missing a future field still deserialize:
+
+```rust
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Video {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub title: String,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub stem: String,
+    #[serde(default)]
+    pub video_path: Option<PathBuf>,
+    #[serde(default)]
+    pub thumb_path: Option<PathBuf>,
+    #[serde(default)]
+    pub description_path: Option<PathBuf>,
+    #[serde(default)]
+    pub info_path: Option<PathBuf>,
+    #[serde(default)]
+    pub subtitles: Vec<Subtitle>,
+    #[serde(default)]
+    pub has_live_chat: bool,
+    #[serde(default)]
+    pub duration_secs: Option<f64>,
+    #[serde(default)]
+    pub has_chapters: bool,
+    #[serde(default)]
+    pub file_size: Option<u64>,
+    #[serde(default)]
+    pub mtime_unix: Option<u64>,
+    #[serde(default)]
+    pub upload_date: Option<String>,
+}
+```
+
+For `Channel`, add the derives and `#[serde(default)]` on every field (keep the existing doc comments):
+
+```rust
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Channel {
+    #[serde(default)]
+    pub name: String,
+    #[serde(default)]
+    pub path: PathBuf,
+    #[serde(default)]
+    pub platform: Platform,
+    #[serde(default)]
+    pub source_url: Option<String>,
+    #[serde(default)]
+    pub videos: Vec<Video>,
+    #[serde(default)]
+    pub playlists: Vec<Playlist>,
+    #[serde(default)]
+    pub meta: Option<ChannelMeta>,
+    #[serde(default)]
+    pub total_videos_cached: usize,
+    #[serde(default)]
+    pub total_size_cached: u64,
+    #[serde(default)]
+    pub download_options: DownloadOptions,
+    #[serde(default)]
+    pub folder_id: Option<i64>,
+}
+```
+
+`Platform` uses `#[serde(default)]` on the `Channel.platform` field, which requires `Platform: Default`. If `Platform` does not already derive/impl `Default`, add a default in `src/platform.rs` by annotating the YouTube variant:
+
+```rust
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
+pub enum Platform {
+    #[default]
+    YouTube,
+    // …remaining variants unchanged
+}
+```
+
+(If `Platform` already impls `Default`, leave it as-is.) Confirm `folder_id`'s real type in `src/library.rs` (the tail of the `Channel` struct) and match it exactly — the snippet assumes `Option<i64>`.
+
+- [ ] **Step 2: Verify it compiles**
+
+Run: `cargo build --release 2>&1 | grep -E "^error" | head`
+Expected: no output (no `error` lines). Fix any missing-`Default` / trait errors before proceeding.
+
+- [ ] **Step 3: Write the failing persistence tests**
+
+In `src/database.rs`, inside the existing `#[cfg(test)] mod tests { … }` block (create one at end of file if none exists, with `use super::*;`), add:
+
+```rust
+#[test]
+fn library_snapshot_round_trips() {
+    use crate::library::{Channel, Playlist, Video};
+    use crate::platform::Platform;
+    let db = Database::open_in_memory().unwrap();
+    let root = std::path::Path::new("/tmp/lib-root");
+
+    let video = Video {
+        id: "abc123".into(),
+        title: "Test Video".into(),
+        stem: "Test Video [abc123]".into(),
+        video_path: Some("/tmp/lib-root/channels/Chan/Test [abc123].mp4".into()),
+        thumb_path: None,
+        description_path: None,
+        info_path: None,
+        subtitles: vec![],
+        has_live_chat: false,
+        duration_secs: Some(42.0),
+        has_chapters: true,
+        file_size: Some(1024),
+        mtime_unix: Some(1_700_000_000),
+        upload_date: Some("20250101".into()),
+    };
+    let mut chan = Channel {
+        name: "Chan".into(),
+        path: "/tmp/lib-root/channels/Chan".into(),
+        platform: Platform::YouTube,
+        source_url: Some("https://youtube.com/@chan".into()),
+        videos: vec![video.clone()],
+        playlists: vec![Playlist {
+            name: "PL".into(),
+            path: "/tmp/lib-root/channels/Chan/PL".into(),
+            videos: vec![video.clone()],
+        }],
+        meta: None,
+        total_videos_cached: 2,
+        total_size_cached: 2048,
+        download_options: Default::default(),
+        folder_id: Some(7),
+    };
+    chan.download_options = Default::default();
+
+    let library = vec![chan];
+    db.save_library_snapshot(root, &library);
+    let loaded = db.load_library_snapshot(root).expect("snapshot present");
+    assert_eq!(loaded.len(), 1);
+    assert_eq!(loaded[0].name, "Chan");
+    assert_eq!(loaded[0].videos.len(), 1);
+    assert_eq!(loaded[0].videos[0].id, "abc123");
+    assert_eq!(loaded[0].playlists[0].videos[0].duration_secs, Some(42.0));
+    assert_eq!(loaded[0].folder_id, Some(7));
+}
+
+#[test]
+fn library_snapshot_missing_root_is_none() {
+    let db = Database::open_in_memory().unwrap();
+    assert!(db.load_library_snapshot(std::path::Path::new("/nope")).is_none());
+}
+
+#[test]
+fn library_snapshot_garbage_json_is_none() {
+    let db = Database::open_in_memory().unwrap();
+    let conn = db.conn();
+    conn.execute(
+        "INSERT INTO library_snapshot (root, json, saved_at) VALUES (?1, ?2, ?3)",
+        rusqlite::params!["/tmp/bad", "{not valid json", 0i64],
+    )
+    .unwrap();
+    assert!(db.load_library_snapshot(std::path::Path::new("/tmp/bad")).is_none());
+}
+```
+
+(Adjust the `Video`/`Channel`/`Playlist` field list if the struct in `library.rs` differs from Task 1 Step 1 — the constructor must name every field.)
+
+- [ ] **Step 4: Run the tests to verify they fail**
+
+Run: `cargo test --release library_snapshot 2>&1 | grep -E "error\[|cannot find|test result"`
+Expected: FAIL — compile errors (`no method named save_library_snapshot`/`load_library_snapshot`, and `library_snapshot` table missing).
+
+- [ ] **Step 5: Add the table to `init_schema()`**
+
+In `src/database.rs`, inside `init_schema()`'s `execute_batch(…)` schema string, add:
+
+```sql
+CREATE TABLE IF NOT EXISTS library_snapshot (
+    root      TEXT PRIMARY KEY,
+    json      TEXT NOT NULL,
+    saved_at  INTEGER NOT NULL
+);
+```
+
+- [ ] **Step 6: Implement save/load**
+
+Add these methods to the `impl Database` block in `src/database.rs` (near `info_cache_put_many`):
+
+```rust
+/// Persist the scanned library as a JSON blob keyed by its root path, so the
+/// desktop GUI can render it instantly on the next launch before the (slow,
+/// disk-bound) rescan finishes. Error-swallowing: a failure just means no
+/// fresh snapshot next launch — non-fatal, like `info_cache_put_many`.
+pub fn save_library_snapshot(&self, root: &std::path::Path, library: &[crate::library::Channel]) {
+    let Ok(json) = serde_json::to_string(library) else { return };
+    let root = root.display().to_string();
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs() as i64)
+        .unwrap_or(0);
+    let conn = self.conn();
+    let _ = conn.execute(
+        "INSERT OR REPLACE INTO library_snapshot (root, json, saved_at) VALUES (?1, ?2, ?3)",
+        rusqlite::params![root, json, now],
+    );
+}
+
+/// Load the last-persisted library for `root`. Returns `None` if there is no
+/// snapshot row or the stored JSON no longer deserializes (e.g. after a struct
+/// change) — callers fall back to the scanning state.
+pub fn load_library_snapshot(&self, root: &std::path::Path) -> Option<Vec<crate::library::Channel>> {
+    let root = root.display().to_string();
+    let conn = self.conn();
+    let json: String = conn
+        .query_row(
+            "SELECT json FROM library_snapshot WHERE root = ?1",
+            rusqlite::params![root],
+            |r| r.get(0),
+        )
+        .ok()?;
+    serde_json::from_str(&json).ok()
+}
+```
+
+- [ ] **Step 7: Run the tests to verify they pass**
+
+Run: `cargo test --release library_snapshot 2>&1 | grep "test result"`
+Expected: `test result: ok. 3 passed` (0 failed).
+
+- [ ] **Step 8: Run the full suite for regressions**
+
+Run: `cargo test --release 2>&1 | grep "test result"`
+Expected: both lines `ok`, 0 failed (unit count is now +3, i.e. 137 passed; integration 12 passed).
+
+- [ ] **Step 9: Commit**
+
+```bash
+export SSH_AUTH_SOCK=/tmp/luna-ssh-agent.sock
+git add src/library.rs src/database.rs src/platform.rs
+git commit -m "feat(db): persist library snapshot as JSON blob keyed by root
+
+Add serde derives to the library structs and a library_snapshot table with
+save_library_snapshot/load_library_snapshot. Load returns None on a missing
+row or unparsable JSON. Groundwork for desktop instant startup.
+
+Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 2: Desktop instant-startup wiring
+
+Seed `self.library` from the snapshot at launch, and write the snapshot after every scan. This is egui glue verified by build + a live run (no headless unit test for the frame loop).
+
+**Files:**
+- Modify: `src/app.rs` — in `App::new()` load + seed the snapshot before spawning the libscan thread; write the snapshot in the libscan thread and at the end of `rescan()`.
+
+**Interfaces:**
+- Consumes: `Database::save_library_snapshot`, `Database::load_library_snapshot` (Task 1).
+
+- [ ] **Step 1: Seed the library from the snapshot in `App::new()`**
+
+In `src/app.rs`, `App::new()`, find the block after the DB is opened and before the libscan thread is spawned. It currently reads:
+
+```rust
+        let status = "Scanning library…".to_string();
+        {
+            let db = db.clone();
+            let channels_root = channels_root.clone();
+            let ctx = cc.egui_ctx.clone();
+```
+
+Replace the `let status = …;` line with a snapshot load that seeds both `library` and `status`:
+
+```rust
+        // Instant startup: if we persisted the library last run, show it
+        // immediately while the (slow, disk-bound) rescan runs in the
+        // background and swaps in fresh data via `library_load_rx`.
+        let seeded_library: Vec<library::Channel> =
+            db.load_library_snapshot(&channels_root).unwrap_or_default();
+        let status = if seeded_library.is_empty() {
+            "Scanning library…".to_string()
+        } else {
+            format!(
+                "{} channels, {} videos (refreshing…)",
+                seeded_library.len(),
+                seeded_library.iter().map(|c| c.total_videos()).sum::<usize>()
+            )
+        };
+        {
+            let db = db.clone();
+            let channels_root = channels_root.clone();
+            let ctx = cc.egui_ctx.clone();
+```
+
+- [ ] **Step 2: Use the seeded library for the struct field**
+
+Still in `App::new()`, find the line (a bit below the thread block):
+
+```rust
+        let library: Vec<library::Channel> = Vec::new();
+```
+
+Replace it with:
+
+```rust
+        let library: Vec<library::Channel> = seeded_library;
+```
+
+(`self.library` is assigned from this local in the `Self { … library, … }` literal. The scanning-state guard `library_load_rx.is_some() && self.library.is_empty()` now naturally yields to a seeded library — a populated `self.library` skips the spinner and renders instantly.)
+
+- [ ] **Step 3: Write the snapshot from the libscan thread**
+
+Still in `App::new()`, in the spawned libscan thread body, locate:
+
+```rust
+                    if let Err(e) = db.sync_search_index(&library::build_search_entries(&library)) {
+                        eprintln!("search index sync failed: {e}");
+                    }
+                    let _ = library_load_tx.send(library);
+                    ctx.request_repaint(); // wake update() to swap the result in
+```
+
+Insert a snapshot write **before** the `send` (which moves `library`):
+
+```rust
+                    if let Err(e) = db.sync_search_index(&library::build_search_entries(&library)) {
+                        eprintln!("search index sync failed: {e}");
+                    }
+                    db.save_library_snapshot(&channels_root, &library);
+                    let _ = library_load_tx.send(library);
+                    ctx.request_repaint(); // wake update() to swap the result in
+```
+
+(`channels_root` and `db` are already the thread's cloned copies.)
+
+- [ ] **Step 4: Write the snapshot at the end of `rescan()`**
+
+In `src/app.rs`, `fn rescan(&mut self)`, find the closing status assignment:
+
+```rust
+        self.status = format!(
+            "Rescanned: {} channels, {} videos",
+            self.library.len(),
+            self.library.iter().map(|c| c.total_videos()).sum::<usize>()
+        );
+    }
+```
+
+Insert a snapshot write just before the `self.status = …`:
+
+```rust
+        self.db.save_library_snapshot(&self.channels_root, &self.library);
+        self.status = format!(
+            "Rescanned: {} channels, {} videos",
+            self.library.len(),
+            self.library.iter().map(|c| c.total_videos()).sum::<usize>()
+        );
+    }
+```
+
+- [ ] **Step 5: Build**
+
+Run: `cargo build --release 2>&1 | grep -E "^error" | head`
+Expected: no output. (Ignore the ~39 upstream egui `f32: From<f64>` warnings.)
+
+- [ ] **Step 6: Full test suite**
+
+Run: `cargo test --release 2>&1 | grep "test result"`
+Expected: both lines `ok`, 0 failed.
+
+- [ ] **Step 7: Manual verification against the real library**
+
+The frame loop can't be unit-tested; verify live. Reproduction recipe (Wayland/KWin box; foreground `sleep` is blocked in the harness Bash tool, so put launch+wait+capture in a script file and run that):
+
+1. **First launch after building** (snapshot table exists but is empty for this root the first time, OR carries the previous run's data): run the GUI with `CWD=/home/luna` (its `config.toml` points at the real library), XWayland forced:
+   ```bash
+   env -u WAYLAND_DISPLAY WINIT_UNIX_BACKEND=x11 DISPLAY=:0 \
+     /home/luna/code/catacomb/target/release/catacomb
+   ```
+   Let it finish one full scan and quit (this writes a fresh snapshot).
+2. **Second launch:** run it again the same way and screenshot within ~2s of the window appearing (`xdotool search --pid`, `windowactivate`+`windowraise`+two `mousemove --window` nudges, then `import -window <wid> out.png`).
+   - Expected: the library list is **already populated** (channels + videos visible), status shows `"… (refreshing…)"`, **no** "Scanning library…" spinner. A moment later the background scan lands and the status flips to `"N channels, M videos"`.
+3. **First-ever launch (no snapshot):** `DELETE FROM library_snapshot;` via `sqlite3 <backup.directory>/catacomb.db` (or test in a throwaway dir), relaunch — expected: the Step-1 "Scanning library…" spinner shows, then populates. Confirms the fallback still works.
+
+Record the two screenshots (seeded-instant and scanning-fallback) in the session scratchpad as evidence.
+
+- [ ] **Step 8: Commit**
+
+```bash
+export SSH_AUTH_SOCK=/tmp/luna-ssh-agent.sock
+git add src/app.rs
+git commit -m "feat(desktop): instant startup from persisted library snapshot
+
+Seed self.library from load_library_snapshot before spawning the scan thread,
+so a warm launch renders the library immediately (status '… refreshing…')
+instead of a blank/scanning window. Write the snapshot after every scan (the
+startup thread and rescan). The background scan is unchanged and still swaps
+in authoritative data; the snapshot only ever shows briefly-stale state.
+
+Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
+```
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+- Data model (`library_snapshot` table) → Task 1 Step 5. ✓
+- Serialization (derives + `#[serde(default)]`) → Task 1 Step 1. ✓
+- Write path (`save_library_snapshot`, both finalization points) → Task 1 Step 6, Task 2 Steps 3–4. ✓
+- Read/seed path (`load_library_snapshot`, seed before spawn) → Task 1 Step 6, Task 2 Steps 1–2. ✓
+- Edge cases: garbage JSON → None (Task 1 Step 3 test); root mismatch (keyed by root, Task 1 Step 6); struct evolution (`#[serde(default)]`, Task 1 Step 1). ✓
+- Testing: round-trip / missing / garbage unit tests (Task 1) + manual seeded-vs-fallback verification (Task 2 Step 7). ✓
+- Interaction with Step 1 scanning state (seeded library skips the spinner) → Task 2 Step 2 note. ✓
+
+**Placeholder scan:** none — all steps carry concrete code/commands. The one conditional ("if `Platform` already impls `Default`") is a real branch with both outcomes specified.
+
+**Type consistency:** `save_library_snapshot(&self, root: &Path, library: &[Channel])` and `load_library_snapshot(&self, root: &Path) -> Option<Vec<Channel>>` are named and typed identically in Task 1 (definition) and Task 2 (call sites). Snapshot written before `send` moves `library`. ✓