diff --git a/.storybook/decorators/withStealthKeys.tsx b/.storybook/decorators/withStealthKeys.tsx
index c5787e2..c35b182 100644
--- a/.storybook/decorators/withStealthKeys.tsx
+++ b/.storybook/decorators/withStealthKeys.tsx
@@ -15,6 +15,12 @@ const baseValue: StealthKeysValue = {
   solanaMetaAddress: null,
   ckbKeys: null,
   ckbMetaAddress: null,
+  isRecoveryMode: false,
+  isReadOnly: false,
+  setIsRecoveryMode: noop,
+  setIsReadOnly: noop,
+  restoreFromRecoveryKit: noop,
+  exitRecoveryMode: noop,
   setEvmKeys: noop,
   setEvmMetaAddress: noop,
   setStellarKeys: noop,
diff --git a/src/components/Header.tsx b/src/components/Header.tsx
index 70d439a..7b1d867 100644
--- a/src/components/Header.tsx
+++ b/src/components/Header.tsx
@@ -7,6 +7,7 @@ import { LocaleSwitcher } from './LocaleSwitcher';
 import { NetworkChip } from './NetworkChip';
 import { useTheme } from '@/context/ThemeContext';
 import { useNotificationsStore } from '@/stores/notificationsStore';
+import { useStealthKeys } from '@/context/StealthKeysContext';
 
 export function Header() {
   const location = useLocation();
@@ -14,6 +15,7 @@ export function Header() {
   const [mobileMenuOpen, setMobileMenuOpen] = useState(false);
   const { theme, toggleTheme } = useTheme();
   const unreadCount = useNotificationsStore((state) => state.unreadCount());
+  const { isRecoveryMode } = useStealthKeys();
 
   const navLinks = [
     { to: '/send', label: t('nav.send') },
@@ -35,6 +37,11 @@ export function Header() {
             <span className="bg-surface-bright px-2 py-0.5 font-mono text-[9px] uppercase tracking-wider text-outline sm:text-[10px]">
               Demo
             </span>
+            {isRecoveryMode && (
+              <span className="border border-amber-500/40 bg-amber-500/10 px-2 py-0.5 font-mono text-[9px] font-semibold uppercase tracking-wider text-amber-400 sm:text-[10px]">
+                Recovery Mode
+              </span>
+            )}
           </Link>
 
           <nav className="hidden gap-0 sm:flex">
diff --git a/src/components/StellarReceive.tsx b/src/components/StellarReceive.tsx
index 5ac342e..e030bba 100644
--- a/src/components/StellarReceive.tsx
+++ b/src/components/StellarReceive.tsx
@@ -1237,7 +1237,7 @@ export function StellarReceive() {
     }
   }, [notifications]);
 
-  if (!isConnected) {
+  if (!isConnected && !stellarKeys) {
     return (
       <section className="flex flex-col gap-3">
         <span className="font-mono text-[10px] uppercase tracking-widest text-outline">
diff --git a/src/context/StealthKeysContext.tsx b/src/context/StealthKeysContext.tsx
index ba2a54a..32eedba 100644
--- a/src/context/StealthKeysContext.tsx
+++ b/src/context/StealthKeysContext.tsx
@@ -4,6 +4,8 @@ import type { StealthKeys as EVMStealthKeys } from '@wraith-protocol/sdk/chains/
 import type { StealthKeys as StellarStealthKeys } from '@wraith-protocol/sdk/chains/stellar';
 import type { StealthKeys as SolanaStealthKeys } from '@wraith-protocol/sdk/chains/solana';
 import type { StealthKeys as CKBStealthKeys } from '@wraith-protocol/sdk/chains/ckb';
+import { hexToBytes, type RecoveryKitData } from '@/lib/stellar/recoveryKit';
+import { importLabels } from '@/lib/stealthLabels';
 
 interface StealthKeysContextValue {
   evmKeys: EVMStealthKeys | null;
@@ -14,6 +16,12 @@ interface StealthKeysContextValue {
   solanaMetaAddress: string | null;
   ckbKeys: CKBStealthKeys | null;
   ckbMetaAddress: string | null;
+  isRecoveryMode: boolean;
+  isReadOnly: boolean;
+  setIsRecoveryMode: (active: boolean) => void;
+  setIsReadOnly: (readOnly: boolean) => void;
+  restoreFromRecoveryKit: (kitData: RecoveryKitData) => void;
+  exitRecoveryMode: () => void;
   setEvmKeys: (keys: EVMStealthKeys) => void;
   setEvmMetaAddress: (metaAddress: string) => void;
   setStellarKeys: (keys: StellarStealthKeys) => void;
@@ -51,22 +59,129 @@ export function StealthKeysProvider({ children }: { children: React.ReactNode })
   const [solanaMetaAddress, setSolanaMetaAddress] = useState<string | null>(null);
   const [ckbKeys, setCkbKeys] = useState<CKBStealthKeys | null>(null);
   const [ckbMetaAddress, setCkbMetaAddress] = useState<string | null>(null);
+  const [isRecoveryMode, setIsRecoveryMode] = useState(false);
+  const [isReadOnly, setIsReadOnly] = useState(false);
 
   const clearEvm = useCallback(() => {
+    if (isRecoveryMode) return;
     setEvmKeys(null);
     setEvmMetaAddress(null);
-  }, []);
+  }, [isRecoveryMode]);
+
   const clearStellar = useCallback(() => {
+    if (isRecoveryMode) return;
     setStellarKeys(null);
     setStellarMetaAddress(null);
-  }, []);
+  }, [isRecoveryMode]);
+
   const clearSolana = useCallback(() => {
+    if (isRecoveryMode) return;
     setSolanaKeys(null);
     setSolanaMetaAddress(null);
-  }, []);
+  }, [isRecoveryMode]);
+
   const clearCkb = useCallback(() => {
+    if (isRecoveryMode) return;
     setCkbKeys(null);
     setCkbMetaAddress(null);
+  }, [isRecoveryMode]);
+
+  const exitRecoveryMode = useCallback(() => {
+    setIsRecoveryMode(false);
+    setIsReadOnly(false);
+    setEvmKeys(null);
+    setEvmMetaAddress(null);
+    setStellarKeys(null);
+    setStellarMetaAddress(null);
+    setSolanaKeys(null);
+    setSolanaMetaAddress(null);
+    setCkbKeys(null);
+    setCkbMetaAddress(null);
+  }, []);
+
+  const restoreFromRecoveryKit = useCallback((kitData: RecoveryKitData) => {
+    setIsRecoveryMode(true);
+    setIsReadOnly(!kitData.spendingScalarHex);
+
+    const viewingKey = kitData.viewingScalarHex
+      ? hexToBytes(kitData.viewingScalarHex)
+      : new Uint8Array(32);
+    const spendingPubKey = kitData.spendingPubKeyHex
+      ? hexToBytes(kitData.spendingPubKeyHex)
+      : new Uint8Array(32);
+    const viewingPubKey = kitData.viewingPubKeyHex
+      ? hexToBytes(kitData.viewingPubKeyHex)
+      : new Uint8Array(32);
+    const spendingScalar = kitData.spendingScalarHex
+      ? BigInt(
+          kitData.spendingScalarHex.startsWith('0x')
+            ? kitData.spendingScalarHex
+            : `0x${kitData.spendingScalarHex}`,
+        )
+      : undefined;
+
+    const chain = kitData.chain?.toLowerCase() || '';
+
+    if (chain === 'stellar' || kitData.metaAddress?.startsWith('st:xlm:')) {
+      const keys: any = {
+        viewingKey,
+        viewingScalar: viewingKey,
+        spendingKey: spendingPubKey,
+        spendingPubKey,
+        viewingPubKey,
+        spendingScalar,
+      };
+      setStellarKeys(keys as StellarStealthKeys);
+      setStellarMetaAddress(kitData.metaAddress);
+    } else if (chain === 'horizen' || kitData.metaAddress?.startsWith('st:eth:')) {
+      const keys: any = {
+        viewingKey: kitData.viewingScalarHex,
+        spendingPubKey: kitData.spendingPubKeyHex || '',
+        viewingPubKey: kitData.viewingPubKeyHex || '',
+        spendingScalar: kitData.spendingScalarHex || '',
+      };
+      setEvmKeys(keys as EVMStealthKeys);
+      setEvmMetaAddress(kitData.metaAddress);
+    } else if (chain === 'solana' || kitData.metaAddress?.startsWith('st:sol:')) {
+      const keys: any = {
+        viewingKey,
+        viewingScalar: viewingKey,
+        spendingKey: spendingPubKey,
+        spendingPubKey,
+        viewingPubKey,
+        spendingScalar,
+      };
+      setSolanaKeys(keys as SolanaStealthKeys);
+      setSolanaMetaAddress(kitData.metaAddress);
+    } else if (chain === 'ckb' || kitData.metaAddress?.startsWith('st:ckb:')) {
+      const keys: any = {
+        viewingKey: kitData.viewingScalarHex,
+        spendingPubKey: kitData.spendingPubKeyHex || '',
+        viewingPubKey: kitData.viewingPubKeyHex || '',
+        spendingScalar: kitData.spendingScalarHex || '',
+      };
+      setCkbKeys(keys as CKBStealthKeys);
+      setCkbMetaAddress(kitData.metaAddress);
+    } else {
+      const keys: any = {
+        viewingKey,
+        viewingScalar: viewingKey,
+        spendingKey: spendingPubKey,
+        spendingPubKey,
+        viewingPubKey,
+        spendingScalar,
+      };
+      setStellarKeys(keys as StellarStealthKeys);
+      setStellarMetaAddress(kitData.metaAddress);
+    }
+
+    if (kitData.labels) {
+      try {
+        importLabels(kitData.metaAddress, JSON.stringify(kitData.labels), true);
+      } catch {
+        // Labels restore optional
+      }
+    }
   }, []);
 
   return (
@@ -80,6 +195,12 @@ export function StealthKeysProvider({ children }: { children: React.ReactNode })
         solanaMetaAddress,
         ckbKeys,
         ckbMetaAddress,
+        isRecoveryMode,
+        isReadOnly,
+        setIsRecoveryMode,
+        setIsReadOnly,
+        restoreFromRecoveryKit,
+        exitRecoveryMode,
         setEvmKeys,
         setEvmMetaAddress,
         setStellarKeys,
diff --git a/src/lib/stellar/recoveryKit.test.ts b/src/lib/stellar/recoveryKit.test.ts
new file mode 100644
index 0000000..0832aca
--- /dev/null
+++ b/src/lib/stellar/recoveryKit.test.ts
@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validatePassphrase,
+  generateRecoveryFilename,
+  exportRecoveryKit,
+  importRecoveryKit,
+} from './recoveryKit';
+
+describe('recoveryKit', () => {
+  it('validates passphrase strength and blocks weak passphrases (< 8 chars)', () => {
+    const weak1 = validatePassphrase('short');
+    expect(weak1.valid).toBe(false);
+    expect(weak1.score).toBe(0);
+    expect(weak1.message).toContain('at least 8 characters');
+
+    const weak2 = validatePassphrase('1234567');
+    expect(weak2.valid).toBe(false);
+
+    const valid = validatePassphrase('securePass123!');
+    expect(valid.valid).toBe(true);
+    expect(valid.score).toBeGreaterThanOrEqual(3);
+  });
+
+  it('generates filename including meta-address prefix', () => {
+    const filename = generateRecoveryFilename('st:xlm:0x1234567890abcdef');
+    expect(filename).toContain('wraith-recovery-kit-1234567890ab-');
+    expect(filename.endsWith('.json')).toBe(true);
+  });
+
+  it('round-trips export and import encrypted kit', async () => {
+    const options = {
+      passphrase: 'super-secret-passphrase-123',
+      chain: 'stellar',
+      metaAddress: 'st:xlm:0xabcdef1234567890',
+      viewingScalarHex: '0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20',
+      viewingPubKeyHex: '2122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40',
+      spendingPubKeyHex: '4142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f60',
+      spendingScalarHex: '6162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80',
+      labels: {
+        '0x123': { label: 'Test Payment', tags: ['vip'] },
+      },
+    };
+
+    const encryptedKit = await exportRecoveryKit(options);
+    expect(encryptedKit.version).toBe(1);
+    expect(encryptedKit.salt).toBeDefined();
+    expect(encryptedKit.iv).toBeDefined();
+    expect(encryptedKit.ciphertext).toBeDefined();
+
+    const restored = await importRecoveryKit(encryptedKit, 'super-secret-passphrase-123');
+    expect(restored.chain).toBe('stellar');
+    expect(restored.metaAddress).toBe('st:xlm:0xabcdef1234567890');
+    expect(restored.viewingScalarHex).toBe(options.viewingScalarHex);
+    expect(restored.viewingPubKeyHex).toBe(options.viewingPubKeyHex);
+    expect(restored.spendingPubKeyHex).toBe(options.spendingPubKeyHex);
+    expect(restored.spendingScalarHex).toBe(options.spendingScalarHex);
+    expect(restored.labels).toEqual(options.labels);
+  });
+
+  it('throws error when exporting with weak passphrase (< 8 chars)', async () => {
+    await expect(
+      exportRecoveryKit({
+        passphrase: 'weak',
+        chain: 'stellar',
+        metaAddress: 'st:xlm:0x123',
+        viewingScalarHex: '010203',
+      }),
+    ).rejects.toThrow('Passphrase must be at least 8 characters long');
+  });
+
+  it('throws error when importing with wrong passphrase', async () => {
+    const encryptedKit = await exportRecoveryKit({
+      passphrase: 'correct-passphrase-123',
+      chain: 'stellar',
+      metaAddress: 'st:xlm:0x123',
+      viewingScalarHex: '0102030405',
+    });
+
+    await expect(importRecoveryKit(encryptedKit, 'wrong-passphrase-456')).rejects.toThrow(
+      'Failed to decrypt recovery kit',
+    );
+  });
+});
diff --git a/src/lib/stellar/recoveryKit.ts b/src/lib/stellar/recoveryKit.ts
new file mode 100644
index 0000000..d9d2045
--- /dev/null
+++ b/src/lib/stellar/recoveryKit.ts
@@ -0,0 +1,188 @@
+export interface RecoveryKitData {
+  version: 1;
+  chain: string;
+  metaAddress: string;
+  viewingScalarHex: string;
+  viewingPubKeyHex?: string;
+  spendingPubKeyHex?: string;
+  spendingScalarHex?: string;
+  labels?: Record<string, any>;
+  createdAt: number;
+}
+
+export interface EncryptedRecoveryKit {
+  version: 1;
+  salt: string;
+  iv: string;
+  iterations: number;
+  ciphertext: string;
+}
+
+export interface PassphraseStrength {
+  valid: boolean;
+  score: number; // 0 to 4
+  label: 'Weak' | 'Fair' | 'Good' | 'Strong';
+  message?: string;
+}
+
+export function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+export function hexToBytes(hex: string): Uint8Array {
+  const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+  if (cleanHex.length % 2 !== 0) {
+    throw new Error('Invalid hex string length');
+  }
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+export function validatePassphrase(passphrase: string): PassphraseStrength {
+  if (!passphrase || passphrase.length < 8) {
+    return {
+      valid: false,
+      score: 0,
+      label: 'Weak',
+      message: 'Passphrase must be at least 8 characters long',
+    };
+  }
+
+  let score = 1;
+  if (passphrase.length >= 12) score += 1;
+  if (/[A-Z]/.test(passphrase) && /[a-z]/.test(passphrase)) score += 1;
+  if (/[0-9]/.test(passphrase)) score += 1;
+  if (/[^A-Za-z0-9]/.test(passphrase)) score += 1;
+
+  score = Math.min(score, 4);
+
+  const labels: Record<number, 'Weak' | 'Fair' | 'Good' | 'Strong'> = {
+    1: 'Weak',
+    2: 'Fair',
+    3: 'Good',
+    4: 'Strong',
+  };
+
+  return {
+    valid: true,
+    score,
+    label: labels[score] || 'Fair',
+  };
+}
+
+export function generateRecoveryFilename(metaAddress: string): string {
+  const prefix = metaAddress
+    .replace(/^st:[a-z]+:/i, '')
+    .replace(/[^a-zA-Z0-9]/g, '')
+    .slice(0, 12);
+  const cleanPrefix = prefix || 'stealth';
+  const dateStr = new Date().toISOString().slice(0, 10);
+  return `wraith-recovery-kit-${cleanPrefix}-${dateStr}.json`;
+}
+
+async function deriveKey(
+  passphrase: string,
+  salt: Uint8Array,
+  iterations: number,
+): Promise<CryptoKey> {
+  const enc = new TextEncoder();
+  const baseKey = await crypto.subtle.importKey('raw', enc.encode(passphrase), 'PBKDF2', false, [
+    'deriveKey',
+  ]);
+  return crypto.subtle.deriveKey(
+    {
+      name: 'PBKDF2',
+      salt: salt as unknown as BufferSource,
+      iterations,
+      hash: 'SHA-256',
+    },
+    baseKey,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['encrypt', 'decrypt'],
+  );
+}
+
+export async function exportRecoveryKit(options: {
+  passphrase: string;
+  chain: string;
+  metaAddress: string;
+  viewingScalarHex: string;
+  viewingPubKeyHex?: string;
+  spendingPubKeyHex?: string;
+  spendingScalarHex?: string;
+  labels?: Record<string, any>;
+}): Promise<EncryptedRecoveryKit> {
+  const strength = validatePassphrase(options.passphrase);
+  if (!strength.valid) {
+    throw new Error(strength.message || 'Passphrase must be at least 8 characters long');
+  }
+
+  const payload: RecoveryKitData = {
+    version: 1,
+    chain: options.chain,
+    metaAddress: options.metaAddress,
+    viewingScalarHex: options.viewingScalarHex,
+    viewingPubKeyHex: options.viewingPubKeyHex,
+    spendingPubKeyHex: options.spendingPubKeyHex,
+    spendingScalarHex: options.spendingScalarHex,
+    labels: options.labels,
+    createdAt: Date.now(),
+  };
+
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const iterations = 100000;
+
+  const key = await deriveKey(options.passphrase, salt, iterations);
+  const enc = new TextEncoder();
+  const ciphertextBuffer = await crypto.subtle.encrypt(
+    { name: 'AES-GCM', iv: iv as unknown as BufferSource },
+    key,
+    enc.encode(JSON.stringify(payload)),
+  );
+
+  return {
+    version: 1,
+    salt: bytesToHex(salt),
+    iv: bytesToHex(iv),
+    iterations,
+    ciphertext: bytesToHex(new Uint8Array(ciphertextBuffer)),
+  };
+}
+
+export async function importRecoveryKit(
+  encryptedInput: string | EncryptedRecoveryKit,
+  passphrase: string,
+): Promise<RecoveryKitData> {
+  const pkg: EncryptedRecoveryKit =
+    typeof encryptedInput === 'string' ? JSON.parse(encryptedInput) : encryptedInput;
+
+  if (pkg.version !== 1 || !pkg.salt || !pkg.iv || !pkg.ciphertext) {
+    throw new Error('Invalid recovery kit format');
+  }
+
+  const salt = hexToBytes(pkg.salt);
+  const iv = hexToBytes(pkg.iv);
+  const ciphertext = hexToBytes(pkg.ciphertext);
+
+  const key = await deriveKey(passphrase, salt, pkg.iterations || 100000);
+
+  try {
+    const decryptedBuffer = await crypto.subtle.decrypt(
+      { name: 'AES-GCM', iv: iv as unknown as BufferSource },
+      key,
+      ciphertext as unknown as BufferSource,
+    );
+    const dec = new TextDecoder();
+    const jsonStr = dec.decode(decryptedBuffer);
+    return JSON.parse(jsonStr) as RecoveryKitData;
+  } catch {
+    throw new Error('Failed to decrypt recovery kit. Incorrect passphrase or corrupted file.');
+  }
+}
diff --git a/src/pages/Settings.tsx b/src/pages/Settings.tsx
index 9dd8582..391f053 100644
--- a/src/pages/Settings.tsx
+++ b/src/pages/Settings.tsx
@@ -1,4 +1,15 @@
+import { useState, useRef } from 'react';
 import { useTheme, type ThemePreference } from '@/context/ThemeContext';
+import { useStealthKeys } from '@/context/StealthKeysContext';
+import { useChain } from '@/context/ChainContext';
+import { getLabels } from '@/lib/stealthLabels';
+import {
+  exportRecoveryKit,
+  importRecoveryKit,
+  validatePassphrase,
+  generateRecoveryFilename,
+  bytesToHex,
+} from '@/lib/stellar/recoveryKit';
 
 const preferences: Array<{ value: ThemePreference; label: string; description: string }> = [
   {
@@ -12,6 +23,209 @@ const preferences: Array<{ value: ThemePreference; label: string; description: s
 
 export default function Settings() {
   const { preference, setThemePreference } = useTheme();
+  const { chain } = useChain();
+  const {
+    evmKeys,
+    evmMetaAddress,
+    stellarKeys,
+    stellarMetaAddress,
+    solanaKeys,
+    solanaMetaAddress,
+    ckbKeys,
+    ckbMetaAddress,
+    isRecoveryMode,
+    isReadOnly,
+    restoreFromRecoveryKit,
+    exitRecoveryMode,
+  } = useStealthKeys();
+
+  // Export State
+  const [exportPassphrase, setExportPassphrase] = useState('');
+  const [includeSpendingScalar, setIncludeSpendingScalar] = useState(true);
+  const [exportMessage, setExportMessage] = useState<{
+    type: 'success' | 'error';
+    text: string;
+  } | null>(null);
+  const [isExporting, setIsExporting] = useState(false);
+
+  // Restore State
+  const [restorePassphrase, setRestorePassphrase] = useState('');
+  const [selectedFileContent, setSelectedFileContent] = useState<string | null>(null);
+  const [selectedFileName, setSelectedFileName] = useState<string | null>(null);
+  const [restoreMessage, setRestoreMessage] = useState<{
+    type: 'success' | 'error';
+    text: string;
+  } | null>(null);
+  const [isRestoring, setIsRestoring] = useState(false);
+  const fileInputRef = useRef<HTMLInputElement>(null);
+
+  // Active meta-address and keys for current chain
+  const activeMetaAddress =
+    chain === 'stellar'
+      ? stellarMetaAddress
+      : chain === 'horizen'
+        ? evmMetaAddress
+        : chain === 'solana'
+          ? solanaMetaAddress
+          : ckbMetaAddress;
+
+  const activeKeys =
+    chain === 'stellar'
+      ? stellarKeys
+      : chain === 'horizen'
+        ? evmKeys
+        : chain === 'solana'
+          ? solanaKeys
+          : ckbKeys;
+
+  const passphraseStrength = validatePassphrase(exportPassphrase);
+
+  const handleExportKit = async () => {
+    setExportMessage(null);
+
+    if (!exportPassphrase) {
+      setExportMessage({ type: 'error', text: 'Enter a passphrase to encrypt your recovery kit.' });
+      return;
+    }
+
+    if (!passphraseStrength.valid) {
+      setExportMessage({
+        type: 'error',
+        text: passphraseStrength.message || 'Passphrase must be at least 8 characters long.',
+      });
+      return;
+    }
+
+    if (!activeMetaAddress || !activeKeys) {
+      setExportMessage({
+        type: 'error',
+        text: 'No derived stealth keys active for export. Please derive keys on the Receive page first.',
+      });
+      return;
+    }
+
+    setIsExporting(true);
+
+    try {
+      // Extract viewing and spending scalar hex
+      const viewingKey = (activeKeys as any).viewingKey || (activeKeys as any).viewingScalar;
+      const viewingScalarHex = viewingKey
+        ? typeof viewingKey === 'string'
+          ? viewingKey
+          : bytesToHex(viewingKey as Uint8Array)
+        : '';
+
+      const viewingPubKeyHex = activeKeys.viewingPubKey
+        ? typeof activeKeys.viewingPubKey === 'string'
+          ? activeKeys.viewingPubKey
+          : bytesToHex(activeKeys.viewingPubKey as Uint8Array)
+        : undefined;
+      const spendingPubKeyHex = activeKeys.spendingPubKey
+        ? typeof activeKeys.spendingPubKey === 'string'
+          ? activeKeys.spendingPubKey
+          : bytesToHex(activeKeys.spendingPubKey as Uint8Array)
+        : undefined;
+
+      let spendingScalarHex: string | undefined = undefined;
+      const spendingScalar = (activeKeys as any).spendingScalar;
+      if (includeSpendingScalar && spendingScalar) {
+        spendingScalarHex =
+          typeof spendingScalar === 'bigint'
+            ? spendingScalar.toString(16).padStart(64, '0')
+            : String(spendingScalar);
+      }
+
+      // Profile labels
+      const labels = getLabels(activeMetaAddress);
+
+      const encryptedKit = await exportRecoveryKit({
+        passphrase: exportPassphrase,
+        chain,
+        metaAddress: activeMetaAddress,
+        viewingScalarHex,
+        viewingPubKeyHex,
+        spendingPubKeyHex,
+        spendingScalarHex,
+        labels,
+      });
+
+      // Trigger download
+      const filename = generateRecoveryFilename(activeMetaAddress);
+      const blob = new Blob([JSON.stringify(encryptedKit, null, 2)], { type: 'application/json' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = filename;
+      a.click();
+      URL.revokeObjectURL(url);
+
+      setExportMessage({
+        type: 'success',
+        text: `Recovery kit exported successfully as "${filename}". Keep it safe offline!`,
+      });
+      setExportPassphrase('');
+    } catch (err) {
+      setExportMessage({
+        type: 'error',
+        text: err instanceof Error ? err.message : 'Failed to export recovery kit.',
+      });
+    } finally {
+      setIsExporting(false);
+    }
+  };
+
+  const handleFileSelect = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+    setSelectedFileName(file.name);
+    const reader = new FileReader();
+    reader.onload = (ev) => {
+      setSelectedFileContent(ev.target?.result as string);
+    };
+    reader.readAsText(file);
+  };
+
+  const handleRestoreKit = async () => {
+    setRestoreMessage(null);
+
+    if (!selectedFileContent) {
+      setRestoreMessage({ type: 'error', text: 'Please select a valid recovery kit JSON file.' });
+      return;
+    }
+
+    if (!restorePassphrase) {
+      setRestoreMessage({
+        type: 'error',
+        text: 'Enter the passphrase used when creating the recovery kit.',
+      });
+      return;
+    }
+
+    setIsRestoring(true);
+
+    try {
+      const kitData = await importRecoveryKit(selectedFileContent, restorePassphrase);
+      restoreFromRecoveryKit(kitData);
+
+      setRestoreMessage({
+        type: 'success',
+        text: `Recovery kit successfully restored! Session set to ${
+          kitData.spendingScalarHex ? 'full recovery' : 'receive-only'
+        } mode for meta-address "${kitData.metaAddress}".`,
+      });
+      setRestorePassphrase('');
+      setSelectedFileContent(null);
+      setSelectedFileName(null);
+      if (fileInputRef.current) fileInputRef.current.value = '';
+    } catch (err) {
+      setRestoreMessage({
+        type: 'error',
+        text: err instanceof Error ? err.message : 'Failed to restore recovery kit.',
+      });
+    } finally {
+      setIsRestoring(false);
+    }
+  };
 
   return (
     <section className="flex flex-col gap-8">
@@ -23,11 +237,214 @@ export default function Settings() {
           Settings
         </h1>
         <p className="font-body text-sm leading-relaxed text-on-surface-variant">
-          Choose how Wraith should display colors. System default updates immediately when your OS
-          theme changes.
+          Manage application settings, appearance preferences, and offline recovery kits.
         </p>
       </div>
 
+      {/* Active Recovery Mode Banner */}
+      {isRecoveryMode && (
+        <div className="flex flex-col gap-3 border border-amber-500/40 bg-amber-500/10 p-5">
+          <div className="flex items-center justify-between">
+            <span className="font-mono text-[10px] font-bold uppercase tracking-widest text-amber-400">
+              Active Session: Recovery Mode
+            </span>
+            <span className="font-mono text-[9px] uppercase tracking-wider text-amber-400">
+              {isReadOnly ? 'Receive-Only (Viewing)' : 'Full Recovery'}
+            </span>
+          </div>
+          <p className="font-body text-xs text-on-surface-variant">
+            You are currently scanning past deposits using a restored recovery kit.
+          </p>
+          <button
+            onClick={exitRecoveryMode}
+            className="w-fit border border-amber-500/40 bg-surface px-4 py-2 font-heading text-xs font-semibold uppercase tracking-widest text-amber-400 hover:bg-amber-500/20"
+          >
+            Exit Recovery Mode
+          </button>
+        </div>
+      )}
+
+      {/* Export Recovery Kit */}
+      <fieldset className="flex flex-col gap-4 border border-outline-variant bg-surface-container p-5">
+        <legend className="font-mono text-[10px] uppercase tracking-widest text-on-surface">
+          Export Recovery Kit
+        </legend>
+        <p className="font-body text-xs leading-relaxed text-on-surface-variant">
+          Export an AES-GCM passphrase-encrypted JSON recovery kit containing your stealth viewing
+          scalar, meta-address, active chain, and profile labels. Back it up offline to regain scan
+          access on a fresh browser.
+        </p>
+
+        <div className="border border-outline-variant/60 bg-surface/50 p-3 font-mono text-xs text-on-surface-variant">
+          <span className="font-semibold text-on-surface">Security Notice: </span>
+          The kit gives scan access (viewing scalar) and, if included below, spend authority
+          (spending scalar). Keep your passphrase and backup file safe!
+        </div>
+
+        {activeMetaAddress ? (
+          <div className="flex flex-col gap-1.5">
+            <span className="font-mono text-[10px] uppercase tracking-widest text-outline">
+              Active Meta-Address
+            </span>
+            <code className="break-all border border-outline-variant bg-surface p-2.5 font-mono text-xs text-primary">
+              {activeMetaAddress}
+            </code>
+          </div>
+        ) : (
+          <p className="font-mono text-xs text-amber-400">
+            No active stealth keys found for current chain ({chain}). Connect wallet or derive keys
+            on Receive page to export a kit.
+          </p>
+        )}
+
+        <div className="flex flex-col gap-2">
+          <label className="font-mono text-[10px] uppercase tracking-widest text-outline">
+            Encryption Passphrase (Min 8 Characters)
+          </label>
+          <input
+            type="password"
+            value={exportPassphrase}
+            onChange={(e) => setExportPassphrase(e.target.value)}
+            placeholder="Enter a strong passphrase"
+            className="h-11 w-full border border-outline-variant bg-surface px-3.5 font-mono text-sm text-primary placeholder:text-outline focus:border-primary"
+          />
+
+          {/* Strength Meter */}
+          {exportPassphrase.length > 0 && (
+            <div className="flex flex-col gap-1 mt-1">
+              <div className="flex items-center justify-between font-mono text-[10px] uppercase tracking-wider">
+                <span className="text-outline">Passphrase Strength:</span>
+                <span
+                  className={
+                    passphraseStrength.score <= 1
+                      ? 'text-error font-bold'
+                      : passphraseStrength.score === 2
+                        ? 'text-amber-400 font-bold'
+                        : 'text-tertiary font-bold'
+                  }
+                >
+                  {passphraseStrength.label} {passphraseStrength.score < 1 && '(Weak - <8 chars)'}
+                </span>
+              </div>
+              <div className="flex h-1.5 w-full gap-1 bg-surface-bright">
+                {[1, 2, 3, 4].map((step) => (
+                  <div
+                    key={step}
+                    className={`h-full flex-1 transition-colors ${
+                      step <= passphraseStrength.score
+                        ? passphraseStrength.score <= 1
+                          ? 'bg-error'
+                          : passphraseStrength.score === 2
+                            ? 'bg-amber-400'
+                            : 'bg-tertiary'
+                        : 'bg-outline-variant/30'
+                    }`}
+                  />
+                ))}
+              </div>
+              {!passphraseStrength.valid && (
+                <span className="font-mono text-[10px] text-error">
+                  Passphrase must be at least 8 characters long to export.
+                </span>
+              )}
+            </div>
+          )}
+        </div>
+
+        <label className="flex cursor-pointer items-center gap-2 font-mono text-xs text-on-surface">
+          <input
+            type="checkbox"
+            checked={includeSpendingScalar}
+            onChange={(e) => setIncludeSpendingScalar(e.target.checked)}
+            className="h-4 w-4 rounded-none border-outline-variant bg-surface text-primary focus:ring-0"
+          />
+          <span>Include spending scalar in kit (allows spend authority)</span>
+        </label>
+
+        <button
+          onClick={handleExportKit}
+          disabled={!activeMetaAddress || !activeKeys || !passphraseStrength.valid || isExporting}
+          className="h-11 bg-primary px-5 font-heading text-xs font-semibold uppercase tracking-widest text-surface transition-colors hover:brightness-110 disabled:opacity-30"
+        >
+          {isExporting ? 'Exporting...' : 'Export Recovery Kit'}
+        </button>
+
+        {exportMessage && (
+          <p
+            className={`font-mono text-xs ${
+              exportMessage.type === 'success' ? 'text-tertiary' : 'text-error'
+            }`}
+          >
+            {exportMessage.text}
+          </p>
+        )}
+      </fieldset>
+
+      {/* Restore Recovery Kit */}
+      <fieldset className="flex flex-col gap-4 border border-outline-variant bg-surface-container p-5">
+        <legend className="font-mono text-[10px] uppercase tracking-widest text-on-surface">
+          Restore Recovery Kit
+        </legend>
+        <p className="font-body text-xs leading-relaxed text-on-surface-variant">
+          Restore a passphrase-encrypted JSON recovery kit on a fresh browser to unlock receive-only
+          scanning mode without needing the original wallet.
+        </p>
+
+        <input
+          ref={fileInputRef}
+          type="file"
+          accept=".json"
+          onChange={handleFileSelect}
+          className="hidden"
+        />
+
+        <div className="flex items-center gap-3">
+          <button
+            onClick={() => fileInputRef.current?.click()}
+            className="h-10 border border-outline-variant bg-surface px-4 font-heading text-xs font-semibold uppercase tracking-widest text-primary transition-colors hover:bg-surface-bright"
+          >
+            {selectedFileName ? 'Change Kit File' : 'Select Recovery Kit (.json)'}
+          </button>
+          {selectedFileName && (
+            <span className="truncate font-mono text-xs text-on-surface-variant">
+              {selectedFileName}
+            </span>
+          )}
+        </div>
+
+        <div className="flex flex-col gap-1.5">
+          <label className="font-mono text-[10px] uppercase tracking-widest text-outline">
+            Decryption Passphrase
+          </label>
+          <input
+            type="password"
+            value={restorePassphrase}
+            onChange={(e) => setRestorePassphrase(e.target.value)}
+            placeholder="Enter passphrase used at export"
+            className="h-11 w-full border border-outline-variant bg-surface px-3.5 font-mono text-sm text-primary placeholder:text-outline focus:border-primary"
+          />
+        </div>
+
+        <button
+          onClick={handleRestoreKit}
+          disabled={!selectedFileContent || !restorePassphrase || isRestoring}
+          className="h-11 bg-primary px-5 font-heading text-xs font-semibold uppercase tracking-widest text-surface transition-colors hover:brightness-110 disabled:opacity-30"
+        >
+          {isRestoring ? 'Decrypting & Restoring...' : 'Restore Recovery Kit'}
+        </button>
+
+        {restoreMessage && (
+          <p
+            className={`font-mono text-xs ${
+              restoreMessage.type === 'success' ? 'text-tertiary' : 'text-error'
+            }`}
+          >
+            {restoreMessage.text}
+          </p>
+        )}
+      </fieldset>
+
+      {/* Appearance Preferences */}
       <fieldset className="flex flex-col gap-3 border border-outline-variant bg-surface-container p-5">
         <legend className="font-mono text-[10px] uppercase tracking-widest text-on-surface">
           Appearance
diff --git a/src/vault/KeyVault.ts b/src/vault/KeyVault.ts
index 43ccf32..a8936c2 100644
--- a/src/vault/KeyVault.ts
+++ b/src/vault/KeyVault.ts
@@ -396,4 +396,44 @@ export class KeyVault {
       this.resetIdleTimer();
     }
   }
+
+  async exportRecoveryKit(
+    label: string,
+    passphrase: string,
+    metaAddress: string,
+    chain = 'stellar',
+    labels?: Record<string, any>,
+  ) {
+    const keys = await this.get<any>(label);
+    if (!keys) {
+      throw new Error(`No keys found in vault for label "${label}"`);
+    }
+
+    const { exportRecoveryKit: exportKit, bytesToHex: bToHex } =
+      await import('@/lib/stellar/recoveryKit');
+
+    const viewingScalarHex = keys.viewingKey
+      ? typeof keys.viewingKey === 'string'
+        ? keys.viewingKey
+        : bToHex(keys.viewingKey)
+      : '';
+    const viewingPubKeyHex = keys.viewingPubKey ? bToHex(keys.viewingPubKey) : undefined;
+    const spendingPubKeyHex = keys.spendingPubKey ? bToHex(keys.spendingPubKey) : undefined;
+    const spendingScalarHex = keys.spendingScalar
+      ? typeof keys.spendingScalar === 'bigint'
+        ? keys.spendingScalar.toString(16).padStart(64, '0')
+        : String(keys.spendingScalar)
+      : undefined;
+
+    return exportKit({
+      passphrase,
+      chain,
+      metaAddress,
+      viewingScalarHex,
+      viewingPubKeyHex,
+      spendingPubKeyHex,
+      spendingScalarHex,
+      labels,
+    });
+  }
 }