diff --git a/assets/resources/docs/user_guide.md b/assets/resources/docs/user_guide.md
index f5bb1e8..b26afc2 100644
--- a/assets/resources/docs/user_guide.md
+++ b/assets/resources/docs/user_guide.md
@@ -131,6 +131,16 @@ Open **Tools** to turn spellcheck on or off. When spellcheck is enabled, right-c
 
 The **Tools** menu also includes Light, Dark, Solarized, Arctic Dark, and Forest themes. Your selected theme is remembered between sessions.
 
+## Session restoration
+
+Session restoration is an opt-in setting under **Tools → Restore Session**. When enabled, SnapDock remembers the open workspace and the saved-file tabs that were open (their order and the active tab) and reopens them on the next start.
+
+- Only **saved** files are restored. Unsaved and untitled tabs, their content, and undo/scroll position are not saved.
+- Files are reloaded from disk on start; the document contents you see come from the saved file, not a snapshot.
+- Missing, moved, or inaccessible files are skipped without blocking startup.
+
+Disable **Tools → Restore Session** to stop restoring tabs; doing so clears the stored session. Choosing **Save → Close Project** also clears the stored session. Users remain responsible for saving changes normally.
+
 ## Updates
 
 Select **Tools → Update** to check for updates when that option is supported by your installation. Microsoft Store and Snap Store packages are normally updated by their stores, and update behaviour can differ for other Linux packages and WSL.
diff --git a/index.html b/index.html
index 0e757f3..8d1bd44 100644
--- a/index.html
+++ b/index.html
@@ -61,6 +61,7 @@
             <div class="dropdown-panel" id="toolsMenu">
               <button id="updateBtn">Update</button>
               <button id="spellcheckBtn" aria-pressed="true">Spellcheck: On</button>
+              <button id="restoreSessionBtn" aria-pressed="false">Restore Session: Off</button>
               <div class="dropdown-separator"></div>
               <div class="dropdown-section-label">Editor Font</div>
               <div class="dropdown-subgroup">
diff --git a/package.json b/package.json
index 37cd510..0de5f40 100644
--- a/package.json
+++ b/package.json
@@ -15,7 +15,7 @@
   "scripts": {
     "start": "electron .",
     "md:test": "node test/markdown-render.mjs",
-    "test": "npm run md:test && node tests/find.test.js && node tests/link-navigation.test.js && node --test tests/editor-indent.test.mjs",
+    "test": "npm run md:test && node tests/find.test.js && node tests/link-navigation.test.js && node --test tests/editor-indent.test.mjs && node --test tests/session-restore.test.mjs",
     "build:dev": "node scripts/build-dev.js",
     "build:test": "node scripts/build-test.js",
     "build:win": "node scripts/build-win.js",
diff --git a/src/modules/file/session.js b/src/modules/file/session.js
new file mode 100644
index 0000000..6880db0
--- /dev/null
+++ b/src/modules/file/session.js
@@ -0,0 +1,134 @@
+// src/modules/file/session.js
+//
+// Session restoration (opt-in, issue #244).
+//
+// Persists only navigation metadata — the last open workspace, the ordered
+// list of saved-file tab paths, and the active saved-file tab — so that the
+// tabs can be reopened on the next launch. File *content* is deliberately
+// NOT stored here; it is always reloaded from disk. This is scoped to a
+// workspace, mirroring the recent-files pattern, so sessions from different
+// folders do not leak into one another.
+
+import { loadWorkspace } from "./workspace.js";
+
+const ENABLED_KEY = "snapdock_session_enabled";
+const SESSION_PREFIX = "snapdock_session_";
+
+// ------------------------------------------------------------------
+// Enabled preference (opt-in, off by default)
+export function isSessionRestoreEnabled() {
+  return localStorage.getItem(ENABLED_KEY) === "true";
+}
+
+export function setSessionRestoreEnabled(enabled) {
+  localStorage.setItem(ENABLED_KEY, String(enabled));
+}
+
+// ------------------------------------------------------------------
+// Session metadata key (workspace-scoped)
+function keyForWorkspace(workspace) {
+  return workspace ? `${SESSION_PREFIX}${workspace}` : null;
+}
+
+function getSessionKey() {
+  return keyForWorkspace(loadWorkspace());
+}
+
+// ------------------------------------------------------------------
+// Persist the session metadata from the current tab state.
+// Only saved-file tabs (with a filePath) are recorded; untitled tabs are
+// excluded by design.
+export function saveSession({ tabs, activeFile }) {
+  if (!isSessionRestoreEnabled()) return;
+
+  const key = getSessionKey();
+  if (!key) return;
+
+  const openFiles = (tabs || [])
+    .map((t) => t.filePath)
+    .filter((p) => typeof p === "string" && p.length > 0);
+
+  const data = {
+    workspacePath: loadWorkspace() || null,
+    openFiles,
+    activeFile: typeof activeFile === "string" ? activeFile : openFiles[openFiles.length - 1] || null,
+  };
+
+  try {
+    localStorage.setItem(key, JSON.stringify(data));
+  } catch (_) {
+    // Ignore serialization/storage failures; session restore is best-effort.
+  }
+}
+
+// ------------------------------------------------------------------
+// Load the stored session metadata. Pass an explicit workspace path to read
+// a specific session (used at startup and to enforce workspace isolation);
+// when omitted, the current persisted workspace is used. Returns null when
+// disabled, no session exists, or the data is corrupt.
+export function loadSession(workspacePath) {
+  if (!isSessionRestoreEnabled()) return null;
+
+  const key = keyForWorkspace(workspacePath || loadWorkspace());
+  if (!key) return null;
+
+  let data = null;
+  try {
+    data = JSON.parse(localStorage.getItem(key) || "null");
+  } catch (_) {
+    return null;
+  }
+
+  if (!data || !Array.isArray(data.openFiles)) return null;
+  return data;
+}
+
+// ------------------------------------------------------------------
+// Clear the current workspace's session metadata. Also called when the
+// feature is disabled so stored session data is not left behind.
+export function clearSession() {
+  const key = getSessionKey();
+  if (key) {
+    try {
+      localStorage.removeItem(key);
+    } catch (_) {
+      // best-effort
+    }
+  }
+}
+
+// ------------------------------------------------------------------
+// Reopen the saved-file tabs for a workspace, in order, and restore the
+// previously active tab. Files are (re)loaded from disk — never from
+// localStorage — and anything missing/inaccessible is skipped. This must be
+// called after the workspace is loaded (see app.js / tree.js event).
+export function initSessionRestore() {
+  document.addEventListener("snapdock:workspaceLoaded", async (e) => {
+    const workspace = e.detail.path;
+    if (!workspace) return;
+
+    const session = loadSession(workspace);
+    if (!session || !Array.isArray(session.openFiles)) return;
+
+    // Enforce workspace isolation: only restore files that live under the
+    // triggered workspace so a stale/foreign session cannot leak in.
+    const { handleFileOpen } = await import("./open.js");
+    const { switchToTabByPath } = await import("./tabs.js");
+    const sep = workspace.includes("\\") ? "\\" : "/";
+    const prefix = workspace.endsWith(sep) ? workspace : workspace + sep;
+
+    for (const filePath of session.openFiles) {
+      if (typeof filePath !== "string") continue;
+      if (!filePath.startsWith(prefix)) continue; // isolation guard
+      const name = filePath.split(/[\\/]/).pop();
+      // handleFileOpen loads from disk and returns early on missing files.
+      await handleFileOpen(filePath, name);
+    }
+
+    // Restore the previously active saved-file tab, if it was reopened.
+    if (session.activeFile) {
+      switchToTabByPath(session.activeFile);
+    }
+  });
+}
+
diff --git a/src/modules/file/tabs.js b/src/modules/file/tabs.js
index 2c518cf..8198e33 100644
--- a/src/modules/file/tabs.js
+++ b/src/modules/file/tabs.js
@@ -1,6 +1,7 @@
 // src/modules/file/tabs.js
 import { saveCurrentFile } from "./operations.js";
 import { updateMetrics } from "../ui/metrics.js";
+import { saveSession } from "./session.js";
 
 let tabs = [];
 let activeTabId = null;
@@ -8,6 +9,16 @@ let activeTabId = null;
 const getEditor = () => document.getElementById("markdownInputMain");
 let tabBarScrollSetup = false;
 
+// Persist the session (navigation metadata only) after tab mutations. Only a
+// saved-file tab can be the session's active file. This is a no-op unless
+// session restoration is enabled (see session.js).
+function persistSession() {
+  const activeFile = activeTabId
+    ? (tabs.find(t => t.id === activeTabId)?.filePath || null)
+    : null;
+  saveSession({ tabs, activeFile });
+}
+
 function isTabBarScrollable(tabBar) {
   return tabBar.scrollWidth > tabBar.clientWidth + 1;
 }
@@ -75,6 +86,9 @@ export function createTab({ filePath = null, content = "", title = "Untitled" }
   };
 
   tabs.push(tab);
+
+  // Only tabs that correspond to a saved file are part of a restorable session.
+  if (tab.filePath) persistSession();
   return tab;
 }
 
@@ -120,6 +134,8 @@ export function switchToTab(tabId) {
   }
 
   renderTabs();
+  // Switching the active tab changes which file is active in the session.
+  persistSession();
 }
 
 /**
@@ -150,6 +166,7 @@ export async function closeTab(tabId) {
     }
   } else {
     renderTabs();
+    persistSession();
   }
 }
 
@@ -164,6 +181,8 @@ export function moveTab(fromIndex, toIndex) {
   const [moved] = tabs.splice(fromIndex, 1);
   tabs.splice(toIndex, 0, moved);
   renderTabs();
+  // Reordering changes tab order in the session.
+  persistSession();
 }
 
 // --- Drag & Drop state ---
diff --git a/src/modules/ui/dropdownMenus.js b/src/modules/ui/dropdownMenus.js
index 3f15402..599e59c 100644
--- a/src/modules/ui/dropdownMenus.js
+++ b/src/modules/ui/dropdownMenus.js
@@ -6,6 +6,13 @@
 import { applyTheme } from "./theme.js";
 import { openHelpModal } from "./help.js";
 import { setEditorFont } from "./editorFont.mjs";
+import {
+  isSessionRestoreEnabled,
+  setSessionRestoreEnabled,
+  clearSession,
+  saveSession,
+} from "../file/session.js";
+import { tabs, getActiveTab } from "../file/tabs.js";
 
 // ─── Public API ────────────────────────────────────────────────
 
@@ -64,6 +71,12 @@ export function initToolsDropdown() {
     initSpellcheckButton(spellcheckBtn);
   }
 
+  // ── Session restoration (opt-in) ──
+  const restoreSessionBtn = document.getElementById("restoreSessionBtn");
+  if (restoreSessionBtn) {
+    initSessionRestoreButton(restoreSessionBtn);
+  }
+
   // ── Themes ──
   document.querySelectorAll(".theme-option").forEach((btn) => {
     btn.addEventListener("click", () => {
@@ -143,6 +156,43 @@ function initSpellcheckButton(btn) {
   });
 }
 
+// Session restoration toggle (opt-in, issue #244).
+//
+// Turning the feature on/off is persisted. Turning it OFF clears any stored
+// session metadata (per acceptance criteria), then re-records the current
+// navigation state so that re-enabling is not fed stale tab data.
+function initSessionRestoreButton(btn) {
+  const applyState = (enabled) => {
+    btn.dataset.enabled = String(enabled);
+    btn.textContent = enabled ? "Restore Session: On" : "Restore Session: Off";
+    btn.classList.toggle("active", enabled);
+    btn.setAttribute("aria-pressed", String(enabled));
+  };
+
+  applyState(isSessionRestoreEnabled());
+
+  btn.addEventListener("click", () => {
+    const enabled = !isSessionRestoreEnabled();
+    setSessionRestoreEnabled(enabled);
+
+    if (enabled) {
+      // Persist the current navigation state immediately so the session
+      // reflects what is open right now. Guard on tabs.length because
+      // getActiveTab() creates an untitled tab when none exist.
+      const active = tabs.length ? getActiveTab() : null;
+      saveSession({
+        tabs,
+        activeFile: active && active.filePath ? active.filePath : null,
+      });
+    } else {
+      // Disabling clears stored session metadata.
+      clearSession();
+    }
+
+    applyState(enabled);
+  });
+}
+
 // Updater state machine.
 //
 // All update UI is driven from a single `state` value below, so the Tools
diff --git a/src/scripts.js b/src/scripts.js
index 7b95f15..e12321f 100644
--- a/src/scripts.js
+++ b/src/scripts.js
@@ -11,6 +11,7 @@ import { initDropdownToggles, initToolsDropdown } from "./modules/ui/dropdownMen
 import { initMetrics } from "./modules/ui/metrics.js";
 import { initEditorFont } from "./modules/ui/editorFont.mjs";
 import { clearWorkspace } from "./modules/file/workspace.js";
+import { initSessionRestore, clearSession } from "./modules/file/session.js";
 import { initEditorIndent } from "./modules/ui/editorIndent.js";
 
 // Helper
@@ -42,12 +43,17 @@ window.workspaceAPI.onSaveAllForCloseRequest(async() => {
 
 window.workspaceAPI.onClearForCloseRequest(() => {
   clearWorkspace();
+  clearSession();
   window.workspaceAPI.sendClearForCloseResult();
 });
 
 // --- MAIN BOOTSTRAP ---
 window.addEventListener("DOMContentLoaded", () => {
 
+  // Register the session restore listener BEFORE initApp() so it can catch
+  // the startup snapdock:workspaceLoaded event dispatched during initApp.
+  initSessionRestore();
+
   // Core App Initialization
   initApp();
 
diff --git a/tests/session-restore.test.mjs b/tests/session-restore.test.mjs
new file mode 100644
index 0000000..afcb953
--- /dev/null
+++ b/tests/session-restore.test.mjs
@@ -0,0 +1,128 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  isSessionRestoreEnabled,
+  setSessionRestoreEnabled,
+  saveSession,
+  loadSession,
+  clearSession,
+} from "../src/modules/file/session.js";
+import { loadWorkspace } from "../src/modules/file/workspace.js";
+
+// Minimal in-memory localStorage replacement (used by session.js/workspace.js).
+const store = {};
+global.localStorage = {
+  getItem: (k) => (k in store ? store[k] : null),
+  setItem: (k, v) => { store[k] = String(v); },
+  removeItem: (k) => { delete store[k]; },
+};
+
+const WORKSPACE = "C:\\Users\\demo\\proj";
+const OTHER_WORKSPACE = "C:\\Users\\demo\\other";
+
+function resetStore() {
+  for (const k of Object.keys(store)) delete store[k];
+  global.localStorage.setItem("snapdock_workspace", WORKSPACE);
+}
+
+function sampleTabs() {
+  return [
+    { filePath: `${WORKSPACE}\\a.md` },
+    { filePath: null, title: "Untitled" }, // untitled must be excluded
+    { filePath: `${WORKSPACE}\\b.md` },
+  ];
+}
+
+test("session restoration is disabled by default", () => {
+  resetStore();
+  assert.equal(isSessionRestoreEnabled(), false);
+});
+
+test("the enabled preference persists across restarts (set then read)", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  assert.equal(isSessionRestoreEnabled(), true);
+
+  // Simulate a fresh session: the preference is read from storage only.
+  setSessionRestoreEnabled(true);
+  assert.equal(isSessionRestoreEnabled(), true);
+});
+
+test("save/load round-trip restores order and active file, skipping untitled", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+
+  saveSession({ tabs: sampleTabs(), activeFile: `${WORKSPACE}\\a.md` });
+
+  const session = loadSession();
+  assert.ok(session);
+  assert.equal(session.workspacePath, WORKSPACE);
+  // Untitled tab (null filePath) is not persisted.
+  assert.deepEqual(session.openFiles, [`${WORKSPACE}\\a.md`, `${WORKSPACE}\\b.md`]);
+  assert.equal(session.activeFile, `${WORKSPACE}\\a.md`);
+});
+
+test("active file falls back to the last open file when not provided", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  saveSession({ tabs: sampleTabs(), activeFile: null });
+  assert.equal(loadSession().activeFile, `${WORKSPACE}\\b.md`);
+});
+
+test("sessions are isolated per workspace", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  saveSession({ tabs: sampleTabs(), activeFile: `${WORKSPACE}\\a.md` });
+
+  // Switch to another workspace: its session key does not exist.
+  global.localStorage.setItem("snapdock_workspace", OTHER_WORKSPACE);
+  assert.equal(loadSession(), null);
+});
+
+test("loadSession returns null when disabled even if metadata exists", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  saveSession({ tabs: sampleTabs(), activeFile: `${WORKSPACE}\\a.md` });
+
+  setSessionRestoreEnabled(false);
+  assert.equal(isSessionRestoreEnabled(), false);
+  // Disabling clears the stored metadata.
+  clearSession();
+  assert.equal(loadSession(), null);
+});
+
+test("missing/corrupt metadata returns null safely", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  global.localStorage.setItem(
+    `snapdock_session_${WORKSPACE}`,
+    "{ not valid json"
+  );
+  assert.equal(loadSession(), null);
+});
+
+test("clearSession removes the current workspace's metadata", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  saveSession({ tabs: sampleTabs(), activeFile: `${WORKSPACE}\\a.md` });
+  assert.ok(loadSession());
+
+  // Project closure calls clearSession.
+  clearSession();
+  assert.equal(loadSession(), null);
+});
+
+test("persisted values are metadata only and never store file contents", () => {
+  resetStore();
+  setSessionRestoreEnabled(true);
+  saveSession({
+    tabs: [{ filePath: `${WORKSPACE}\\a.md`, content: "SECRET BODY" }],
+    activeFile: `${WORKSPACE}\\a.md`,
+  });
+
+  const raw = global.localStorage.getItem(`snapdock_session_${WORKSPACE}`);
+  assert.ok(raw);
+  // The serialized session must not contain document body text.
+  assert.ok(!raw.includes("SECRET BODY"));
+});