diff --git a/src-tauri/src/db/schema.rs b/src-tauri/src/db/schema.rs
index c0cd54fa..f15b0ff5 100644
--- a/src-tauri/src/db/schema.rs
+++ b/src-tauri/src/db/schema.rs
@@ -2,7 +2,7 @@ use rusqlite::{params, Connection};
 
 use crate::error::AppResult;
 
-const SCHEMA_VERSION: u32 = 32;
+const SCHEMA_VERSION: u32 = 33;
 
 fn column_exists(conn: &Connection, table: &str, col: &str) -> AppResult<bool> {
     let mut stmt = conn.prepare("SELECT 1 FROM pragma_table_info(?1) WHERE name = ?2")?;
@@ -692,6 +692,23 @@ pub fn migrate(conn: &Connection) -> AppResult<()> {
         }
     }
 
+    if version < 33 && table_exists(conn, "settings")? {
+        conn.execute_batch(
+            "INSERT INTO settings (key, value) VALUES (
+                 'startup_action',
+                 CASE
+                     WHEN (SELECT value FROM settings WHERE key = 'session_restore.enabled') = 'true'
+                         THEN 'restore'
+                     WHEN (SELECT value FROM settings WHERE key = 'open_local_on_startup') = 'true'
+                         THEN 'local'
+                     ELSE 'home'
+                 END
+             ) ON CONFLICT(key) DO NOTHING;
+             DELETE FROM settings
+             WHERE key IN ('session_restore.enabled', 'open_local_on_startup');",
+        )?;
+    }
+
     if version < SCHEMA_VERSION {
         conn.pragma_update(None, "user_version", SCHEMA_VERSION)?;
     }
@@ -701,6 +718,175 @@ pub fn migrate(conn: &Connection) -> AppResult<()> {
 
 #[cfg(test)]
 mod tests {
+    fn startup_settings_fixture(restore: Option<&str>, local: Option<&str>) -> Connection {
+        let conn = Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+             PRAGMA user_version = 32;",
+        )
+        .unwrap();
+        for (key, value) in [
+            ("session_restore.enabled", restore),
+            ("open_local_on_startup", local),
+        ] {
+            if let Some(value) = value {
+                conn.execute(
+                    "INSERT INTO settings (key, value) VALUES (?1, ?2)",
+                    params![key, value],
+                )
+                .unwrap();
+            }
+        }
+        conn
+    }
+
+    #[test]
+    fn migration_33_defaults_new_databases_to_home() {
+        let conn = Connection::open_in_memory().unwrap();
+
+        migrate(&conn).unwrap();
+        migrate(&conn).unwrap();
+
+        let action: String = conn
+            .query_row(
+                "SELECT value FROM settings WHERE key = 'startup_action'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(action, "home");
+    }
+
+    #[test]
+    fn migration_33_combines_startup_flags_and_preserves_the_snapshot() {
+        let cases = [
+            (None, None, "home"),
+            (None, Some("false"), "home"),
+            (None, Some("true"), "local"),
+            (Some("false"), None, "home"),
+            (Some("false"), Some("false"), "home"),
+            (Some("false"), Some("true"), "local"),
+            (Some("true"), None, "restore"),
+            (Some("true"), Some("false"), "restore"),
+            (Some("true"), Some("true"), "restore"),
+        ];
+        let snapshot = r#"{"version":1,"terminals":[{"type":"local"}],"active":0}"#;
+        for (restore, local, expected) in cases {
+            let conn = startup_settings_fixture(restore, local);
+            conn.execute(
+                "INSERT INTO settings (key, value) VALUES ('session_restore.snapshot', ?1)",
+                [snapshot],
+            )
+            .unwrap();
+
+            migrate(&conn).unwrap();
+            migrate(&conn).unwrap();
+
+            let settings: Vec<(String, String)> = conn
+                .prepare("SELECT key, value FROM settings ORDER BY key")
+                .unwrap()
+                .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
+                .unwrap()
+                .collect::<Result<_, _>>()
+                .unwrap();
+            assert_eq!(
+                settings,
+                vec![
+                    ("session_restore.snapshot".into(), snapshot.into()),
+                    ("startup_action".into(), expected.into()),
+                ],
+                "restore={restore:?}, local={local:?}",
+            );
+            let version: u32 = conn
+                .pragma_query_value(None, "user_version", |row| row.get(0))
+                .unwrap();
+            assert_eq!(version, SCHEMA_VERSION);
+        }
+    }
+
+    #[test]
+    fn migration_33_preserves_existing_startup_actions_and_later_user_changes() {
+        for current in ["home", "local", "restore", "", "unknown"] {
+            let conn = startup_settings_fixture(Some("true"), Some("true"));
+            conn.execute(
+                "INSERT INTO settings (key, value) VALUES ('startup_action', ?1)",
+                [current],
+            )
+            .unwrap();
+
+            migrate(&conn).unwrap();
+
+            let action: String = conn
+                .query_row(
+                    "SELECT value FROM settings WHERE key = 'startup_action'",
+                    [],
+                    |row| row.get(0),
+                )
+                .unwrap();
+            assert_eq!(action, current);
+            let count: u32 = conn
+                .query_row("SELECT COUNT(*) FROM settings", [], |row| row.get(0))
+                .unwrap();
+            assert_eq!(count, 1);
+
+            conn.execute(
+                "UPDATE settings SET value = 'local' WHERE key = 'startup_action'",
+                [],
+            )
+            .unwrap();
+            migrate(&conn).unwrap();
+            let action: String = conn
+                .query_row(
+                    "SELECT value FROM settings WHERE key = 'startup_action'",
+                    [],
+                    |row| row.get(0),
+                )
+                .unwrap();
+            assert_eq!(action, "local");
+        }
+    }
+
+    #[test]
+    fn migration_33_rolls_back_if_legacy_key_cleanup_fails() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("rssh.db");
+        let conn = Connection::open(&path).unwrap();
+        conn.execute_batch(
+            "CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+             INSERT INTO settings (key, value) VALUES
+                 ('session_restore.enabled', 'true'),
+                 ('open_local_on_startup', 'true');
+             CREATE TRIGGER reject_startup_cleanup
+             BEFORE DELETE ON settings WHEN OLD.key = 'open_local_on_startup'
+             BEGIN SELECT RAISE(ABORT, 'cleanup failed'); END;
+             PRAGMA user_version = 32;",
+        )
+        .unwrap();
+        drop(conn);
+
+        assert!(crate::db::Db::open(dir.path()).is_err());
+
+        let conn = Connection::open(path).unwrap();
+        let settings: Vec<(String, String)> = conn
+            .prepare("SELECT key, value FROM settings ORDER BY key")
+            .unwrap()
+            .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
+            .unwrap()
+            .collect::<Result<_, _>>()
+            .unwrap();
+        assert_eq!(
+            settings,
+            vec![
+                ("open_local_on_startup".into(), "true".into()),
+                ("session_restore.enabled".into(), "true".into()),
+            ],
+        );
+        let version: u32 = conn
+            .pragma_query_value(None, "user_version", |row| row.get(0))
+            .unwrap();
+        assert_eq!(version, 32);
+    }
+
     #[test]
     fn migration_32_preserves_groups_and_defaults_group_waves_to_disabled() {
         let conn = rusqlite::Connection::open_in_memory().unwrap();
@@ -723,7 +909,7 @@ mod tests {
         let version: u32 = conn
             .pragma_query_value(None, "user_version", |row| row.get(0))
             .unwrap();
-        assert_eq!(version, 32);
+        assert_eq!(version, SCHEMA_VERSION);
         assert!(!super::column_exists(&conn, "groups", "terminal_background").unwrap());
     }
 
@@ -790,7 +976,7 @@ mod tests {
         let version: u32 = conn
             .pragma_query_value(None, "user_version", |row| row.get(0))
             .unwrap();
-        assert_eq!(version, 32);
+        assert_eq!(version, SCHEMA_VERSION);
     }
 
     #[test]
@@ -833,7 +1019,7 @@ mod tests {
             let version: u32 = conn
                 .pragma_query_value(None, "user_version", |row| row.get(0))
                 .unwrap();
-            assert_eq!(version, 32);
+            assert_eq!(version, SCHEMA_VERSION);
         }
     }
     use super::*;
diff --git a/src/lib/components/AppShell.svelte b/src/lib/components/AppShell.svelte
index 6adc6fb1..f2debd5c 100644
--- a/src/lib/components/AppShell.svelte
+++ b/src/lib/components/AppShell.svelte
@@ -4,6 +4,7 @@
     import {getCurrentWindow} from "@tauri-apps/api/window";
     import type {Profile, Tab, Group} from "../stores/app.svelte.ts";
     import * as app from "../stores/app.svelte.ts";
+    import * as startupSettings from "../stores/startup.svelte.ts";
     import * as layout from "../stores/layout.svelte.ts";
     import * as updates from "../stores/updates.svelte.ts";
     import * as syncStatus from "../stores/sync.svelte.ts";
@@ -87,12 +88,9 @@
         try {
             await initializePrimarySessionWindow({
                 signal: startup.signal,
-                canOpenLocal: app.capabilities().localPty,
                 reconcile: () => invoke("reconcile_sessions", { activeIds: [] }),
                 allowResourcePanes: () => { resourcePanesAllowed = true; },
-                loadAutoOpenLocal: async () =>
-                    await invoke<string | null>("get_setting", { key: "open_local_on_startup" }) === "true",
-                openLocal: addLocalTab,
+                runStartupAction: () => startupSettings.run(startup.signal),
             });
         } catch (error) {
             if (!startup.signal.aborted) startupError = errMsg(error);
@@ -101,6 +99,11 @@
         }
     }
     let navigationLoad = 0;
+    function persistSessionSnapshot() {
+        if (bypassStartupReconcile || !startupSettings.ready()) return;
+        void startupSettings.persist(startupSettings.snapshot());
+    }
+    $effect(persistSessionSnapshot);
     $effect(() => {
         const tabs = app.tabs();
         for (const paneId of Object.keys(pendingPaneSources)) {
@@ -1253,7 +1256,7 @@
     }
 </script>
 
-<svelte:window onkeydown={handleKeydown}/>
+<svelte:window onkeydown={handleKeydown} onfocus={persistSessionSnapshot}/>
 
 {#if app.snippetPickerOpen()}
     <SnippetPicker />
diff --git a/src/lib/components/ShellSettings.svelte b/src/lib/components/ShellSettings.svelte
index 2d51c4db..bb42437d 100644
--- a/src/lib/components/ShellSettings.svelte
+++ b/src/lib/components/ShellSettings.svelte
@@ -2,9 +2,12 @@
   import { onMount } from "svelte";
   import { invoke } from "@tauri-apps/api/core";
   import * as app from "../stores/app.svelte.ts";
+  import * as startup from "../stores/startup.svelte.ts";
+  import type { StartupAction } from "../stores/startup.svelte.ts";
   import * as transfers from "../stores/transfers.svelte.ts";
   import { isMac } from "../stores/keymap.svelte.ts";
-  import { t } from "../i18n/index.svelte.ts";
+  import { t, errMsg } from "../i18n/index.svelte.ts";
+  import { toast } from "../stores/toast.svelte.ts";
   import Select from "./Select.svelte";
   import Modal from "./Modal.svelte";
 
@@ -15,8 +18,8 @@
   /** 用户选了 Custom 但还没填路径的瞬态标记 —— 不持久化。
    *  避免把占位字符串写进 local_shell 设置导致重启坏 shell。 */
   let pendingCustom = $state(false);
-  /** Auto-open one local terminal on startup — default off (unset reads as off). */
-  let openLocalOnStartup = $state(false);
+  let startupAction = $state<StartupAction | null>(null);
+  let startupBusy = $state(false);
   let verboseLog = $state(true);
   let connectTimeout = $state(10);
   let copyOnSelect = $state(false);
@@ -30,6 +33,11 @@
     { value: "paste", label: t("settings.shell.right_click_paste") },
     { value: "copyPaste", label: t("settings.shell.right_click_copy_paste") },
   ]);
+  let startupOptions = $derived([
+    { value: "restore", label: t("settings.shell.startup_restore") },
+    ...(shells.length ? [{ value: "local", label: t("settings.shell.startup_local") }] : []),
+    { value: "home", label: t("settings.shell.startup_home") },
+  ]);
   /** SFTP 并发上限。main.ts 启动时 loadMaxConcurrent 已写过 store，
    *  这里 onMount 再读一次显示当前值。 */
   let sftpMaxConcurrent = $state(transfers.maxConcurrent());
@@ -40,13 +48,12 @@
   let customMode = $derived(pendingCustom || (selectedShell !== "" && !shells.includes(selectedShell)));
 
   onMount(async () => {
+    await loadStartup();
     if (app.capabilities().localPty) {
-      try { shells = await invoke<string[]>("list_shells"); } catch { shells = []; }
       selectedShell = await invoke<string | null>("get_setting", { key: "local_shell" }) ?? "";
       if (selectedShell && !shells.includes(selectedShell)) {
         customPath = selectedShell;
       }
-      openLocalOnStartup = (await invoke<string | null>("get_setting", { key: "open_local_on_startup" })) === "true";
     }
     verboseLog = (await invoke<string | null>("get_setting", { key: "verbose_log" })) !== "false";
     const ts = await invoke<string | null>("get_setting", { key: "connect_timeout" });
@@ -97,8 +104,31 @@
     await invoke("set_setting", { key: "verbose_log", value: String(verboseLog) });
   }
 
-  async function saveOpenLocalOnStartup() {
-    await invoke("set_setting", { key: "open_local_on_startup", value: String(openLocalOnStartup) });
+  async function loadStartup() {
+    if (startupBusy) return;
+    startupBusy = true;
+    try {
+      const [action, availableShells] = await Promise.all([startup.action(), startup.availableShells()]);
+      shells = availableShells;
+      startupAction = action === "local" && !shells.length ? "home" : action;
+    } catch (error) {
+      startupAction = null;
+      toast.error(errMsg(error));
+    } finally {
+      startupBusy = false;
+    }
+  }
+
+  async function saveStartup(action: StartupAction) {
+    startupBusy = true;
+    try {
+      await startup.setAction(action);
+    } catch (error) {
+      toast.error(errMsg(error));
+    } finally {
+      startupBusy = false;
+      await loadStartup();
+    }
   }
 
   async function saveTimeout() {
@@ -150,10 +180,14 @@
   }
 </script>
 
+<svelte:window onfocus={loadStartup} />
+
 <div class="page">
   {#if app.capabilities().localPty}
     <div class="section-label" id="local-shell-label">{t("settings.shell.local_shell")}</div>
-    <div class="card surface-raised shell-card">
+  {/if}
+  <div class="card surface-raised shell-card">
+    {#if app.capabilities().localPty}
       <div class="shell-hint">
         {t("settings.shell.pick_hint")}
       </div>
@@ -192,49 +226,63 @@
         </div>
       </div>
       <div class="card-divider"></div>
-      <div class="cmd-block-head">
-        <div class="cmd-block-head-body">
-          <div class="cmd-block-title" class:on={openLocalOnStartup} class:off={!openLocalOnStartup}>{t("settings.shell.open_local_on_startup")}</div>
-          <div class="cmd-block-desc">{t("settings.shell.open_local_on_startup_desc")}</div>
-        </div>
-        <label class="switch">
-          <input type="checkbox" bind:checked={openLocalOnStartup} onchange={saveOpenLocalOnStartup} />
-          <span class="slider"></span>
-        </label>
+    {/if}
+    <div class="cmd-block-head action-row">
+      <div class="cmd-block-head-body">
+        <label for="startup-action" class="cmd-block-title">{t("settings.shell.startup_action")}</label>
+        {#if startupAction === "restore"}
+          <div class="cmd-block-desc">{t("settings.shell.startup_restore_desc")}</div>
+        {/if}
+      </div>
+      <div class="action-select">
+        <Select id="startup-action" bind:value={startupAction} options={startupOptions}
+          disabled={startupBusy || startupAction === null}
+          placeholder={startupBusy ? t("common.loading") : ""}
+          onchange={(value) => saveStartup(value as StartupAction)} />
       </div>
     </div>
-  {/if}
-
-  <div class="section-label">{t("settings.shell.connection_timeout")}</div>
-  <div class="timeout-row">
-    <label>{t("settings.shell.timeout_label")}</label>
-    <input type="number" bind:value={connectTimeout} min="1" max="300" onblur={saveTimeout}
-      onkeydown={(e) => { if (e.key === "Enter") saveTimeout(); }} />
-    <span class="timeout-hint">{t("settings.shell.timeout_hint")}</span>
   </div>
 
-  <div class="section-label">{t("settings.shell.sftp_concurrent")}</div>
-  <div class="timeout-row">
-    <label>{t("settings.shell.sftp_concurrent_label")}</label>
-    <input type="number" bind:value={sftpMaxConcurrent}
-      min={sftpBounds.min} max={sftpBounds.max}
-      onblur={saveSftpMaxConcurrent}
-      onkeydown={(e) => { if (e.key === "Enter") saveSftpMaxConcurrent(); }} />
-    <span class="timeout-hint">{t("settings.shell.sftp_concurrent_hint", {
-      min: sftpBounds.min, max: sftpBounds.max, def: sftpBounds.def,
-    })}</span>
-  </div>
+  <div class="section-label">{t("settings.shell.connection_settings")}</div>
+  <div class="card surface-raised connection-card">
+    <div class="cmd-block-head">
+      <div class="cmd-block-head-body">
+        <label for="connect-timeout" class="cmd-block-title">{t("settings.shell.timeout_label")}</label>
+        <div id="connect-timeout-hint" class="cmd-block-desc">{t("settings.shell.timeout_hint")}</div>
+      </div>
+      <input id="connect-timeout" type="number" bind:value={connectTimeout} min="1" max="300"
+        aria-describedby="connect-timeout-hint" onblur={saveTimeout}
+        onkeydown={(e) => { if (e.key === "Enter") saveTimeout(); }} />
+    </div>
+
+    <div class="card-divider"></div>
 
-  <div class="section-label">{t("settings.shell.connection_logging")}</div>
-  <div class="switch-card">
-    <div class="switch-card-body">
-      <div class="switch-card-title" class:on={verboseLog} class:off={!verboseLog}>{t("settings.shell.verbose_log")}</div>
-      <div class="switch-card-desc">{t("settings.shell.verbose_log_desc")}</div>
+    <div class="cmd-block-head">
+      <div class="cmd-block-head-body">
+        <label for="sftp-concurrent" class="cmd-block-title">{t("settings.shell.sftp_concurrent_label")}</label>
+        <div id="sftp-concurrent-hint" class="cmd-block-desc">{t("settings.shell.sftp_concurrent_hint", {
+          min: sftpBounds.min, max: sftpBounds.max, def: sftpBounds.def,
+        })}</div>
+      </div>
+      <input id="sftp-concurrent" type="number" bind:value={sftpMaxConcurrent}
+        min={sftpBounds.min} max={sftpBounds.max} aria-describedby="sftp-concurrent-hint"
+        onblur={saveSftpMaxConcurrent}
+        onkeydown={(e) => { if (e.key === "Enter") saveSftpMaxConcurrent(); }} />
+    </div>
+
+    <div class="card-divider"></div>
+
+    <div class="cmd-block-head">
+      <div class="cmd-block-head-body">
+        <label for="ssh-connection-log" class="cmd-block-title" class:on={verboseLog} class:off={!verboseLog}>{t("settings.shell.verbose_log")}</label>
+        <div id="ssh-connection-log-hint" class="cmd-block-desc">{t("settings.shell.verbose_log_desc")}</div>
+      </div>
+      <label class="switch">
+        <input id="ssh-connection-log" type="checkbox" bind:checked={verboseLog}
+          aria-describedby="ssh-connection-log-hint" onchange={saveVerbose} />
+        <span class="slider"></span>
+      </label>
     </div>
-    <label class="switch">
-      <input type="checkbox" bind:checked={verboseLog} onchange={saveVerbose} />
-      <span class="slider"></span>
-    </label>
   </div>
 
   <div class="section-label">{t("settings.shell.interaction")}</div>
@@ -267,12 +315,12 @@
 
     <div class="card-divider"></div>
 
-    <div class="cmd-block-head">
+    <div class="cmd-block-head action-row">
       <div class="cmd-block-head-body">
         <label for="rca-select" class="cmd-block-title">{t("settings.shell.right_click")}</label>
         <div class="cmd-block-desc">{t("settings.shell.right_click_desc")}</div>
       </div>
-      <div class="rca-select">
+      <div class="action-select">
         <Select id="rca-select" bind:value={rightClickAction}
                 options={rightClickOptions}
                 onchange={(v) => saveRightClickAction(v as app.RightClickAction)} />
@@ -317,6 +365,7 @@
   /* 卡片：复用全局 .card.surface-raised，本地只加 padding + 内布局，
      跟 SyncScreen / AiSettings 同款。 */
   .shell-card,
+  .connection-card,
   .mouse-card {
     padding: 18px;
     display: flex;
@@ -415,18 +464,15 @@
   .custom-input:focus { outline: none; color: var(--text); }
   .custom-input::placeholder { color: var(--text-dim); opacity: 0.6; }
 
-  .timeout-row {
-    display: flex; align-items: center; gap: 10px;
-  }
-  .timeout-row input[type="number"] {
+  .connection-card input[type="number"] {
     width: 80px;
+    flex-shrink: 0;
   }
 
-  /* 右键动作的下拉框：定宽，靠右，不被卡片行压缩。 */
-  .rca-select { width: 260px; flex-shrink: 0; }
-  .timeout-hint {
-    font-size: 11px; color: var(--text-dim);
-  }
+  /* 动作下拉框：定宽靠右，窄窗口换行并限制在卡片内。 */
+  .action-row { flex-wrap: wrap; }
+  .action-row .cmd-block-head-body { flex-basis: 180px; }
+  .action-select { width: 260px; max-width: 100%; flex-shrink: 0; margin-left: auto; }
 
   /* 交互卡片的行布局（title/desc + 控件），分隔线分隔多行。
      类名沿用 .cmd-block-* —— 命令块卡片已迁到 CommandBlockSettings，这里复用同款行结构。 */
@@ -437,6 +483,7 @@
   }
   .cmd-block-head-body {
     flex: 1;
+    min-width: 0;
     display: flex;
     flex-direction: column;
     gap: 4px;
diff --git a/src/lib/components/primary-session-window.test.ts b/src/lib/components/primary-session-window.test.ts
index b8e7108a..80d307af 100644
--- a/src/lib/components/primary-session-window.test.ts
+++ b/src/lib/components/primary-session-window.test.ts
@@ -11,8 +11,9 @@ function deferred<T>() {
 }
 
 describe("initializePrimarySessionWindow", () => {
-  it("releases resource panes before reading and applying auto-open", async () => {
+  it("reconciles before releasing resource panes and awaiting the startup action", async () => {
     const reconcile = deferred<void>();
+    const startupAction = deferred<void>();
     const events: string[] = [];
     const initializing = initializePrimarySessionWindow({
       reconcile: () => {
@@ -20,113 +21,82 @@ describe("initializePrimarySessionWindow", () => {
         return reconcile.promise;
       },
       allowResourcePanes: () => events.push("release"),
-      loadAutoOpenLocal: async () => {
-        events.push("load auto-open");
-        return true;
+      runStartupAction: () => {
+        events.push("startup");
+        return startupAction.promise;
       },
-      openLocal: () => events.push("open local"),
-    });
+    }).then(() => events.push("complete"));
 
     await Promise.resolve();
     expect(events).toEqual(["reconcile"]);
 
     reconcile.resolve();
+    await vi.waitFor(() => expect(events).toEqual(["reconcile", "release", "startup"]));
+    startupAction.resolve();
     await initializing;
-    expect(events).toEqual([
-      "reconcile",
-      "release",
-      "load auto-open",
-      "open local",
-    ]);
+    expect(events).toEqual(["reconcile", "release", "startup", "complete"]);
   });
 
-  it("keeps resource panes closed when reconciliation fails so the owner can retry", async () => {
-    const events: string[] = [];
-
-    await expect(initializePrimarySessionWindow({
-      reconcile: async () => {
-        events.push("reconcile");
-        throw new Error("backend unavailable");
-      },
-      allowResourcePanes: () => events.push("release"),
-      loadAutoOpenLocal: async () => {
-        events.push("load auto-open");
-        return false;
-      },
-      openLocal: () => events.push("open local"),
-    })).rejects.toThrow("backend unavailable");
-
-    expect(events).toEqual(["reconcile"]);
-  });
-
-  it("does not read or apply the desktop local-terminal setting on mobile", async () => {
-    const events: string[] = [];
-
-    await initializePrimarySessionWindow({
-      canOpenLocal: false,
-      reconcile: async () => events.push("reconcile"),
-      allowResourcePanes: () => events.push("release"),
-      loadAutoOpenLocal: async () => {
-        events.push("load auto-open");
-        return true;
-      },
-      openLocal: () => events.push("open local"),
-    });
-
-    expect(events).toEqual(["reconcile", "release"]);
-  });
-
-  it("opens resources on a successful retry after a failed reconciliation", async () => {
+  it("releases resources and runs startup only after a successful reconciliation retry", async () => {
     const reconcile = vi.fn()
       .mockRejectedValueOnce(new Error("close failed"))
       .mockResolvedValueOnce(1);
     const allowResourcePanes = vi.fn();
-    const openLocal = vi.fn();
-    const dependencies = { reconcile, allowResourcePanes, openLocal, loadAutoOpenLocal: async () => true };
+    const runStartupAction = vi.fn(async () => {});
+    const dependencies = { reconcile, allowResourcePanes, runStartupAction };
+
     await expect(initializePrimarySessionWindow(dependencies)).rejects.toThrow("close failed");
     expect(allowResourcePanes).not.toHaveBeenCalled();
-    expect(openLocal).not.toHaveBeenCalled();
+    expect(runStartupAction).not.toHaveBeenCalled();
+
     await initializePrimarySessionWindow(dependencies);
-    expect(allowResourcePanes).toHaveBeenCalledTimes(1);
-    expect(openLocal).toHaveBeenCalledTimes(1);
+    expect(allowResourcePanes).toHaveBeenCalledOnce();
+    expect(runStartupAction).toHaveBeenCalledOnce();
   });
 
-  it("does nothing after its owner is cancelled", async () => {
-    const reconcile = deferred<void>();
+  it("propagates unexpected startup action failures to the startup error handler", async () => {
+    const allowResourcePanes = vi.fn();
+    await expect(initializePrimarySessionWindow({
+      reconcile: async () => {},
+      allowResourcePanes,
+      runStartupAction: async () => { throw new Error("unexpected startup failure"); },
+    })).rejects.toThrow("unexpected startup failure");
+    expect(allowResourcePanes).toHaveBeenCalledOnce();
+  });
+
+  it("does nothing when its owner is already cancelled", async () => {
     const controller = new AbortController();
-    const events: string[] = [];
-    const initializing = initializePrimarySessionWindow({
+    controller.abort();
+    const reconcile = vi.fn(async () => {});
+    const allowResourcePanes = vi.fn();
+    const runStartupAction = vi.fn(async () => {});
+
+    await initializePrimarySessionWindow({
       signal: controller.signal,
-      reconcile: () => reconcile.promise,
-      allowResourcePanes: () => events.push("release"),
-      loadAutoOpenLocal: async () => true,
-      openLocal: () => events.push("open local"),
+      reconcile, allowResourcePanes, runStartupAction,
     });
 
-    controller.abort();
-    reconcile.resolve();
-    await initializing;
-
-    expect(events).toEqual([]);
+    expect(reconcile).not.toHaveBeenCalled();
+    expect(allowResourcePanes).not.toHaveBeenCalled();
+    expect(runStartupAction).not.toHaveBeenCalled();
   });
 
-  it("does not auto-open after cancellation during the settings read", async () => {
-    const autoOpen = deferred<boolean>();
+  it("does not release resources or run startup after cancellation during reconciliation", async () => {
+    const reconcile = deferred<void>();
     const controller = new AbortController();
-    const events: string[] = [];
+    const allowResourcePanes = vi.fn();
+    const runStartupAction = vi.fn(async () => {});
     const initializing = initializePrimarySessionWindow({
       signal: controller.signal,
-      reconcile: async () => {},
-      allowResourcePanes: () => events.push("release"),
-      loadAutoOpenLocal: () => autoOpen.promise,
-      openLocal: () => events.push("open local"),
+      reconcile: () => reconcile.promise,
+      allowResourcePanes, runStartupAction,
     });
 
-    await vi.waitFor(() => expect(events).toEqual(["release"]));
     controller.abort();
-    autoOpen.resolve(true);
+    reconcile.resolve();
     await initializing;
 
-    expect(events).toEqual(["release"]);
+    expect(allowResourcePanes).not.toHaveBeenCalled();
+    expect(runStartupAction).not.toHaveBeenCalled();
   });
 });
diff --git a/src/lib/components/primary-session-window.ts b/src/lib/components/primary-session-window.ts
index 849d694c..b5e6d6ef 100644
--- a/src/lib/components/primary-session-window.ts
+++ b/src/lib/components/primary-session-window.ts
@@ -1,10 +1,8 @@
 interface PrimarySessionWindowDependencies {
   signal?: AbortSignal;
-  canOpenLocal?: boolean;
   reconcile: () => Promise<unknown>;
   allowResourcePanes: () => void;
-  loadAutoOpenLocal: () => Promise<boolean>;
-  openLocal: () => void;
+  runStartupAction: () => Promise<void>;
 }
 
 export async function initializePrimarySessionWindow(
@@ -14,15 +12,5 @@ export async function initializePrimarySessionWindow(
   await dependencies.reconcile();
   if (dependencies.signal?.aborted) return;
   dependencies.allowResourcePanes();
-  if (dependencies.canOpenLocal === false) return;
-
-  try {
-    const autoOpen = await dependencies.loadAutoOpenLocal();
-    if (!dependencies.signal?.aborted && autoOpen) {
-      dependencies.openLocal();
-    }
-  } catch {
-    // Keep the existing fail-closed auto-open behavior when settings are
-    // unavailable; the resource barrier has already been released above.
-  }
+  await dependencies.runStartupAction();
 }
diff --git a/src/lib/i18n/locales/en.ts b/src/lib/i18n/locales/en.ts
index 70c638e6..01660f78 100644
--- a/src/lib/i18n/locales/en.ts
+++ b/src/lib/i18n/locales/en.ts
@@ -191,8 +191,7 @@ const en = {
   "settings.appearance.font.row_desc": "Pick an installed font; it leads the default fallback stack.",
   "settings.appearance.font.size": "Font size",
   "settings.appearance.font.size_desc": "Terminal text size, {min}–{max} px.",
-  "settings.shell.sftp_concurrent": "SFTP CONCURRENT TRANSFERS",
-  "settings.shell.sftp_concurrent_label": "Max parallel",
+  "settings.shell.sftp_concurrent_label": "SFTP concurrent transfer limit",
   "settings.shell.sftp_concurrent_hint": "{min}–{max}, default {def}. Excess transfers queue up; one starts when another finishes. Raising too high may hit your SSH server's channel limit.",
   "settings.shell.command_block": "Command block",
   "settings.shell.command_block_bar": "Command block bar",
@@ -1235,13 +1234,15 @@ const en = {
   "settings.shell.custom_placeholder": "/usr/local/bin/fish",
   "settings.shell.local_shell": "LOCAL SHELL",
   "settings.shell.custom": "CUSTOM",
-  "settings.shell.open_local_on_startup": "Open on startup",
-  "settings.shell.open_local_on_startup_desc": "When rssh starts, automatically open one local terminal tab.",
-  "settings.shell.connection_timeout": "CONNECTION TIMEOUT",
-  "settings.shell.timeout_label": "Timeout (seconds)",
+  "settings.shell.startup_action": "Startup action",
+  "settings.shell.startup_restore": "Restore previous sessions",
+  "settings.shell.startup_local": "Open a local shell",
+  "settings.shell.startup_home": "Open Home page",
+  "settings.shell.startup_restore_desc": "Reopen saved SSH, Telnet and serial connections and local terminals using current profiles. Startup commands may run again. Only the root terminal of each tab is restored; split panes, terminal output, editors, forwards and discovered containers are not restored.",
+  "settings.shell.connection_settings": "CONNECTION SETTINGS",
+  "settings.shell.timeout_label": "Connection timeout (seconds)",
   "settings.shell.timeout_hint": "1–300s, default 10s",
-  "settings.shell.connection_logging": "CONNECTION LOGGING",
-  "settings.shell.verbose_log": "VERBOSE LOG",
+  "settings.shell.verbose_log": "SSH connection logging",
   "settings.shell.verbose_log_desc": "Show detailed SSH handshake and authentication messages in terminal.",
   "settings.shell.interaction": "Terminal interaction",
   "settings.shell.confirm_close_tab": "Confirm before closing tab",
diff --git a/src/lib/i18n/locales/zh.ts b/src/lib/i18n/locales/zh.ts
index 0f40827d..b37c7f8b 100644
--- a/src/lib/i18n/locales/zh.ts
+++ b/src/lib/i18n/locales/zh.ts
@@ -193,8 +193,7 @@ const zh: Messages = {
   "settings.appearance.font.row_desc": "选择已安装字体，置于默认字体链最前。",
   "settings.appearance.font.size": "字体大小",
   "settings.appearance.font.size_desc": "终端文字大小，{min}–{max} 像素。",
-  "settings.shell.sftp_concurrent": "SFTP 并发传输",
-  "settings.shell.sftp_concurrent_label": "并发上限",
+  "settings.shell.sftp_concurrent_label": "SFTP 并发传输上限",
   "settings.shell.sftp_concurrent_hint": "{min}–{max}，默认 {def}。超出上限的传输自动排队，前一个结束后顶替。调大要注意 SSH 服务端 channel 上限。",
   "settings.shell.command_block": "命令块",
   "settings.shell.command_block_bar": "命令块侧栏",
@@ -1238,13 +1237,15 @@ const zh: Messages = {
   "settings.shell.custom_placeholder": "/usr/local/bin/fish",
   "settings.shell.local_shell": "本地 SHELL",
   "settings.shell.custom": "自定义",
-  "settings.shell.open_local_on_startup": "启动时打开",
-  "settings.shell.open_local_on_startup_desc": "rssh 启动时自动打开一个本地终端标签页。",
-  "settings.shell.connection_timeout": "连接超时",
-  "settings.shell.timeout_label": "超时（秒）",
+  "settings.shell.startup_action": "启动时动作",
+  "settings.shell.startup_restore": "恢复关闭前的会话",
+  "settings.shell.startup_local": "打开本地 Shell",
+  "settings.shell.startup_home": "打开 Home 页",
+  "settings.shell.startup_restore_desc": "使用当前配置重新打开已保存的 SSH、Telnet、串口连接和本地终端，启动命令可能再次执行。每个标签页只恢复根终端，不恢复分屏、终端输出、编辑器、端口转发或动态发现的容器。",
+  "settings.shell.connection_settings": "连接设置",
+  "settings.shell.timeout_label": "连接超时（秒）",
   "settings.shell.timeout_hint": "1–300 秒，默认 10 秒",
-  "settings.shell.connection_logging": "连接日志",
-  "settings.shell.verbose_log": "详细日志",
+  "settings.shell.verbose_log": "SSH 连接日志",
   "settings.shell.verbose_log_desc": "在终端显示详细的 SSH 握手与认证信息。",
   "settings.shell.interaction": "终端交互",
   "settings.shell.confirm_close_tab": "关闭标签页前确认",
diff --git a/src/lib/stores/startup.svelte.test.ts b/src/lib/stores/startup.svelte.test.ts
new file mode 100644
index 00000000..6de9346b
--- /dev/null
+++ b/src/lib/stores/startup.svelte.test.ts
@@ -0,0 +1,420 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+
+const invoke = vi.hoisted(() => vi.fn());
+const capabilities = vi.hoisted(() => ({ localPty: true, serial: true }));
+vi.mock("./runtime.svelte.ts", () => ({ capabilities: () => capabilities }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke }));
+const key = "session_restore";
+const actionKey = "startup_action";
+let settings: Map<string, string>;
+
+beforeEach(() => {
+  vi.resetModules();
+  settings = new Map();
+  capabilities.localPty = true;
+  capabilities.serial = true;
+  vi.stubGlobal("navigator", { userAgent: "node" });
+  const storage = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: (key: string) => storage.get(key) ?? null,
+    setItem: (key: string, value: string) => storage.set(key, value),
+    removeItem: (key: string) => storage.delete(key),
+  });
+  invoke.mockReset();
+  invoke.mockImplementation(async (command: string, args: Record<string, string>) => {
+    if (command === "get_setting") return settings.get(args.key) ?? null;
+    if (command === "set_setting") { settings.set(args.key, args.value); return; }
+    if (command === "list_profiles") return [{ id: "ssh1", name: "Current SSH", host: "new-host", port: 2222 }];
+    if (command === "list_telnet_profiles") return [{ id: "telnet1", name: "Telnet", host: "telnet", port: 23, login_script: "secret" }];
+    if (command === "list_serial_profiles") return [];
+    if (command === "list_shells") return ["/bin/sh"];
+    return null;
+  });
+});
+afterEach(() => vi.unstubAllGlobals());
+
+async function modules() {
+  return { app: await import("./app.svelte.ts"), startup: await import("./startup.svelte.ts") };
+}
+function saved(terminals: unknown[], active = -1) {
+  settings.set(actionKey, "restore");
+  settings.set(`${key}.snapshot`, JSON.stringify({ version: 1, terminals, active }));
+}
+function deferred() {
+  let resolve!: () => void;
+  const promise = new Promise<void>((done) => { resolve = done; });
+  return { promise, resolve };
+}
+
+describe("startup actions", () => {
+  it.each(["home", "local"] as const)("uses %s instead of restoring the saved snapshot", async (action) => {
+    saved([{ type: "ssh", profileId: "ssh1" }]);
+    settings.set(actionKey, action);
+    const { app, startup } = await modules();
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.type)).toEqual(action === "local" ? ["home", "local"] : ["home"]);
+    expect(invoke).not.toHaveBeenCalledWith("list_profiles");
+    expect(startup.ready()).toBe(true);
+  });
+
+  it("keeps Home when no shell was detected", async () => {
+    settings.set(actionKey, "local");
+    const implementation = invoke.getMockImplementation()!;
+    invoke.mockImplementation((command, args) => command === "list_shells"
+      ? Promise.resolve([]) : implementation(command, args));
+    const { app, startup } = await modules();
+    expect(await startup.availableShells()).toEqual([]);
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.id)).toEqual(["home"]);
+    expect(settings.get(actionKey)).toBe("local");
+  });
+
+  it("does not query shells or open local tabs without PTY support", async () => {
+    capabilities.localPty = false;
+    settings.set(actionKey, "local");
+    const { app, startup } = await modules();
+    expect(await startup.availableShells()).toEqual([]);
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.id)).toEqual(["home"]);
+    expect(invoke).not.toHaveBeenCalledWith("list_shells");
+  });
+
+  it.each(["cancel", "home", "manual"])("does not open a shell after %s during discovery", async (change) => {
+    settings.set(actionKey, "local");
+    const blocked = deferred();
+    const implementation = invoke.getMockImplementation()!;
+    invoke.mockImplementation(async (command, args) => {
+      if (command === "list_shells") await blocked.promise;
+      return implementation(command, args);
+    });
+    const { app, startup } = await modules();
+    const controller = new AbortController();
+    const running = startup.run(controller.signal);
+    await vi.waitFor(() => expect(invoke).toHaveBeenCalledWith("list_shells"));
+    if (change === "cancel") controller.abort();
+    if (change === "home") settings.set(actionKey, "home");
+    if (change === "manual") app.addTab({ id: "manual", type: "local", label: "Local" });
+    blocked.resolve();
+    await running;
+    expect(app.tabs().map((tab) => tab.id)).toEqual(change === "manual" ? ["home", "manual"] : ["home"]);
+  });
+
+  it("does not fall back to a local shell when restoring an empty snapshot", async () => {
+    settings.set(actionKey, "restore");
+    const { app, startup } = await modules();
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.id)).toEqual(["home"]);
+    expect(invoke).not.toHaveBeenCalledWith("list_shells");
+  });
+
+  it("treats an unknown startup action as Home", async () => {
+    settings.set(actionKey, "unknown");
+    const { app, startup } = await modules();
+    expect(await startup.action()).toBe("home");
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.id)).toEqual(["home"]);
+  });
+
+  it("defaults to Home without fetching profiles or reopening tabs", async () => {
+    const { app, startup } = await modules();
+    await startup.run();
+    expect(await startup.action()).toBe("home");
+    expect(startup.ready()).toBe(true);
+    expect(app.tabs()).toHaveLength(1);
+    expect(invoke).not.toHaveBeenCalledWith("list_profiles");
+  });
+
+  it("reopens duplicates in order with fresh IDs and current profiles, skipping deleted profiles", async () => {
+    saved([
+      { type: "ssh", profileId: "ssh1" }, { type: "ssh", profileId: "gone" },
+      { type: "local" }, { type: "ssh", profileId: "ssh1" },
+      { type: "telnet", profileId: "telnet1" },
+    ], 3);
+    const { app, startup } = await modules();
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.type)).toEqual(["home", "ssh", "local", "ssh", "telnet"]);
+    expect(new Set(app.tabs().map((tab) => tab.id)).size).toBe(5);
+    expect(app.activeTabId()).toBe(app.tabs()[3].id);
+    expect(app.tabs()[1].meta).toEqual({ profileId: "ssh1", host: "new-host", port: "2222" });
+    expect(app.tabs()[4].meta).not.toHaveProperty("login_script");
+  });
+
+  it("persists only root profile references without split panes, secret metadata or unsupported tabs", async () => {
+    const { app, startup } = await modules();
+    app.addTab({ id: "ssh", type: "ssh", label: "Secret label", meta: { profileId: "ssh1", password: "secret", host: "host" } });
+    app.addPane("ssh", "right", { id: "telnet", type: "telnet", label: "Telnet", meta: { profileId: "telnet1", login_script: "secret" } });
+    app.addTab({ id: "serial", type: "serial", label: "Serial", meta: { serialProfileId: "serial1", login_script: "secret" } });
+    app.addTab({ id: "forward", type: "forward", label: "Forward", meta: { forwardId: "f1" } });
+    app.addTab({ id: "container", type: "docker_exec", label: "Container", meta: { connectorSpec: "secret" } });
+    app.addTab({ id: "editor", type: "edit", label: "Editor", meta: { content: "secret" } });
+    app.setActiveWorkspace("ssh");
+    app.setActivePane("telnet");
+    const snapshot = startup.snapshot();
+    expect(JSON.parse(snapshot)).toEqual({ version: 1, terminals: [
+      { type: "ssh", profileId: "ssh1" },
+      { type: "serial", profileId: "serial1" },
+    ], active: 0 });
+    expect(snapshot).not.toContain("secret");
+  });
+
+  it("restores only workspace roots and selects the root of the focused split pane", async () => {
+    const { app, startup } = await modules();
+    app.addTab({ id: "telnet", type: "telnet", label: "Telnet", meta: { profileId: "telnet1" } });
+    app.addTab({ id: "ssh", type: "ssh", label: "SSH", meta: { profileId: "ssh1" } });
+    app.addPane("ssh", "right", { id: "split-local", type: "local", label: "Local pane" });
+    app.addPane("ssh", "bottom", { id: "split-telnet", type: "telnet", label: "Telnet pane", meta: { profileId: "telnet1" } });
+    app.addTab({ id: "local", type: "local", label: "Local" });
+    app.setActiveWorkspace("ssh");
+    app.setActivePane("split-telnet");
+    settings.set(actionKey, "restore");
+    settings.set(`${key}.snapshot`, startup.snapshot());
+
+    vi.resetModules();
+    const restarted = await modules();
+    await restarted.startup.run();
+    expect(restarted.app.tabs().map((tab) => tab.type)).toEqual(["home", "telnet", "ssh", "local"]);
+    expect(restarted.app.activeTabId()).toBe(restarted.app.tabs()[2].id);
+    for (const tab of restarted.app.workspaceTabs()) {
+      expect(restarted.app.paneIdsForWorkspace(tab.id)).toEqual([tab.id]);
+    }
+  });
+
+  it.each(["home", "local"] as const)("clears saved sessions when %s is selected and does not persist", async (action) => {
+    saved([{ type: "local" }]);
+    const { startup } = await modules();
+    await startup.run();
+    await startup.setAction(action);
+    await startup.persist(startup.snapshot());
+    expect(settings.get(actionKey)).toBe(action);
+    expect(settings.get(`${key}.snapshot`)).toBe("");
+  });
+
+  it("records existing terminal tabs without filtering them by host capabilities", async () => {
+    const { app, startup } = await modules();
+    app.addTab({ id: "local", type: "local", label: "Local" });
+    app.addTab({ id: "serial", type: "serial", label: "Serial", meta: { serialProfileId: "serial1" } });
+    capabilities.localPty = false;
+    capabilities.serial = false;
+
+    expect(JSON.parse(startup.snapshot())).toEqual({ version: 1, terminals: [
+      { type: "local" }, { type: "serial", profileId: "serial1" },
+    ], active: 1 });
+  });
+
+  it("round-trips more than 100 tabs without losing the active terminal", async () => {
+    const { app, startup } = await modules();
+    for (let index = 0; index < 101; index++) {
+      app.addTab({ id: `local:${index}`, type: "local", label: "Local" });
+    }
+    const snapshot = startup.snapshot();
+    expect(JSON.parse(snapshot).terminals).toHaveLength(101);
+    settings.set(actionKey, "restore");
+    settings.set(`${key}.snapshot`, snapshot);
+
+    vi.resetModules();
+    const restarted = await modules();
+    await restarted.startup.run();
+    expect(restarted.app.tabs()).toHaveLength(102);
+    expect(restarted.app.activeTabId()).toBe(restarted.app.tabs()[101].id);
+    expect(restarted.startup.snapshot()).toBe(snapshot);
+  });
+
+  it.each(["bad JSON", '{"version":2,"terminals":[]}', '{"version":1,"terminals":[{"type":"ssh"}]}'])
+    ("handles invalid snapshots: %s", async (snapshot) => {
+      settings.set(actionKey, "restore");
+      settings.set(`${key}.snapshot`, snapshot);
+      const { app, startup } = await modules();
+      await startup.run();
+      expect(app.tabs()).toHaveLength(1);
+    });
+
+  it("does not overwrite the snapshot if profile loading fails", async () => {
+    saved([{ type: "ssh", profileId: "ssh1" }]);
+    const original = settings.get(`${key}.snapshot`);
+    const implementation = invoke.getMockImplementation()!;
+    invoke.mockImplementation((command, args) => command === "list_profiles"
+      ? Promise.reject(new Error("offline")) : implementation(command, args));
+    const { startup } = await modules();
+    await startup.run();
+    expect(startup.ready()).toBe(false);
+    await startup.persist(startup.snapshot());
+    expect(settings.get(`${key}.snapshot`)).toBe(original);
+  });
+
+  it("does not reopen connections after startup cancellation", async () => {
+    saved([{ type: "local" }]);
+    const original = settings.get(`${key}.snapshot`);
+    const controller = new AbortController();
+    controller.abort();
+    const { app, startup } = await modules();
+    await startup.run(controller.signal);
+    expect(app.tabs()).toHaveLength(1);
+    expect(startup.ready()).toBe(false);
+    await startup.persist(startup.snapshot());
+    expect(settings.get(`${key}.snapshot`)).toBe(original);
+  });
+
+  it("does not reopen saved connections when disabled during profile loading", async () => {
+    saved([{ type: "ssh", profileId: "ssh1" }]);
+    const { app, startup } = await modules();
+    const blocked = deferred();
+    const implementation = invoke.getMockImplementation()!;
+    invoke.mockImplementation(async (command, args) => {
+      if (command === "list_profiles") await blocked.promise;
+      return implementation(command, args);
+    });
+    const running = startup.run();
+    await vi.waitFor(() => expect(invoke).toHaveBeenCalledWith("list_profiles"));
+    await startup.setAction("home");
+    blocked.resolve();
+    await running;
+    expect(app.tabs().map((tab) => tab.id)).toEqual(["home"]);
+    expect(settings.get(`${key}.snapshot`)).toBe("");
+  });
+
+  it("does not take over connections opened manually during startup", async () => {
+    saved([{ type: "local" }]);
+    const { app, startup } = await modules();
+    app.addTab({ id: "manual", type: "local", label: "Manual" });
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.id)).toEqual(["home", "manual"]);
+  });
+
+  it("serializes snapshots so the latest write wins", async () => {
+    const { startup } = await modules();
+    await startup.run();
+    await startup.setAction("restore");
+    await Promise.all([startup.persist("first"), startup.persist("second")]);
+    expect(settings.get(`${key}.snapshot`)).toBe("second");
+  });
+
+  it("reads the current startup action instead of caching it", async () => {
+    const { startup } = await modules();
+    expect(await startup.action()).toBe("home");
+    settings.set(actionKey, "restore");
+    expect(await startup.action()).toBe("restore");
+    settings.set(actionKey, "home");
+    expect(await startup.action()).toBe("home");
+  });
+
+  it("observes preference changes from a secondary window before saving primary tabs", async () => {
+    const primary = await modules();
+    await primary.startup.run();
+    primary.app.addTab({ id: "primary", type: "local", label: "Primary" });
+    vi.resetModules();
+    const secondary = await modules();
+    secondary.app.addTab({ id: "secondary", type: "local", label: "Secondary" });
+
+    await secondary.startup.setAction("restore");
+    expect(secondary.startup.ready()).toBe(false);
+    await secondary.startup.persist(secondary.startup.snapshot());
+    expect(settings.get(`${key}.snapshot`)).toBeUndefined();
+    await primary.startup.persist(primary.startup.snapshot());
+    expect(settings.get(`${key}.snapshot`)).toBe(primary.startup.snapshot());
+
+    await secondary.startup.setAction("home");
+    await primary.startup.persist(primary.startup.snapshot());
+    expect(settings.get(`${key}.snapshot`)).toBe("");
+  });
+
+  it("saves existing primary tabs when restoration is selected", async () => {
+    const { app, startup } = await modules();
+    await startup.run();
+    app.addTab({ id: "local", type: "local", label: "Local" });
+    await startup.setAction("restore");
+    expect(settings.get(`${key}.snapshot`)).toBe(startup.snapshot());
+  });
+
+  it("checks the preference when a queued snapshot starts writing", async () => {
+    saved([{ type: "local" }]);
+    const { startup } = await modules();
+    await startup.run();
+    const blocked = deferred();
+    const implementation = invoke.getMockImplementation()!;
+    invoke.mockImplementation(async (command, args) => {
+      if (command === "set_setting" && args.key === `${key}.snapshot` && args.value === "first") {
+        await blocked.promise;
+      }
+      return implementation(command, args);
+    });
+    const first = startup.persist("first");
+    await vi.waitFor(() => expect(invoke).toHaveBeenCalledWith("set_setting", {
+      key: `${key}.snapshot`, value: "first",
+    }));
+    const second = startup.persist("second");
+    settings.set(actionKey, "home");
+    blocked.resolve();
+    await Promise.all([first, second]);
+    expect(settings.get(`${key}.snapshot`)).toBe("first");
+    expect(invoke).not.toHaveBeenCalledWith("set_setting", { key: `${key}.snapshot`, value: "second" });
+  });
+
+  it("keeps the snapshot cleared when disable follows a pending save", async () => {
+    saved([{ type: "local" }]);
+    const { startup } = await modules();
+    await startup.run();
+    const blocked = deferred();
+    const implementation = invoke.getMockImplementation()!;
+    invoke.mockImplementation(async (command, args) => {
+      if (command === "set_setting" && args.key === `${key}.snapshot` && args.value === "pending") {
+        await blocked.promise;
+      }
+      return implementation(command, args);
+    });
+    const pending = startup.persist("pending");
+    await vi.waitFor(() => expect(invoke).toHaveBeenCalledWith("set_setting", {
+      key: `${key}.snapshot`, value: "pending",
+    }));
+    const disable = startup.setAction("home");
+    const later = startup.persist("later");
+    blocked.resolve();
+    await Promise.all([pending, disable, later]);
+    expect(settings.get(actionKey)).toBe("home");
+    expect(settings.get(`${key}.snapshot`)).toBe("");
+    expect(invoke).not.toHaveBeenCalledWith("set_setting", { key: `${key}.snapshot`, value: "later" });
+  });
+
+  it("preserves the snapshot when a preference read fails and saves after recovery", async () => {
+    saved([{ type: "local" }]);
+    const original = settings.get(`${key}.snapshot`);
+    const { startup } = await modules();
+    await startup.run();
+    invoke.mockRejectedValueOnce(new Error("settings unavailable"));
+    await startup.persist("failed");
+    expect(settings.get(`${key}.snapshot`)).toBe(original);
+    await startup.persist("recovered");
+    expect(settings.get(`${key}.snapshot`)).toBe("recovered");
+  });
+
+  it("keeps saved ordering even when MRU reordering is enabled", async () => {
+    saved([{ type: "ssh", profileId: "ssh1" }, { type: "local" }], 1);
+    const { app, startup } = await modules();
+    await app.setTabMru(true);
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.type)).toEqual(["home", "ssh", "local"]);
+    expect(app.activeTabId()).toBe(app.tabs()[2].id);
+  });
+
+  it("uses the shared snapshot on hosts without PTY/serial capabilities", async () => {
+    capabilities.localPty = false;
+    capabilities.serial = false;
+    saved([
+      { type: "local" }, { type: "serial", profileId: "s1" },
+      { type: "ssh", profileId: "ssh1" }, { type: "telnet", profileId: "telnet1" },
+    ], 2);
+    const { app, startup } = await modules();
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.type)).toEqual(["home", "ssh", "telnet"]);
+    expect(invoke).not.toHaveBeenCalledWith("list_serial_profiles");
+    expect(app.activeTabId()).toBe(app.tabs()[1].id);
+  });
+
+  it("does not fetch or restore serial profiles on a PTY-only host", async () => {
+    capabilities.serial = false;
+    saved([{ type: "local" }, { type: "serial", profileId: "serial1" }], 0);
+    const { app, startup } = await modules();
+    await startup.run();
+    expect(app.tabs().map((tab) => tab.type)).toEqual(["home", "local"]);
+    expect(invoke).not.toHaveBeenCalledWith("list_serial_profiles");
+  });
+});
diff --git a/src/lib/stores/startup.svelte.ts b/src/lib/stores/startup.svelte.ts
new file mode 100644
index 00000000..247d3fa4
--- /dev/null
+++ b/src/lib/stores/startup.svelte.ts
@@ -0,0 +1,152 @@
+import { invoke } from "@tauri-apps/api/core";
+import * as app from "./app.svelte.ts";
+import { errMsg } from "../i18n/index.svelte.ts";
+import { toast } from "./toast.svelte.ts";
+
+// Only references to saved profiles are persisted. Never serialize tab.meta:
+// serial login scripts, editor content and connector commands may contain secrets.
+type SavedTerminal = { type: "ssh" | "telnet" | "serial"; profileId: string } | { type: "local" };
+interface Snapshot { version: 1; terminals: SavedTerminal[]; active: number }
+export type StartupAction = "restore" | "local" | "home";
+const actionKey = "startup_action";
+const snapshotKey = "session_restore.snapshot";
+let _ready = $state(false);
+let writes = Promise.resolve();
+
+export async function action(): Promise<StartupAction> {
+  const value = await invoke<string | null>("get_setting", { key: actionKey });
+  return value === "restore" || value === "local" ? value : "home";
+}
+export function ready() { return _ready; }
+
+export async function availableShells(): Promise<string[]> {
+  return app.capabilities().localPty ? invoke<string[]>("list_shells") : [];
+}
+
+function report(error: unknown) {
+  console.warn("[startup]", error);
+  toast.error(errMsg(error));
+}
+
+function queueWrite(operation: () => Promise<void>): Promise<void> {
+  // Keep action reads and their writes together, including switching away + clear.
+  const next = writes.then(operation);
+  writes = next.catch((error) => console.warn("[startup] write failed:", error));
+  return next;
+}
+
+export async function setAction(value: StartupAction) {
+  await queueWrite(async () => {
+    await invoke("set_setting", { key: actionKey, value });
+    if (value !== "restore") await invoke("set_setting", { key: snapshotKey, value: "" });
+  });
+  if (value === "restore") await persist(snapshot());
+}
+
+function reference(tab: app.Tab): SavedTerminal | null {
+  if (tab.type === "local") return { type: "local" };
+  if (tab.type !== "ssh" && tab.type !== "telnet" && tab.type !== "serial") return null;
+  const profileId = tab.type === "serial" ? tab.meta?.serialProfileId : tab.meta?.profileId;
+  return profileId ? { type: tab.type, profileId } : null;
+}
+
+export function snapshot(): string {
+  const terminals: SavedTerminal[] = [];
+  let active = -1;
+  for (const tab of app.workspaceTabs()) {
+    const saved = reference(tab);
+    if (!saved) continue;
+    if (tab.id === app.activeWorkspaceId()) active = terminals.length;
+    terminals.push(saved);
+  }
+  return JSON.stringify({ version: 1, terminals, active } satisfies Snapshot);
+}
+
+export async function persist(value: string): Promise<void> {
+  // Only a primary window whose startup reads succeeded may replace the snapshot.
+  if (!_ready) return;
+  await queueWrite(async () => {
+    if (await action() === "restore") {
+      await invoke("set_setting", { key: snapshotKey, value });
+    }
+  }).catch(report);
+}
+
+function parse(raw: string | null): Snapshot | null {
+  if (!raw) return null;
+  const data = JSON.parse(raw);
+  if (data?.version !== 1 || !Array.isArray(data.terminals)) return null;
+  const terminals = data.terminals.map((value: unknown): SavedTerminal | null => {
+    if (!value || typeof value !== "object") return null;
+    const entry = value as Record<string, unknown>;
+    if (entry.type === "local") return { type: "local" };
+    if ((entry.type === "ssh" || entry.type === "telnet" || entry.type === "serial")
+      && typeof entry.profileId === "string" && entry.profileId) {
+      return { type: entry.type, profileId: entry.profileId };
+    }
+    return null;
+  });
+  // Reject invalid entries rather than shifting the active index.
+  if (terminals.some((entry: SavedTerminal | null) => !entry)) return null;
+  return { version: 1, terminals, active: Number.isInteger(data.active) ? data.active : -1 };
+}
+
+export async function run(signal?: AbortSignal): Promise<void> {
+  let failed = false;
+  try {
+    const selectedAction = await action();
+    if (selectedAction === "home" || signal?.aborted || app.tabs().length !== 1) return;
+    if (selectedAction === "local") {
+      const shells = await availableShells();
+      if (shells.length && await action() === "local" && !signal?.aborted && app.tabs().length === 1) {
+        app.addTab({ id: `local:${crypto.randomUUID()}`, type: "local", label: "Local" });
+      }
+      return;
+    }
+    const saved = parse(await invoke<string | null>("get_setting", { key: snapshotKey }));
+    if (!saved || signal?.aborted) return;
+    const types = new Set(saved.terminals.map((entry) => entry.type));
+    const [ssh, telnet, serial] = await Promise.all([
+      types.has("ssh") ? app.loadProfiles() : [],
+      types.has("telnet") ? invoke<app.TelnetProfile[]>("list_telnet_profiles") : [],
+      types.has("serial") && app.capabilities().serial ? invoke<app.SerialProfile[]>("list_serial_profiles") : [],
+    ]);
+    // The preference or the user's tabs may have changed while profiles loaded.
+    const stillRestoring = await action() === "restore";
+    if (!stillRestoring || signal?.aborted || app.tabs().length !== 1) return;
+    let activeId = "home";
+    const restoredIds: string[] = [];
+    saved.terminals.forEach((entry, index) => {
+      const before = app.tabs().length;
+      if (entry.type === "local" && app.capabilities().localPty) {
+        app.addTab({ id: `local:${crypto.randomUUID()}`, type: "local", label: "Local" });
+      } else if (entry.type === "ssh") {
+        const profile = ssh.find((profile) => profile.id === entry.profileId);
+        if (profile) app.addTab({
+          id: `ssh:${crypto.randomUUID()}`, type: "ssh", label: profile.name,
+          meta: { profileId: profile.id, host: profile.host, port: String(profile.port) },
+        });
+      } else if (entry.type === "telnet") {
+        const profile = telnet.find((profile) => profile.id === entry.profileId);
+        if (profile) app.connectTelnetProfile(profile);
+      } else if (entry.type === "serial" && app.capabilities().serial) {
+        const profile = serial.find((profile) => profile.id === entry.profileId);
+        if (profile) app.connectSerialProfile(profile);
+      }
+      if (app.tabs().length > before) {
+        restoredIds.push(app.activeTabId());
+        if (index === saved.active) activeId = app.activeTabId();
+      }
+    });
+    app.setActiveTab(activeId);
+    // addTab/focus may apply MRU ordering. Restore the saved strip order last.
+    restoredIds.forEach((id, index) => {
+      app.moveTab(app.tabs().findIndex((tab) => tab.id === id), index + 1);
+    });
+  } catch (error) {
+    failed = true; // Preserve the last snapshot when startup reads fail.
+    report(error);
+  } finally {
+    _ready = !failed && !signal?.aborted;
+  }
+}