diff --git a/crates/snowbound/src/main.rs b/crates/snowbound/src/main.rs
index 5aab659e493d1bb8a6f24c17f64e19de201386d9..769853cc4bf9b254a1441c15056cf406c5320a41 100644
--- a/crates/snowbound/src/main.rs
+++ b/crates/snowbound/src/main.rs
@@ -1039,23 +1039,32 @@ impl State {
                         library.purge_recycle_bin();
                     }
                 }
+                // Where the notebook was left, or its first section.
                 let shown = notebooks
                     .iter()
                     .filter(|library| Some(&library.location) == current.as_ref())
                     .chain(&notebooks)
-                    .find_map(|library| Some((library, library.first_section()?)));
+                    .find_map(|library| {
+                        let left = stored.recent.iter().find(|place| {
+                            place.notebook == library.location && library.contains(&place.section)
+                        });
+                        match left {
+                            Some(place) => Some((library, place.section.clone(), Some(place.page))),
+                            None => Some((library, library.first_section()?, None)),
+                        }
+                    });
                 match shown {
-                    Some((library, path)) if !library.locked(&path) => {
+                    Some((library, path, left)) if !library.locked(&path) => {
                         let section = library.open(&path, notify(proxy.clone()))?;
                         let (opened, page) =
-                            read_session(section, Arc::clone(library), path, None)?;
+                            read_session(section, Arc::clone(library), path, left)?;
                         let (scene, editor) = PageScene::from_page(page, &mut engine)?;
                         session = Some(opened);
                         (editor, Some((scene, [0.0; 2])))
                     }
                     shown => {
                         // A first section still locked shows its locked page.
-                        locked = shown.map(|(library, path)| protection::Locked {
+                        locked = shown.map(|(library, path, _)| protection::Locked {
                             library: Arc::clone(library),
                             path,
                         });
@@ -1228,7 +1237,9 @@ impl State {
             opening: None,
             switching: None,
             places: HashMap::new(),
-            last_pages: HashMap::new(),
+            last_pages: (stored.recent.iter().rev())
+                .map(|place| (library::key(&place.notebook, &place.section), place.page))
+                .collect(),
             trail: {
                 let mut trail = navigation::Trail::default();
                 trail.recent = stored.recent;
diff --git a/crates/snowbound/src/settings.rs b/crates/snowbound/src/settings.rs
index 569cd42bed2fe5b6812132af90cd4e9785c81d0f..55518123a37062e05177d016933d8c6587090826 100644
--- a/crates/snowbound/src/settings.rs
+++ b/crates/snowbound/src/settings.rs
@@ -46,7 +46,7 @@ pub struct Settings {
     pub servers: Vec<String>,
     /// Chords set in Options' Keyboard, by command, each list in place of its defaults.
     pub keys: std::collections::BTreeMap<String, Vec<String>>,
-    /// Pages shown lately, latest first, which the palette lists first.
+    /// Pages shown lately, latest first, which the palette lists first and a launch returns to.
     pub recent: Vec<crate::navigation::Place>,
     pub passwords: Passwords,
 }
diff --git a/crates/snowbound/src/sidebar.rs b/crates/snowbound/src/sidebar.rs
index 743fddbe1588504d3d60c74e061bbbea01c217a1..140ce8754ba58f5897bf2dc0c1f32a92679b739d 100644
--- a/crates/snowbound/src/sidebar.rs
+++ b/crates/snowbound/src/sidebar.rs
@@ -1100,8 +1100,8 @@ impl crate::State {
         self.read_notebook(location, section, open, read);
     }
 
-    /// Shows `section`, or the first section, of the notebook at `location`, `open` or read
-    /// with `read`, in place of the notebook listed there.
+    /// Shows `section`, or where it was left, or the first section, of the notebook at
+    /// `location`, `open` or read with `read`, in place of the notebook listed there.
     pub(crate) fn read_notebook(
         &mut self,
         location: String,
@@ -1109,6 +1109,15 @@ impl crate::State {
         open: Option<Arc<Library>>,
         read: impl FnOnce(&str, &std::path::Path) -> Result<Library, String> + Send + 'static,
     ) {
+        let section = section.or_else(|| {
+            (self.trail.recent.iter())
+                .find(|place| place.notebook == location)
+                .map(|place| place.section.clone())
+        });
+        let left = section
+            .as_ref()
+            .and_then(|path| self.last_pages.get(&crate::library::key(&location, path)))
+            .copied();
         let (cache, notify) = (self.cache.clone(), crate::notify(self.proxy.clone()));
         self.load(move || {
             let library = match open {
@@ -1122,9 +1131,10 @@ impl crate::State {
             if let Err(error) = &library.notebook {
                 return Err(error.clone().into());
             }
-            let Some(path) = section
+            let Some((path, left)) = section
                 .filter(|path| library.contains(path))
-                .or_else(|| library.first_section())
+                .map(|path| (path, left))
+                .or_else(|| Some((library.first_section()?, None)))
             else {
                 // Shown once its sections arrive.
                 if library.downloading() {
@@ -1133,7 +1143,7 @@ impl crate::State {
                 return Err("This folder holds no notebook sections.".into());
             };
             let section = library.open(&path, notify)?;
-            let (session, page) = crate::read_session(section, library, path, None)?;
+            let (session, page) = crate::read_session(section, library, path, left)?;
             Ok(crate::Loaded::Section(Box::new(session), page))
         });
     }
diff --git a/crates/snowbound/tests/replay.rs b/crates/snowbound/tests/replay.rs
index 5e19e767a0881677c33a52b734045914410cec8e..b867e7bb24f1d887ff62a3b0771c3ac9c15601d3 100644
--- a/crates/snowbound/tests/replay.rs
+++ b/crates/snowbound/tests/replay.rs
@@ -12,6 +12,11 @@ impl Scratch {
         let path = std::env::temp_dir().join(format!("snowbound-{name}-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&path);
         std::fs::create_dir_all(path.join("notebook")).unwrap();
+        std::fs::write(
+            path.join("settings.json"),
+            r#"{"user_name": "Snowbound Test"}"#,
+        )
+        .unwrap();
         Self(path)
     }
 }
@@ -22,7 +27,8 @@ impl Drop for Scratch {
     }
 }
 
-/// Runs `steps` against a copy of `notebook`'s files, then returns the trees each
+/// Runs `steps` against a copy of `notebook`'s files with the scratch's settings, then
+/// returns the trees each
 /// `accessibility` step named by the trailing word wrote.
 fn replay(scratch: &Scratch, notebook: Option<&Path>, steps: &[&str]) -> Vec<String> {
     let dir = &scratch.0;
@@ -46,11 +52,6 @@ fn replay(scratch: &Scratch, notebook: Option<&Path>, steps: &[&str]) -> Vec<Str
     }
     script += "quit\n";
     std::fs::write(dir.join("script"), script).unwrap();
-    std::fs::write(
-        dir.join("settings.json"),
-        r#"{"user_name": "Snowbound Test"}"#,
-    )
-    .unwrap();
     let status = Command::new(env!("CARGO_BIN_EXE_snowbound"))
         .env("SNOWBOUND_REPLAY", dir.join("script"))
         .arg("--notebook")
@@ -389,3 +390,45 @@ fn the_find_bar_keeps_room_for_the_query() {
         "{found}"
     );
 }
+
+/// A launch shows the page each notebook was left on, as the settings recall them: the
+/// notebook shown at once, and another as its section is opened.
+#[test]
+fn a_launch_returns_to_the_page_each_notebook_was_left_on() {
+    let scratch = Scratch::new("left-on");
+    let source =
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus/cross-container/candidate");
+    let other = scratch.0.join("other");
+    std::fs::create_dir_all(&other).unwrap();
+    for entry in std::fs::read_dir(&source).unwrap() {
+        let entry = entry.unwrap();
+        std::fs::copy(entry.path(), other.join(entry.file_name())).unwrap();
+    }
+    let place = |notebook: &Path, page: &str| serde_json::json!({"notebook": notebook, "section": "Cross.one", "page": page});
+    let settings = serde_json::json!({
+        "user_name": "Snowbound Test",
+        "sidebar": true,
+        "notebooks": [other],
+        "recent": [
+            // Type over a row, then Delete a whole table.
+            place(&scratch.0.join("notebook"), "{F8285B5C-5410-4A62-B7DC-43E408FE82AE},1"),
+            place(&other, "{9F114CE9-F7D5-4234-B7C3-FF0D79615BB2},1"),
+        ],
+    });
+    std::fs::write(scratch.0.join("settings.json"), settings.to_string()).unwrap();
+    // The other notebook's section in the sidebar.
+    let mut steps = vec!["accessibility launched", "move 63 104", "press", "release"];
+    steps.extend(["wait 4000", "accessibility other"]);
+    let shown = |tree: &str| page_tabs(tree).into_iter().find(|tab| tab.starts_with('*'));
+    let [launched, other] = replay(&scratch, Some(&source), &steps).try_into().unwrap();
+    assert_eq!(
+        shown(&launched).as_deref(),
+        Some("*Type over a row"),
+        "{launched}"
+    );
+    assert_eq!(
+        shown(&other).as_deref(),
+        Some("*Delete a whole table"),
+        "{other}"
+    );
+}