style: fix lint errors and format issues

- Remove unused configStore import from CompactMode.svelte - Add key to each block in CompactMode.svelte - Fix useless escape characters in config.ts path masking - Apply Prettier formatting to StatusBar, Terminal, and +page.svelte
feat: add compact mode for minimal widget interface (#36 )
2026-01-25 19:09:03 -08:00 · 2026-01-25 18:51:39 -08:00 · 2026-01-25 18:15:47 -08:00 · 2026-01-25 17:41:20 -08:00 · 2026-01-25 17:40:03 -08:00 · 2026-01-25 17:07:32 -08:00
46 changed files with 230 additions and 11857 deletions
@@ -49,13 +49,13 @@ jobs:
      - name: Run Svelte Check
        run: pnpm check

-      - name: Run frontend tests with coverage
-        run: pnpm test:coverage
+      - name: Run frontend tests
+        run: pnpm test

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable
        with:
-          components: clippy, llvm-tools-preview
+          components: clippy

      - name: Cache Rust dependencies
        uses: actions/cache@v4
@@ -68,16 +68,13 @@ jobs:
            src-tauri/target/
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}

-      - name: Install cargo-llvm-cov
-        run: cargo install cargo-llvm-cov --locked
-
      - name: Run Clippy
        working-directory: src-tauri
        run: cargo clippy --all-targets --all-features -- -D warnings

-      - name: Run Rust tests with coverage
+      - name: Run Rust tests
        working-directory: src-tauri
-        run: cargo llvm-cov --fail-under-lines 50
+        run: cargo test

  build-linux:
    name: Build Linux
@@ -8,6 +8,3 @@ node_modules
 !.env.example
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
-
-# Coverage reports
-/coverage
@@ -0,0 +1,74 @@
+# Hikari Desktop v0.3.0 Release Notes
+
+## New Features
+
+### AskUserQuestion Tool Support (#51)
+
+- Claude can now ask you questions with multiple choice options during conversations
+- A dedicated modal appears with answer choices and support for custom responses
+- Answers are seamlessly integrated back into the conversation context
+
+### Slash Commands
+
+- `/cd <path>` - Change the working directory while preserving conversation context (#55)
+- `/search <query>` - Search and highlight matches within the conversation (#32)
+- `/skill <name> [data]` - Invoke Claude Code skills from `~/.claude/skills/` (#57)
+- `/new`, `/clear`, `/rename`, `/help` commands for conversation management (#6)
+
+### Auto-Update Checker (#17)
+
+- Automatically checks for new releases on startup
+- Notification appears when a newer version is available
+- Can be disabled in settings
+
+### Font Size & Zoom (#19)
+
+- Adjust font size with keyboard shortcuts: `Ctrl++`, `Ctrl+-`, `Ctrl+0`
+- Font size slider in settings (10-24px range)
+- Preference persists between sessions
+
+### Resizable Character Panel (#10)
+
+- Drag the divider between the character panel and terminal to resize
+- Panel width is saved and restored on app restart
+- Sprite now uses full height for better proportions
+
+### Input History Navigation (#13)
+
+- Use up/down arrows to navigate through previous messages and commands
+- Arrow keys only navigate history when input is empty - otherwise they move the cursor (#58)
+
+### Keyboard Shortcuts (#21)
+
+- `Ctrl+N` - New conversation
+- `Ctrl+W` - Close current tab
+- `Ctrl+Tab` / `Ctrl+Shift+Tab` - Switch between tabs
+- `Ctrl+L` - Clear conversation
+- `Ctrl+,` - Open settings
+
+### Always On Top Toggle (#28)
+
+- Pin the window to stay above other applications
+- Toggle in settings
+
+## Improvements
+
+### UI/UX
+
+- Resizable chat input with drag handle (expands upward)
+- Send button properly aligned with input field
+- Markdown rendering with syntax-highlighted code blocks (#31, #33)
+- Light mode text colors improved for better readability
+- Scroll position persists per conversation tab when switching
+- Confirmation modal when closing connected tabs
+- Links in chat now open in default browser (#54)
+- Spaces allowed when renaming tabs (#52)
+
+### State Management
+
+- Stats (tokens, cost) persist across session changes and only reset on disconnect (#59)
+- Multiple tabs can now request permissions simultaneously without conflicts
+
+## Closed Issues
+
+#6, #10, #13, #17, #19, #21, #28, #31, #32, #33, #51, #52, #54, #55, #57, #58, #59
@@ -27,6 +27,6 @@ export default tseslint.config(
    },
  },
  {
-    ignores: ["build/", ".svelte-kit/", "dist/", "src-tauri/target/", "node_modules/", "coverage/"],
+    ignores: ["build/", ".svelte-kit/", "dist/", "src-tauri/target/", "node_modules/"],
  }
 );
@@ -1,6 +1,6 @@
 {
  "name": "hikari-desktop",
-  "version": "1.0.0",
+  "version": "0.3.0",
  "description": "",
  "type": "module",
  "scripts": {
@@ -16,10 +16,6 @@
    "test": "vitest run",
    "test:watch": "vitest",
    "test:coverage": "vitest run --coverage",
-    "test:backend": "cd src-tauri && cargo test",
-    "test:backend:coverage": "cd src-tauri && cargo llvm-cov --text",
-    "test:all": "pnpm test && pnpm test:backend",
-    "coverage:all": "pnpm test:coverage && pnpm test:backend:coverage",
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
    "format": "prettier --write .",
@@ -48,7 +44,6 @@
    "@tauri-apps/cli": "^2",
    "@testing-library/jest-dom": "^6.9.1",
    "@testing-library/svelte": "^5.3.1",
-    "@vitest/coverage-v8": "^4.0.18",
    "eslint": "^9.39.2",
    "eslint-config-prettier": "^10.1.8",
    "eslint-plugin-svelte": "^3.14.0",
@@ -66,9 +66,6 @@ importers:
      '@testing-library/svelte':
        specifier: ^5.3.1
        version: 5.3.1(svelte@5.46.3)(vite@6.4.1(jiti@2.6.1)(lightningcss@1.30.2))(vitest@4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2))
-      '@vitest/coverage-v8':
-        specifier: ^4.0.18
-        version: 4.0.18(vitest@4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2))
      eslint:
        specifier: ^9.39.2
        version: 9.39.2(jiti@2.6.1)
@@ -133,31 +130,14 @@ packages:
    resolution: {integrity: sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==}
    engines: {node: '>=6.9.0'}

-  '@babel/helper-string-parser@7.27.1':
-    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
-    engines: {node: '>=6.9.0'}
-
  '@babel/helper-validator-identifier@7.28.5':
    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
    engines: {node: '>=6.9.0'}

-  '@babel/parser@7.28.6':
-    resolution: {integrity: sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-
  '@babel/runtime@7.28.6':
    resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==}
    engines: {node: '>=6.9.0'}

-  '@babel/types@7.28.6':
-    resolution: {integrity: sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==}
-    engines: {node: '>=6.9.0'}
-
-  '@bcoe/v8-coverage@1.0.2':
-    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
-    engines: {node: '>=18'}
-
  '@csstools/color-helpers@5.1.0':
    resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
    engines: {node: '>=18'}
@@ -889,15 +869,6 @@ packages:
    resolution: {integrity: sha512-LZ2NqIHFhvFwxG0qZeLL9DvdNAHPGCY5dIRwBhyYeU+LfLhcStE1ImjsuTG/WaVh3XysGaeLW8Rqq7cGkPCFvw==}
    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}

-  '@vitest/coverage-v8@4.0.18':
-    resolution: {integrity: sha512-7i+N2i0+ME+2JFZhfuz7Tg/FqKtilHjGyGvoHYQ6iLV0zahbsJ9sljC9OcFcPDbhYKCet+sG8SsVqlyGvPflZg==}
-    peerDependencies:
-      '@vitest/browser': 4.0.18
-      vitest: 4.0.18
-    peerDependenciesMeta:
-      '@vitest/browser':
-        optional: true
-
  '@vitest/expect@4.0.17':
    resolution: {integrity: sha512-mEoqP3RqhKlbmUmntNDDCJeTDavDR+fVYkSOw8qRwJFaW/0/5zA9zFeTrHqNtcmwh6j26yMmwx2PqUDPzt5ZAQ==}

@@ -915,9 +886,6 @@ packages:
  '@vitest/pretty-format@4.0.17':
    resolution: {integrity: sha512-Ah3VAYmjcEdHg6+MwFE17qyLqBHZ+ni2ScKCiW2XrlSBV4H3Z7vYfPfz7CWQ33gyu76oc0Ai36+kgLU3rfF4nw==}

-  '@vitest/pretty-format@4.0.18':
-    resolution: {integrity: sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==}
-
  '@vitest/runner@4.0.17':
    resolution: {integrity: sha512-JmuQyf8aMWoo/LmNFppdpkfRVHJcsgzkbCA+/Bk7VfNH7RE6Ut2qxegeyx2j3ojtJtKIbIGy3h+KxGfYfk28YQ==}

@@ -930,9 +898,6 @@ packages:
  '@vitest/utils@4.0.17':
    resolution: {integrity: sha512-RG6iy+IzQpa9SB8HAFHJ9Y+pTzI+h8553MrciN9eC6TFBErqrQaTas4vG+MVj8S4uKk8uTT2p0vgZPnTdxd96w==}

-  '@vitest/utils@4.0.18':
-    resolution: {integrity: sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==}
-
  acorn-jsx@5.3.2:
    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
    peerDependencies:
@@ -976,9 +941,6 @@ packages:
    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
    engines: {node: '>=12'}

-  ast-v8-to-istanbul@0.3.10:
-    resolution: {integrity: sha512-p4K7vMz2ZSk3wN8l5o3y2bJAoZXT3VuJI5OLTATY/01CYWumWvwkUw0SqDBnNq6IiTO3qDa1eSQDibAV8g7XOQ==}
-
  axobject-query@4.1.0:
    resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
    engines: {node: '>= 0.4'}
@@ -1249,9 +1211,6 @@ packages:
    resolution: {integrity: sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==}
    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}

-  html-escaper@2.0.2:
-    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
-
  http-proxy-agent@7.0.2:
    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
    engines: {node: '>= 14'}
@@ -1297,18 +1256,6 @@ packages:
  isexe@2.0.0:
    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}

-  istanbul-lib-coverage@3.2.2:
-    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
-    engines: {node: '>=8'}
-
-  istanbul-lib-report@3.0.1:
-    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
-    engines: {node: '>=10'}
-
-  istanbul-reports@3.2.0:
-    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
-    engines: {node: '>=8'}
-
  jiti@2.6.1:
    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
    hasBin: true
@@ -1316,9 +1263,6 @@ packages:
  js-tokens@4.0.0:
    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}

-  js-tokens@9.0.1:
-    resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
-
  js-yaml@4.1.1:
    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
    hasBin: true
@@ -1450,13 +1394,6 @@ packages:
  magic-string@0.30.21:
    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}

-  magicast@0.5.1:
-    resolution: {integrity: sha512-xrHS24IxaLrvuo613F719wvOIv9xPHFWQHuvGUBmPnCA/3MQxKI3b+r7n1jAoDHmsbC5bRhTZYR77invLAxVnw==}
-
-  make-dir@4.0.0:
-    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
-    engines: {node: '>=10'}
-
  marked@17.0.1:
    resolution: {integrity: sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg==}
    engines: {node: '>= 20'}
@@ -1932,23 +1869,10 @@ snapshots:
      js-tokens: 4.0.0
      picocolors: 1.1.1

-  '@babel/helper-string-parser@7.27.1': {}
-
  '@babel/helper-validator-identifier@7.28.5': {}

-  '@babel/parser@7.28.6':
-    dependencies:
-      '@babel/types': 7.28.6
-
  '@babel/runtime@7.28.6': {}

-  '@babel/types@7.28.6':
-    dependencies:
-      '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
-
-  '@bcoe/v8-coverage@1.0.2': {}
-
  '@csstools/color-helpers@5.1.0': {}

  '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
@@ -2545,20 +2469,6 @@ snapshots:
      '@typescript-eslint/types': 8.53.0
      eslint-visitor-keys: 4.2.1

-  '@vitest/coverage-v8@4.0.18(vitest@4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2))':
-    dependencies:
-      '@bcoe/v8-coverage': 1.0.2
-      '@vitest/utils': 4.0.18
-      ast-v8-to-istanbul: 0.3.10
-      istanbul-lib-coverage: 3.2.2
-      istanbul-lib-report: 3.0.1
-      istanbul-reports: 3.2.0
-      magicast: 0.5.1
-      obug: 2.1.1
-      std-env: 3.10.0
-      tinyrainbow: 3.0.3
-      vitest: 4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)
-
  '@vitest/expect@4.0.17':
    dependencies:
      '@standard-schema/spec': 1.1.0
@@ -2580,10 +2490,6 @@ snapshots:
    dependencies:
      tinyrainbow: 3.0.3

-  '@vitest/pretty-format@4.0.18':
-    dependencies:
-      tinyrainbow: 3.0.3
-
  '@vitest/runner@4.0.17':
    dependencies:
      '@vitest/utils': 4.0.17
@@ -2602,11 +2508,6 @@ snapshots:
      '@vitest/pretty-format': 4.0.17
      tinyrainbow: 3.0.3

-  '@vitest/utils@4.0.18':
-    dependencies:
-      '@vitest/pretty-format': 4.0.18
-      tinyrainbow: 3.0.3
-
  acorn-jsx@5.3.2(acorn@8.15.0):
    dependencies:
      acorn: 8.15.0
@@ -2640,12 +2541,6 @@ snapshots:

  assertion-error@2.0.1: {}

-  ast-v8-to-istanbul@0.3.10:
-    dependencies:
-      '@jridgewell/trace-mapping': 0.3.31
-      estree-walker: 3.0.3
-      js-tokens: 9.0.1
-
  axobject-query@4.1.0: {}

  balanced-match@1.0.2: {}
@@ -2928,8 +2823,6 @@ snapshots:
    transitivePeerDependencies:
      - '@exodus/crypto'

-  html-escaper@2.0.2: {}
-
  http-proxy-agent@7.0.2:
    dependencies:
      agent-base: 7.1.4
@@ -2971,25 +2864,10 @@ snapshots:

  isexe@2.0.0: {}

-  istanbul-lib-coverage@3.2.2: {}
-
-  istanbul-lib-report@3.0.1:
-    dependencies:
-      istanbul-lib-coverage: 3.2.2
-      make-dir: 4.0.0
-      supports-color: 7.2.0
-
-  istanbul-reports@3.2.0:
-    dependencies:
-      html-escaper: 2.0.2
-      istanbul-lib-report: 3.0.1
-
  jiti@2.6.1: {}

  js-tokens@4.0.0: {}

-  js-tokens@9.0.1: {}
-
  js-yaml@4.1.1:
    dependencies:
      argparse: 2.0.1
@@ -3108,16 +2986,6 @@ snapshots:
    dependencies:
      '@jridgewell/sourcemap-codec': 1.5.5

-  magicast@0.5.1:
-    dependencies:
-      '@babel/parser': 7.28.6
-      '@babel/types': 7.28.6
-      source-map-js: 1.2.1
-
-  make-dir@4.0.0:
-    dependencies:
-      semver: 7.7.3
-
  marked@17.0.1: {}

  mdn-data@2.12.2: {}
@@ -1,6 +1,6 @@
 [package]
 name = "hikari-desktop"
-version = "1.0.0"
+version = "0.3.0"
 description = "Hikari - Claude Code Visual Assistant"
 authors = ["Naomi Carrigan"]
 edition = "2021"
@@ -20,14 +20,6 @@
    "fs:default",
    "fs:allow-read-text-file",
    "fs:allow-write-text-file",
-    {
-      "identifier": "fs:allow-read-file",
-      "allow": [{ "path": "**" }]
-    },
-    {
-      "identifier": "fs:allow-write-file",
-      "allow": [{ "path": "**" }]
-    },
    "core:window:allow-set-size",
    "core:window:allow-set-always-on-top",
    "core:window:allow-inner-size"
@@ -257,468 +257,3 @@ pub fn update_clipboard_language(
    save_history(&app, &history)?;
    Ok(updated_entry)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // ==================== ClipboardEntry tests ====================
-
-    #[test]
-    fn test_clipboard_entry_new() {
-        let entry = ClipboardEntry::new(
-            "let x = 42;".to_string(),
-            Some("rust".to_string()),
-            Some("main.rs".to_string()),
-        );
-
-        assert_eq!(entry.content, "let x = 42;");
-        assert_eq!(entry.language, Some("rust".to_string()));
-        assert_eq!(entry.source, Some("main.rs".to_string()));
-        assert!(!entry.is_pinned);
-        assert!(!entry.id.is_empty());
-        assert!(!entry.timestamp.is_empty());
-    }
-
-    #[test]
-    fn test_clipboard_entry_new_without_optional_fields() {
-        let entry = ClipboardEntry::new("some content".to_string(), None, None);
-
-        assert_eq!(entry.content, "some content");
-        assert!(entry.language.is_none());
-        assert!(entry.source.is_none());
-        assert!(!entry.is_pinned);
-    }
-
-    #[test]
-    fn test_clipboard_entry_unique_ids() {
-        let entry1 = ClipboardEntry::new("content1".to_string(), None, None);
-        let entry2 = ClipboardEntry::new("content2".to_string(), None, None);
-
-        assert_ne!(entry1.id, entry2.id);
-    }
-
-    #[test]
-    fn test_clipboard_entry_serialization() {
-        let entry = ClipboardEntry::new(
-            "fn main() {}".to_string(),
-            Some("rust".to_string()),
-            Some("lib.rs".to_string()),
-        );
-
-        let json = serde_json::to_string(&entry).unwrap();
-        assert!(json.contains("fn main() {}"));
-        assert!(json.contains("rust"));
-        assert!(json.contains("lib.rs"));
-        assert!(json.contains("is_pinned"));
-
-        let deserialized: ClipboardEntry = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized.content, entry.content);
-        assert_eq!(deserialized.language, entry.language);
-        assert_eq!(deserialized.source, entry.source);
-        assert_eq!(deserialized.id, entry.id);
-    }
-
-    #[test]
-    fn test_clipboard_entry_clone() {
-        let entry = ClipboardEntry::new(
-            "original".to_string(),
-            Some("python".to_string()),
-            None,
-        );
-
-        let cloned = entry.clone();
-        assert_eq!(cloned.content, entry.content);
-        assert_eq!(cloned.id, entry.id);
-        assert_eq!(cloned.language, entry.language);
-    }
-
-    #[test]
-    fn test_clipboard_entry_timestamp_is_rfc3339() {
-        let entry = ClipboardEntry::new("test".to_string(), None, None);
-
-        // RFC3339 timestamp should parse successfully
-        let parsed = chrono::DateTime::parse_from_rfc3339(&entry.timestamp);
-        assert!(parsed.is_ok());
-    }
-
-    // ==================== ClipboardHistory tests ====================
-
-    #[test]
-    fn test_clipboard_history_default() {
-        let history = ClipboardHistory::default();
-        assert!(history.entries.is_empty());
-    }
-
-    #[test]
-    fn test_clipboard_history_serialization() {
-        let mut history = ClipboardHistory::default();
-        history.entries.push(ClipboardEntry::new(
-            "entry1".to_string(),
-            Some("js".to_string()),
-            None,
-        ));
-        history.entries.push(ClipboardEntry::new(
-            "entry2".to_string(),
-            None,
-            Some("file.txt".to_string()),
-        ));
-
-        let json = serde_json::to_string(&history).unwrap();
-        assert!(json.contains("entry1"));
-        assert!(json.contains("entry2"));
-        assert!(json.contains("js"));
-        assert!(json.contains("file.txt"));
-
-        let deserialized: ClipboardHistory = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized.entries.len(), 2);
-    }
-
-    #[test]
-    fn test_clipboard_history_entries_order() {
-        let mut history = ClipboardHistory::default();
-
-        history.entries.push(ClipboardEntry::new("first".to_string(), None, None));
-        history.entries.push(ClipboardEntry::new("second".to_string(), None, None));
-        history.entries.push(ClipboardEntry::new("third".to_string(), None, None));
-
-        assert_eq!(history.entries[0].content, "first");
-        assert_eq!(history.entries[1].content, "second");
-        assert_eq!(history.entries[2].content, "third");
-    }
-
-    // ==================== ClipboardState tests ====================
-
-    #[test]
-    fn test_clipboard_state_default() {
-        let state = ClipboardState::default();
-        assert!(state.last_content.is_none());
-    }
-
-    #[test]
-    fn test_clipboard_state_with_content() {
-        let state = ClipboardState {
-            last_content: Some("cached content".to_string()),
-        };
-        assert_eq!(state.last_content, Some("cached content".to_string()));
-    }
-
-    // ==================== MAX_HISTORY_SIZE constant test ====================
-
-    #[test]
-    fn test_max_history_size_is_reasonable() {
-        assert_eq!(MAX_HISTORY_SIZE, 100);
-        // Compile-time assertions for constant bounds
-        const _: () = assert!(MAX_HISTORY_SIZE > 0);
-        const _: () = assert!(MAX_HISTORY_SIZE <= 1000); // Sanity check
-    }
-
-    // ==================== Pinned entry sorting tests ====================
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_pinned_entries_sorting() {
-        let mut entries = vec![
-            ClipboardEntry {
-                id: "1".to_string(),
-                content: "unpinned older".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-01T00:00:00Z".to_string(),
-                is_pinned: false,
-            },
-            ClipboardEntry {
-                id: "2".to_string(),
-                content: "pinned".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-02T00:00:00Z".to_string(),
-                is_pinned: true,
-            },
-            ClipboardEntry {
-                id: "3".to_string(),
-                content: "unpinned newer".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-03T00:00:00Z".to_string(),
-                is_pinned: false,
-            },
-        ];
-
-        // Apply the same sorting logic as used in the module
-        entries.sort_by(|a, b| {
-            if a.is_pinned && !b.is_pinned {
-                std::cmp::Ordering::Less
-            } else if !a.is_pinned && b.is_pinned {
-                std::cmp::Ordering::Greater
-            } else {
-                b.timestamp.cmp(&a.timestamp)
-            }
-        });
-
-        // Pinned should be first
-        assert!(entries[0].is_pinned);
-        assert_eq!(entries[0].id, "2");
-
-        // Then unpinned sorted by timestamp descending (newest first)
-        assert_eq!(entries[1].id, "3"); // newer unpinned
-        assert_eq!(entries[2].id, "1"); // older unpinned
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_multiple_pinned_entries_sorting() {
-        let mut entries = vec![
-            ClipboardEntry {
-                id: "1".to_string(),
-                content: "pinned older".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-01T00:00:00Z".to_string(),
-                is_pinned: true,
-            },
-            ClipboardEntry {
-                id: "2".to_string(),
-                content: "unpinned".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-02T00:00:00Z".to_string(),
-                is_pinned: false,
-            },
-            ClipboardEntry {
-                id: "3".to_string(),
-                content: "pinned newer".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-03T00:00:00Z".to_string(),
-                is_pinned: true,
-            },
-        ];
-
-        entries.sort_by(|a, b| {
-            if a.is_pinned && !b.is_pinned {
-                std::cmp::Ordering::Less
-            } else if !a.is_pinned && b.is_pinned {
-                std::cmp::Ordering::Greater
-            } else {
-                b.timestamp.cmp(&a.timestamp)
-            }
-        });
-
-        // Both pinned first, sorted by timestamp
-        assert!(entries[0].is_pinned);
-        assert_eq!(entries[0].id, "3"); // pinned newer
-        assert!(entries[1].is_pinned);
-        assert_eq!(entries[1].id, "1"); // pinned older
-        // Then unpinned
-        assert!(!entries[2].is_pinned);
-        assert_eq!(entries[2].id, "2");
-    }
-
-    // ==================== Entry filtering tests ====================
-
-    #[test]
-    fn test_filter_entries_by_language() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "rust code".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "2024-01-01T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "js code".to_string(),
-                    language: Some("javascript".to_string()),
-                    source: None,
-                    timestamp: "2024-01-02T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "more rust".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "2024-01-03T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let filtered: Vec<_> = history
-            .entries
-            .iter()
-            .filter(|e| e.language.as_ref() == Some(&"rust".to_string()))
-            .collect();
-
-        assert_eq!(filtered.len(), 2);
-        assert!(filtered.iter().all(|e| e.language == Some("rust".to_string())));
-    }
-
-    #[test]
-    fn test_search_entries_by_content() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "fn hello_world()".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "2024-01-01T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "function hello()".to_string(),
-                    language: Some("javascript".to_string()),
-                    source: None,
-                    timestamp: "2024-01-02T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "def goodbye()".to_string(),
-                    language: Some("python".to_string()),
-                    source: None,
-                    timestamp: "2024-01-03T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let query = "hello";
-        let query_lower = query.to_lowercase();
-        let filtered: Vec<_> = history
-            .entries
-            .iter()
-            .filter(|e| e.content.to_lowercase().contains(&query_lower))
-            .collect();
-
-        assert_eq!(filtered.len(), 2);
-        assert!(filtered[0].content.contains("hello"));
-        assert!(filtered[1].content.contains("hello"));
-    }
-
-    #[test]
-    fn test_search_entries_case_insensitive() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "HELLO WORLD".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "2024-01-01T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let query = "hello";
-        let query_lower = query.to_lowercase();
-        let filtered: Vec<_> = history
-            .entries
-            .iter()
-            .filter(|e| e.content.to_lowercase().contains(&query_lower))
-            .collect();
-
-        assert_eq!(filtered.len(), 1);
-    }
-
-    // ==================== Unique languages extraction test ====================
-
-    #[test]
-    fn test_extract_unique_languages() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "".to_string(),
-                    language: Some("javascript".to_string()),
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "".to_string(),
-                    language: Some("rust".to_string()), // Duplicate
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "4".to_string(),
-                    content: "".to_string(),
-                    language: None, // No language
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let mut languages: Vec<String> = history
-            .entries
-            .iter()
-            .filter_map(|e| e.language.clone())
-            .collect();
-        languages.sort();
-        languages.dedup();
-
-        assert_eq!(languages.len(), 2);
-        assert!(languages.contains(&"rust".to_string()));
-        assert!(languages.contains(&"javascript".to_string()));
-    }
-
-    // ==================== Retain pinned entries test ====================
-
-    #[test]
-    fn test_retain_pinned_on_clear() {
-        let mut history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "pinned".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: true,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "unpinned".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "another pinned".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: true,
-                },
-            ],
-        };
-
-        // Simulate clear (keep only pinned)
-        history.entries.retain(|e| e.is_pinned);
-
-        assert_eq!(history.entries.len(), 2);
-        assert!(history.entries.iter().all(|e| e.is_pinned));
-    }
-}
@@ -102,19 +102,6 @@ pub async fn get_usage_stats(
    manager.get_usage_stats(&conversation_id)
 }

-/// Load persisted lifetime stats from store (no bridge required)
-#[tauri::command]
-pub async fn get_persisted_stats(app: AppHandle) -> Result<UsageStats, String> {
-    let mut stats = UsageStats::new();
-
-    // Load persisted stats if available
-    if let Some(persisted) = crate::stats::load_stats(&app).await {
-        stats.apply_persisted(persisted);
-    }
-
-    Ok(stats)
-}
-
 #[tauri::command]
 pub async fn validate_directory(
    path: String,
@@ -393,263 +380,3 @@ pub async fn get_file_size(file_path: String) -> Result<u64, String> {
        .map_err(|e| format!("Failed to get file metadata: {}", e))?;
    Ok(metadata.len())
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::{self, File};
-    use std::io::Write;
-    use tempfile::TempDir;
-
-    // Helper to run async tests
-    fn run_async<F: std::future::Future>(f: F) -> F::Output {
-        tokio::runtime::Runtime::new().unwrap().block_on(f)
-    }
-
-    // ==================== validate_directory tests ====================
-
-    #[test]
-    fn test_validate_directory_absolute_path_exists() {
-        let temp_dir = TempDir::new().unwrap();
-        let path = temp_dir.path().to_string_lossy().to_string();
-
-        let result = run_async(validate_directory(path.clone(), None));
-        assert!(result.is_ok());
-        // Canonicalized path should be returned
-        assert!(result.unwrap().contains(&temp_dir.path().file_name().unwrap().to_string_lossy().to_string()));
-    }
-
-    #[test]
-    fn test_validate_directory_path_not_exists() {
-        let result = run_async(validate_directory(
-            "/nonexistent/path/that/does/not/exist".to_string(),
-            None,
-        ));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("does not exist"));
-    }
-
-    #[test]
-    fn test_validate_directory_path_is_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("test_file.txt");
-        File::create(&file_path).unwrap();
-
-        let result = run_async(validate_directory(
-            file_path.to_string_lossy().to_string(),
-            None,
-        ));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("not a directory"));
-    }
-
-    #[test]
-    fn test_validate_directory_home_expansion() {
-        // This test assumes HOME is set (which it should be on most systems)
-        if std::env::var_os("HOME").is_some() {
-            let result = run_async(validate_directory("~".to_string(), None));
-            assert!(result.is_ok());
-            // Should not contain ~ after expansion
-            assert!(!result.unwrap().contains("~"));
-        }
-    }
-
-    #[test]
-    fn test_validate_directory_home_subpath_expansion() {
-        // This test assumes HOME is set and has some subdirectory
-        if let Some(home) = std::env::var_os("HOME") {
-            let home_path = std::path::Path::new(&home);
-            // Find any subdirectory in home
-            if let Ok(entries) = fs::read_dir(home_path) {
-                for entry in entries.flatten() {
-                    if entry.path().is_dir() {
-                        let subdir_name = entry.file_name().to_string_lossy().to_string();
-                        let tilde_path = format!("~/{}", subdir_name);
-                        let result = run_async(validate_directory(tilde_path, None));
-                        assert!(result.is_ok());
-                        assert!(!result.unwrap().contains("~"));
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_validate_directory_relative_path_with_current_dir() {
-        let temp_dir = TempDir::new().unwrap();
-        let subdir = temp_dir.path().join("subdir");
-        fs::create_dir(&subdir).unwrap();
-
-        let result = run_async(validate_directory(
-            "subdir".to_string(),
-            Some(temp_dir.path().to_string_lossy().to_string()),
-        ));
-        assert!(result.is_ok());
-        assert!(result.unwrap().contains("subdir"));
-    }
-
-    #[test]
-    fn test_validate_directory_dot_path() {
-        let temp_dir = TempDir::new().unwrap();
-
-        let result = run_async(validate_directory(
-            ".".to_string(),
-            Some(temp_dir.path().to_string_lossy().to_string()),
-        ));
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_validate_directory_dotdot_path() {
-        let temp_dir = TempDir::new().unwrap();
-        let subdir = temp_dir.path().join("subdir");
-        fs::create_dir(&subdir).unwrap();
-
-        let result = run_async(validate_directory(
-            "..".to_string(),
-            Some(subdir.to_string_lossy().to_string()),
-        ));
-        assert!(result.is_ok());
-        // Should resolve to parent
-        let resolved = result.unwrap();
-        assert!(resolved.contains(&temp_dir.path().file_name().unwrap().to_string_lossy().to_string()));
-    }
-
-    #[test]
-    fn test_validate_directory_relative_without_current_dir() {
-        // Relative path without current_dir - should fail since relative path likely won't exist
-        let result = run_async(validate_directory(
-            "some_random_nonexistent_relative_path".to_string(),
-            None,
-        ));
-        assert!(result.is_err());
-    }
-
-    // ==================== get_file_size tests ====================
-
-    #[test]
-    fn test_get_file_size_empty_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("empty.txt");
-        File::create(&file_path).unwrap();
-
-        let result = run_async(get_file_size(file_path.to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0);
-    }
-
-    #[test]
-    fn test_get_file_size_with_content() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("content.txt");
-        let mut file = File::create(&file_path).unwrap();
-        file.write_all(b"Hello, Hikari!").unwrap();
-
-        let result = run_async(get_file_size(file_path.to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 14); // "Hello, Hikari!" is 14 bytes
-    }
-
-    #[test]
-    fn test_get_file_size_larger_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("large.txt");
-        let mut file = File::create(&file_path).unwrap();
-        // Write 1000 bytes
-        let data = vec![b'x'; 1000];
-        file.write_all(&data).unwrap();
-
-        let result = run_async(get_file_size(file_path.to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 1000);
-    }
-
-    #[test]
-    fn test_get_file_size_nonexistent_file() {
-        let result = run_async(get_file_size(
-            "/nonexistent/path/file.txt".to_string(),
-        ));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("Failed to get file metadata"));
-    }
-
-    #[test]
-    fn test_get_file_size_directory() {
-        let temp_dir = TempDir::new().unwrap();
-
-        // Getting "size" of a directory should work but return directory metadata
-        // This is actually valid - directories have metadata too
-        let result = run_async(get_file_size(temp_dir.path().to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        // Directory size is platform-dependent, just check it returns something
-    }
-
-    // ==================== list_skills tests ====================
-
-    #[test]
-    fn test_list_skills_no_skills_dir() {
-        // This test is tricky because it depends on HOME being set
-        // and potentially affecting real user data, so we'll just
-        // verify the function doesn't panic
-        let result = run_async(list_skills());
-        // Should either return Ok with a list or Ok with empty vec
-        assert!(result.is_ok());
-    }
-
-    // ==================== select_wsl_directory tests ====================
-
-    #[test]
-    fn test_select_wsl_directory_returns_home() {
-        let result = run_async(select_wsl_directory());
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "/home");
-    }
-
-    // ==================== UpdateInfo struct tests ====================
-
-    #[test]
-    fn test_update_info_serialization() {
-        let info = UpdateInfo {
-            current_version: "1.0.0".to_string(),
-            latest_version: "0.4.0".to_string(),
-            has_update: true,
-            release_url: "https://example.com/release".to_string(),
-            release_notes: Some("New features!".to_string()),
-        };
-
-        let json = serde_json::to_string(&info).unwrap();
-        assert!(json.contains("1.0.0"));
-        assert!(json.contains("0.4.0"));
-        assert!(json.contains("true"));
-        assert!(json.contains("New features!"));
-    }
-
-    #[test]
-    fn test_update_info_without_notes() {
-        let info = UpdateInfo {
-            current_version: "1.0.0".to_string(),
-            latest_version: "1.0.0".to_string(),
-            has_update: false,
-            release_url: "https://example.com/release".to_string(),
-            release_notes: None,
-        };
-
-        let json = serde_json::to_string(&info).unwrap();
-        assert!(json.contains("null") || json.contains("release_notes"));
-    }
-
-    // ==================== SavedFileInfo struct tests ====================
-
-    #[test]
-    fn test_saved_file_info_serialization() {
-        let info = SavedFileInfo {
-            path: "/tmp/test.txt".to_string(),
-            filename: "test.txt".to_string(),
-        };
-
-        let json = serde_json::to_string(&info).unwrap();
-        assert!(json.contains("/tmp/test.txt"));
-        assert!(json.contains("test.txt"));
-    }
-}
@@ -82,20 +82,6 @@ pub struct HikariConfig {

    #[serde(default)]
    pub compact_mode: bool,
-
-    // Profile fields
-    #[serde(default)]
-    pub profile_name: Option<String>,
-
-    #[serde(default)]
-    pub profile_avatar_path: Option<String>,
-
-    #[serde(default)]
-    pub profile_bio: Option<String>,
-
-    // Custom theme colors
-    #[serde(default)]
-    pub custom_theme_colors: CustomThemeColors,
 }

 impl Default for HikariConfig {
@@ -119,10 +105,6 @@ impl Default for HikariConfig {
            streamer_mode: false,
            streamer_hide_paths: false,
            compact_mode: false,
-            profile_name: None,
-            profile_avatar_path: None,
-            profile_bio: None,
-            custom_theme_colors: CustomThemeColors::default(),
        }
    }
 }
@@ -155,27 +137,6 @@ pub enum Theme {
    Light,
    #[serde(rename = "high-contrast")]
    HighContrast,
-    Custom,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
-pub struct CustomThemeColors {
-    #[serde(default)]
-    pub bg_primary: Option<String>,
-    #[serde(default)]
-    pub bg_secondary: Option<String>,
-    #[serde(default)]
-    pub bg_terminal: Option<String>,
-    #[serde(default)]
-    pub accent_primary: Option<String>,
-    #[serde(default)]
-    pub accent_secondary: Option<String>,
-    #[serde(default)]
-    pub text_primary: Option<String>,
-    #[serde(default)]
-    pub text_secondary: Option<String>,
-    #[serde(default)]
-    pub border_color: Option<String>,
 }

 #[cfg(test)]
@@ -201,10 +162,6 @@ mod tests {
        assert!(!config.streamer_mode);
        assert!(!config.streamer_hide_paths);
        assert!(!config.compact_mode);
-        assert!(config.profile_name.is_none());
-        assert!(config.profile_avatar_path.is_none());
-        assert!(config.profile_bio.is_none());
-        assert_eq!(config.custom_theme_colors, CustomThemeColors::default());
    }

    #[test]
@@ -228,10 +185,6 @@ mod tests {
            streamer_mode: false,
            streamer_hide_paths: false,
            compact_mode: false,
-            profile_name: Some("Test User".to_string()),
-            profile_avatar_path: None,
-            profile_bio: Some("A test bio".to_string()),
-            custom_theme_colors: CustomThemeColors::default(),
        };

        let json = serde_json::to_string(&config).unwrap();
@@ -260,8 +213,5 @@ mod tests {
            serde_json::to_string(&high_contrast).unwrap(),
            "\"high-contrast\""
        );
-
-        let custom = Theme::Custom;
-        assert_eq!(serde_json::to_string(&custom).unwrap(), "\"custom\"");
    }
 }
@@ -286,593 +286,3 @@ pub fn git_discard(working_dir: String, file_path: String) -> Result<String, Str
 pub fn git_create_branch(working_dir: String, branch_name: String) -> Result<String, String> {
    run_git_command(&working_dir, &["checkout", "-b", &branch_name])
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::{self, File};
-    use std::io::Write;
-    use tempfile::TempDir;
-
-    // Helper to create a git repository in a temp directory
-    fn create_test_repo() -> TempDir {
-        let temp_dir = TempDir::new().unwrap();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initialize git repo
-        run_git_command(&working_dir, &["init"]).unwrap();
-
-        // Configure git user for commits
-        run_git_command(&working_dir, &["config", "user.email", "test@example.com"]).unwrap();
-        run_git_command(&working_dir, &["config", "user.name", "Test User"]).unwrap();
-
-        // Disable GPG signing for tests (user may have it enabled globally)
-        run_git_command(&working_dir, &["config", "commit.gpgsign", "false"]).unwrap();
-
-        temp_dir
-    }
-
-    // Helper to create a file in the test repo
-    fn create_file(dir: &TempDir, name: &str, content: &str) {
-        let file_path = dir.path().join(name);
-        let mut file = File::create(file_path).unwrap();
-        file.write_all(content.as_bytes()).unwrap();
-    }
-
-    // ==================== GitStatus struct tests ====================
-
-    #[test]
-    fn test_git_status_serialization() {
-        let status = GitStatus {
-            is_repo: true,
-            branch: Some("main".to_string()),
-            upstream: Some("origin/main".to_string()),
-            ahead: 2,
-            behind: 1,
-            staged: vec![GitFileChange {
-                path: "file.txt".to_string(),
-                status: "modified".to_string(),
-            }],
-            unstaged: vec![],
-            untracked: vec!["new_file.txt".to_string()],
-        };
-
-        let json = serde_json::to_string(&status).unwrap();
-        assert!(json.contains("\"is_repo\":true"));
-        assert!(json.contains("\"branch\":\"main\""));
-        assert!(json.contains("\"ahead\":2"));
-        assert!(json.contains("\"behind\":1"));
-    }
-
-    #[test]
-    fn test_git_status_not_a_repo() {
-        let status = GitStatus {
-            is_repo: false,
-            branch: None,
-            upstream: None,
-            ahead: 0,
-            behind: 0,
-            staged: vec![],
-            unstaged: vec![],
-            untracked: vec![],
-        };
-
-        let json = serde_json::to_string(&status).unwrap();
-        let deserialized: GitStatus = serde_json::from_str(&json).unwrap();
-        assert!(!deserialized.is_repo);
-        assert!(deserialized.branch.is_none());
-    }
-
-    // ==================== GitFileChange struct tests ====================
-
-    #[test]
-    fn test_git_file_change_serialization() {
-        let change = GitFileChange {
-            path: "src/main.rs".to_string(),
-            status: "added".to_string(),
-        };
-
-        let json = serde_json::to_string(&change).unwrap();
-        assert!(json.contains("src/main.rs"));
-        assert!(json.contains("added"));
-
-        let deserialized: GitFileChange = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized.path, "src/main.rs");
-        assert_eq!(deserialized.status, "added");
-    }
-
-    // ==================== GitBranch struct tests ====================
-
-    #[test]
-    fn test_git_branch_serialization() {
-        let branch = GitBranch {
-            name: "feature/new-feature".to_string(),
-            is_current: true,
-            is_remote: false,
-        };
-
-        let json = serde_json::to_string(&branch).unwrap();
-        assert!(json.contains("feature/new-feature"));
-        assert!(json.contains("\"is_current\":true"));
-        assert!(json.contains("\"is_remote\":false"));
-    }
-
-    #[test]
-    fn test_git_branch_remote() {
-        let branch = GitBranch {
-            name: "origin/main".to_string(),
-            is_current: false,
-            is_remote: true,
-        };
-
-        let json = serde_json::to_string(&branch).unwrap();
-        let deserialized: GitBranch = serde_json::from_str(&json).unwrap();
-        assert!(deserialized.is_remote);
-        assert!(!deserialized.is_current);
-    }
-
-    // ==================== GitLogEntry struct tests ====================
-
-    #[test]
-    fn test_git_log_entry_serialization() {
-        let entry = GitLogEntry {
-            hash: "abc123def456".to_string(),
-            short_hash: "abc123d".to_string(),
-            author: "Hikari".to_string(),
-            date: "2 hours ago".to_string(),
-            message: "feat: add new feature".to_string(),
-        };
-
-        let json = serde_json::to_string(&entry).unwrap();
-        assert!(json.contains("abc123def456"));
-        assert!(json.contains("Hikari"));
-        assert!(json.contains("feat: add new feature"));
-    }
-
-    // ==================== git_status integration tests ====================
-
-    #[test]
-    fn test_git_status_not_a_git_repo() {
-        let temp_dir = TempDir::new().unwrap();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(!status.is_repo);
-        assert!(status.branch.is_none());
-        assert!(status.staged.is_empty());
-    }
-
-    #[test]
-    fn test_git_status_empty_repo() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(status.staged.is_empty());
-        assert!(status.unstaged.is_empty());
-        assert!(status.untracked.is_empty());
-    }
-
-    #[test]
-    fn test_git_status_with_untracked_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create an untracked file
-        create_file(&temp_dir, "untracked.txt", "hello");
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(status.untracked.contains(&"untracked.txt".to_string()));
-    }
-
-    #[test]
-    fn test_git_status_with_staged_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and stage a file
-        create_file(&temp_dir, "staged.txt", "hello");
-        run_git_command(&working_dir, &["add", "staged.txt"]).unwrap();
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(!status.staged.is_empty());
-        assert_eq!(status.staged[0].path, "staged.txt");
-        assert_eq!(status.staged[0].status, "added");
-    }
-
-    #[test]
-    fn test_git_status_with_modified_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create, stage, and commit a file
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial commit"]).unwrap();
-
-        // Modify the file
-        create_file(&temp_dir, "file.txt", "modified content");
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(!status.unstaged.is_empty());
-        assert_eq!(status.unstaged[0].path, "file.txt");
-        assert_eq!(status.unstaged[0].status, "modified");
-    }
-
-    // ==================== git_diff integration tests ====================
-
-    #[test]
-    fn test_git_diff_no_changes() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_diff(working_dir, None, false);
-        assert!(result.is_ok());
-        assert!(result.unwrap().is_empty());
-    }
-
-    #[test]
-    fn test_git_diff_with_changes() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit a file
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify the file
-        create_file(&temp_dir, "file.txt", "modified content");
-
-        let result = git_diff(working_dir, None, false);
-        assert!(result.is_ok());
-        let diff = result.unwrap();
-        assert!(diff.contains("diff"));
-        assert!(diff.contains("file.txt"));
-    }
-
-    #[test]
-    fn test_git_diff_staged() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit a file
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify and stage the file
-        create_file(&temp_dir, "file.txt", "modified content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-
-        let result = git_diff(working_dir, None, true);
-        assert!(result.is_ok());
-        let diff = result.unwrap();
-        assert!(diff.contains("diff"));
-    }
-
-    #[test]
-    fn test_git_diff_specific_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit files
-        create_file(&temp_dir, "file1.txt", "content1");
-        create_file(&temp_dir, "file2.txt", "content2");
-        run_git_command(&working_dir, &["add", "-A"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify both files
-        create_file(&temp_dir, "file1.txt", "modified1");
-        create_file(&temp_dir, "file2.txt", "modified2");
-
-        // Get diff for only file1.txt
-        let result = git_diff(working_dir, Some("file1.txt".to_string()), false);
-        assert!(result.is_ok());
-        let diff = result.unwrap();
-        assert!(diff.contains("file1.txt"));
-        assert!(!diff.contains("file2.txt"));
-    }
-
-    // ==================== git_branches integration tests ====================
-
-    #[test]
-    fn test_git_branches_single_branch() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Need at least one commit for branches to show
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        let result = git_branches(working_dir);
-        assert!(result.is_ok());
-
-        let branches = result.unwrap();
-        assert!(!branches.is_empty());
-        // Should have at least one branch (main or master)
-    }
-
-    #[test]
-    fn test_git_branches_multiple_branches() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initial commit
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Create additional branch
-        run_git_command(&working_dir, &["branch", "feature-branch"]).unwrap();
-
-        let result = git_branches(working_dir);
-        assert!(result.is_ok());
-
-        let branches = result.unwrap();
-        assert!(branches.len() >= 2);
-        assert!(branches.iter().any(|b| b.name == "feature-branch"));
-    }
-
-    // ==================== git_stage and git_unstage tests ====================
-
-    #[test]
-    fn test_git_stage_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        create_file(&temp_dir, "file.txt", "content");
-
-        let result = git_stage(working_dir.clone(), "file.txt".to_string());
-        assert!(result.is_ok());
-
-        // Verify file is staged
-        let status = git_status(working_dir).unwrap();
-        assert!(status.staged.iter().any(|f| f.path == "file.txt"));
-    }
-
-    #[test]
-    fn test_git_unstage_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // First, commit a file so we have a HEAD to restore from
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify and stage the file
-        create_file(&temp_dir, "file.txt", "modified content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-
-        let result = git_unstage(working_dir.clone(), "file.txt".to_string());
-        assert!(result.is_ok());
-
-        // Verify file is unstaged (should now be in unstaged/modified, not staged)
-        let status = git_status(working_dir).unwrap();
-        assert!(!status.staged.iter().any(|f| f.path == "file.txt"));
-        assert!(status.unstaged.iter().any(|f| f.path == "file.txt"));
-    }
-
-    #[test]
-    fn test_git_stage_all() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        create_file(&temp_dir, "file1.txt", "content1");
-        create_file(&temp_dir, "file2.txt", "content2");
-
-        let result = git_stage_all(working_dir.clone());
-        assert!(result.is_ok());
-
-        // Verify all files are staged
-        let status = git_status(working_dir).unwrap();
-        assert_eq!(status.staged.len(), 2);
-    }
-
-    // ==================== git_commit tests ====================
-
-    #[test]
-    fn test_git_commit() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-
-        let result = git_commit(working_dir.clone(), "test commit message".to_string());
-        assert!(result.is_ok());
-
-        // Verify commit was made
-        let log = git_log(working_dir, Some(1)).unwrap();
-        assert!(!log.is_empty());
-        assert!(log[0].message.contains("test commit message"));
-    }
-
-    #[test]
-    fn test_git_commit_nothing_to_commit() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Need initial commit first
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Try to commit with nothing staged
-        let result = git_commit(working_dir, "empty commit".to_string());
-        assert!(result.is_err()); // Should fail because nothing to commit
-    }
-
-    // ==================== git_log tests ====================
-
-    #[test]
-    fn test_git_log_empty_repo() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_log(working_dir, Some(10));
-        // May fail on empty repo or return empty
-        if let Ok(commits) = result {
-            assert!(commits.is_empty());
-        }
-    }
-
-    #[test]
-    fn test_git_log_with_commits() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Make multiple commits
-        for i in 1..=3 {
-            create_file(&temp_dir, &format!("file{}.txt", i), "content");
-            run_git_command(&working_dir, &["add", "-A"]).unwrap();
-            run_git_command(&working_dir, &["commit", "-m", &format!("commit {}", i)]).unwrap();
-        }
-
-        let result = git_log(working_dir, Some(10));
-        assert!(result.is_ok());
-
-        let log = result.unwrap();
-        assert_eq!(log.len(), 3);
-        assert!(log[0].message.contains("commit 3")); // Most recent first
-        assert!(log[2].message.contains("commit 1"));
-    }
-
-    #[test]
-    fn test_git_log_limit() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Make 5 commits
-        for i in 1..=5 {
-            create_file(&temp_dir, &format!("file{}.txt", i), "content");
-            run_git_command(&working_dir, &["add", "-A"]).unwrap();
-            run_git_command(&working_dir, &["commit", "-m", &format!("commit {}", i)]).unwrap();
-        }
-
-        // Only get last 2
-        let result = git_log(working_dir, Some(2));
-        assert!(result.is_ok());
-
-        let log = result.unwrap();
-        assert_eq!(log.len(), 2);
-    }
-
-    // ==================== git_discard tests ====================
-
-    #[test]
-    fn test_git_discard_changes() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit a file
-        create_file(&temp_dir, "file.txt", "original content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify the file
-        create_file(&temp_dir, "file.txt", "modified content");
-
-        // Discard changes
-        let result = git_discard(working_dir.clone(), "file.txt".to_string());
-        assert!(result.is_ok());
-
-        // Verify file contents are restored
-        let content = fs::read_to_string(temp_dir.path().join("file.txt")).unwrap();
-        assert_eq!(content, "original content");
-    }
-
-    // ==================== git_create_branch tests ====================
-
-    #[test]
-    fn test_git_create_branch() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initial commit required
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        let result = git_create_branch(working_dir.clone(), "new-branch".to_string());
-        assert!(result.is_ok());
-
-        // Verify branch exists and is current
-        let branches = git_branches(working_dir).unwrap();
-        assert!(branches.iter().any(|b| b.name == "new-branch" && b.is_current));
-    }
-
-    // ==================== git_checkout tests ====================
-
-    #[test]
-    fn test_git_checkout() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initial commit required
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Create a branch
-        run_git_command(&working_dir, &["branch", "other-branch"]).unwrap();
-
-        // Checkout the branch
-        let result = git_checkout(working_dir.clone(), "other-branch".to_string());
-        assert!(result.is_ok());
-
-        // Verify current branch
-        let branches = git_branches(working_dir).unwrap();
-        let current = branches.iter().find(|b| b.is_current);
-        assert!(current.is_some());
-        assert_eq!(current.unwrap().name, "other-branch");
-    }
-
-    // ==================== run_git_command tests ====================
-
-    #[test]
-    fn test_run_git_command_success() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = run_git_command(&working_dir, &["status"]);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_run_git_command_failure() {
-        let temp_dir = TempDir::new().unwrap();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // This should fail because it's not a git repo
-        let result = run_git_command(&working_dir, &["log"]);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_run_git_command_invalid_dir() {
-        let result = run_git_command("/nonexistent/path", &["status"]);
-        assert!(result.is_err());
-    }
-}
@@ -95,7 +95,6 @@ pub fn run() {
            get_config,
            save_config,
            get_usage_stats,
-            get_persisted_stats,
            load_saved_achievements,
            answer_question,
            send_windows_notification,
@@ -171,18 +171,6 @@ pub async fn reset_default_quick_actions(app: AppHandle) -> Result<(), String> {
 mod tests {
    use super::*;

-    fn create_test_action(id: &str, name: &str, is_default: bool) -> QuickAction {
-        QuickAction {
-            id: id.to_string(),
-            name: name.to_string(),
-            prompt: "Test prompt".to_string(),
-            icon: "star".to_string(),
-            is_default,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-        }
-    }
-
    #[test]
    fn test_default_quick_actions_exist() {
        let defaults = get_default_quick_actions();
@@ -200,174 +188,4 @@ mod tests {
            assert!(!action.icon.is_empty());
        }
    }
-
-    #[test]
-    fn test_default_quick_actions_count() {
-        let defaults = get_default_quick_actions();
-        // Should have 6 default actions
-        assert_eq!(defaults.len(), 6);
-    }
-
-    #[test]
-    fn test_default_quick_actions_have_unique_ids() {
-        let defaults = get_default_quick_actions();
-        let mut ids: Vec<&String> = defaults.iter().map(|a| &a.id).collect();
-        ids.sort();
-        ids.dedup();
-        assert_eq!(ids.len(), defaults.len());
-    }
-
-    #[test]
-    fn test_default_quick_actions_ids_start_with_default() {
-        let defaults = get_default_quick_actions();
-        assert!(defaults.iter().all(|a| a.id.starts_with("default-")));
-    }
-
-    #[test]
-    fn test_quick_action_serialization() {
-        let action = create_test_action("test-1", "Test Action", false);
-        let json = serde_json::to_string(&action).expect("Failed to serialize");
-        let parsed: QuickAction = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, action.id);
-        assert_eq!(parsed.name, action.name);
-        assert_eq!(parsed.prompt, action.prompt);
-        assert_eq!(parsed.icon, action.icon);
-        assert_eq!(parsed.is_default, action.is_default);
-    }
-
-    #[test]
-    fn test_quick_action_clone() {
-        let original = create_test_action("clone-test", "Clone Test", true);
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.name, cloned.name);
-        assert_eq!(original.is_default, cloned.is_default);
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_quick_action_sorting_defaults_first() {
-        let mut actions = vec![
-            create_test_action("custom-z", "Zebra", false),
-            create_test_action("default-a", "Apple", true),
-            create_test_action("custom-a", "Alpha", false),
-            create_test_action("default-z", "Zulu", true),
-        ];
-
-        // Sort by: defaults first, then alphabetically by name
-        actions.sort_by(|a, b| {
-            let default_cmp = b.is_default.cmp(&a.is_default);
-            if default_cmp == std::cmp::Ordering::Equal {
-                a.name.cmp(&b.name)
-            } else {
-                default_cmp
-            }
-        });
-
-        // Defaults should come first
-        assert!(actions[0].is_default);
-        assert!(actions[1].is_default);
-        assert!(!actions[2].is_default);
-        assert!(!actions[3].is_default);
-
-        // Within defaults, alphabetically sorted
-        assert_eq!(actions[0].name, "Apple");
-        assert_eq!(actions[1].name, "Zulu");
-
-        // Within non-defaults, alphabetically sorted
-        assert_eq!(actions[2].name, "Alpha");
-        assert_eq!(actions[3].name, "Zebra");
-    }
-
-    #[test]
-    fn test_known_default_actions() {
-        let defaults = get_default_quick_actions();
-        let ids: Vec<&str> = defaults.iter().map(|a| a.id.as_str()).collect();
-
-        assert!(ids.contains(&"default-review-pr"));
-        assert!(ids.contains(&"default-run-tests"));
-        assert!(ids.contains(&"default-explain-file"));
-        assert!(ids.contains(&"default-fix-error"));
-        assert!(ids.contains(&"default-write-tests"));
-        assert!(ids.contains(&"default-refactor"));
-    }
-
-    #[test]
-    fn test_default_action_icons() {
-        let defaults = get_default_quick_actions();
-        let icons: Vec<&str> = defaults.iter().map(|a| a.icon.as_str()).collect();
-
-        assert!(icons.contains(&"git-pull-request"));
-        assert!(icons.contains(&"play"));
-        assert!(icons.contains(&"file-text"));
-        assert!(icons.contains(&"alert-circle"));
-        assert!(icons.contains(&"check-square"));
-        assert!(icons.contains(&"refresh-cw"));
-    }
-
-    #[test]
-    fn test_quick_action_prompts_not_empty() {
-        let defaults = get_default_quick_actions();
-        for action in defaults {
-            assert!(
-                action.prompt.len() > 10,
-                "Prompt should be meaningful: {}",
-                action.name
-            );
-        }
-    }
-
-    #[test]
-    fn test_quick_action_timestamps() {
-        let action = create_test_action("time-test", "Time Test", false);
-        assert!(action.created_at <= action.updated_at);
-    }
-
-    #[test]
-    fn test_default_actions_have_same_timestamps() {
-        let defaults = get_default_quick_actions();
-        // All defaults are created at the same instant
-        let first_created = defaults[0].created_at;
-        let first_updated = defaults[0].updated_at;
-
-        for action in &defaults {
-            assert_eq!(action.created_at, first_created);
-            assert_eq!(action.updated_at, first_updated);
-        }
-    }
-
-    #[test]
-    fn test_action_retain_non_default() {
-        let mut actions = vec![
-            create_test_action("default-1", "Default 1", true),
-            create_test_action("custom-1", "Custom 1", false),
-            create_test_action("default-2", "Default 2", true),
-            create_test_action("custom-2", "Custom 2", false),
-        ];
-
-        // Mimics reset_default_quick_actions behavior (retain non-defaults)
-        actions.retain(|a| !a.is_default);
-
-        assert_eq!(actions.len(), 2);
-        assert!(actions.iter().all(|a| !a.is_default));
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_action_find_by_id() {
-        let actions = vec![
-            create_test_action("action-1", "First", false),
-            create_test_action("action-2", "Second", false),
-            create_test_action("action-3", "Third", false),
-        ];
-
-        let found = actions.iter().find(|a| a.id == "action-2");
-        assert!(found.is_some());
-        assert_eq!(found.unwrap().name, "Second");
-
-        let not_found = actions.iter().find(|a| a.id == "action-999");
-        assert!(not_found.is_none());
-    }
 }
@@ -145,30 +145,6 @@ pub async fn clear_all_sessions(app: AppHandle) -> Result<(), String> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use chrono::TimeZone;
-
-    fn create_test_session(id: &str, name: &str) -> SavedSession {
-        SavedSession {
-            id: id.to_string(),
-            name: name.to_string(),
-            created_at: Utc::now(),
-            last_activity_at: Utc::now(),
-            working_directory: "/home/test".to_string(),
-            message_count: 5,
-            preview: "Hello world".to_string(),
-            messages: vec![],
-        }
-    }
-
-    fn create_test_message(id: &str, content: &str, msg_type: &str) -> SavedMessage {
-        SavedMessage {
-            id: id.to_string(),
-            message_type: msg_type.to_string(),
-            content: content.to_string(),
-            timestamp: Utc::now(),
-            tool_name: None,
-        }
-    }

    #[test]
    fn test_session_list_item_from_saved_session() {
@@ -188,187 +164,4 @@ mod tests {
        assert_eq!(item.name, "Test Session");
        assert_eq!(item.message_count, 5);
    }
-
-    #[test]
-    fn test_session_list_item_preserves_all_fields() {
-        let created = Utc.with_ymd_and_hms(2024, 1, 15, 10, 30, 0).unwrap();
-        let last_activity = Utc.with_ymd_and_hms(2024, 1, 15, 14, 45, 0).unwrap();
-
-        let session = SavedSession {
-            id: "sess-123".to_string(),
-            name: "My Chat".to_string(),
-            created_at: created,
-            last_activity_at: last_activity,
-            working_directory: "/home/naomi/project".to_string(),
-            message_count: 42,
-            preview: "What is the meaning of life?".to_string(),
-            messages: vec![],
-        };
-
-        let item = SessionListItem::from(&session);
-
-        assert_eq!(item.id, "sess-123");
-        assert_eq!(item.name, "My Chat");
-        assert_eq!(item.created_at, created);
-        assert_eq!(item.last_activity_at, last_activity);
-        assert_eq!(item.working_directory, "/home/naomi/project");
-        assert_eq!(item.message_count, 42);
-        assert_eq!(item.preview, "What is the meaning of life?");
-    }
-
-    #[test]
-    fn test_saved_session_serialization() {
-        let session = create_test_session("test-1", "Test Session");
-        let json = serde_json::to_string(&session).expect("Failed to serialize");
-        let parsed: SavedSession = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, session.id);
-        assert_eq!(parsed.name, session.name);
-        assert_eq!(parsed.working_directory, session.working_directory);
-    }
-
-    #[test]
-    fn test_saved_message_serialization() {
-        let message = create_test_message("msg-1", "Hello!", "user");
-        let json = serde_json::to_string(&message).expect("Failed to serialize");
-        let parsed: SavedMessage = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, message.id);
-        assert_eq!(parsed.content, message.content);
-        assert_eq!(parsed.message_type, "user");
-    }
-
-    #[test]
-    fn test_saved_message_with_tool_name() {
-        let message = SavedMessage {
-            id: "msg-tool-1".to_string(),
-            message_type: "tool".to_string(),
-            content: "File read successfully".to_string(),
-            timestamp: Utc::now(),
-            tool_name: Some("Read".to_string()),
-        };
-
-        let json = serde_json::to_string(&message).expect("Failed to serialize");
-        let parsed: SavedMessage = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.tool_name, Some("Read".to_string()));
-    }
-
-    #[test]
-    fn test_session_with_messages_serialization() {
-        let mut session = create_test_session("sess-full", "Full Session");
-        session.messages = vec![
-            create_test_message("msg-1", "Hello!", "user"),
-            create_test_message("msg-2", "Hi there!", "assistant"),
-            create_test_message("msg-3", "Read file", "tool"),
-        ];
-        session.message_count = 3;
-
-        let json = serde_json::to_string(&session).expect("Failed to serialize");
-        let parsed: SavedSession = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.messages.len(), 3);
-        assert_eq!(parsed.messages[0].content, "Hello!");
-        assert_eq!(parsed.messages[1].message_type, "assistant");
-        assert_eq!(parsed.messages[2].message_type, "tool");
-    }
-
-    #[test]
-    fn test_session_list_item_serialization() {
-        let item = SessionListItem {
-            id: "list-item-1".to_string(),
-            name: "Quick Chat".to_string(),
-            created_at: Utc::now(),
-            last_activity_at: Utc::now(),
-            working_directory: "/tmp".to_string(),
-            message_count: 10,
-            preview: "Short preview...".to_string(),
-        };
-
-        let json = serde_json::to_string(&item).expect("Failed to serialize");
-        let parsed: SessionListItem = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, item.id);
-        assert_eq!(parsed.name, item.name);
-        assert_eq!(parsed.preview, item.preview);
-    }
-
-    #[test]
-    fn test_message_type_field_rename() {
-        // The message_type field is renamed to "type" in JSON
-        let message = create_test_message("msg-1", "Test", "assistant");
-        let json = serde_json::to_string(&message).expect("Failed to serialize");
-
-        assert!(json.contains("\"type\":"));
-        assert!(!json.contains("\"message_type\":"));
-    }
-
-    #[test]
-    fn test_session_default_empty_messages() {
-        let session = SavedSession {
-            id: "empty".to_string(),
-            name: "Empty".to_string(),
-            created_at: Utc::now(),
-            last_activity_at: Utc::now(),
-            working_directory: "/".to_string(),
-            message_count: 0,
-            preview: "".to_string(),
-            messages: vec![],
-        };
-
-        assert!(session.messages.is_empty());
-        assert_eq!(session.message_count, 0);
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_session_sorting_by_activity() {
-        let old_time = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
-        let new_time = Utc.with_ymd_and_hms(2024, 6, 15, 12, 0, 0).unwrap();
-
-        let mut sessions = vec![
-            SessionListItem {
-                id: "old".to_string(),
-                name: "Old Session".to_string(),
-                created_at: old_time,
-                last_activity_at: old_time,
-                working_directory: "/old".to_string(),
-                message_count: 1,
-                preview: "Old".to_string(),
-            },
-            SessionListItem {
-                id: "new".to_string(),
-                name: "New Session".to_string(),
-                created_at: new_time,
-                last_activity_at: new_time,
-                working_directory: "/new".to_string(),
-                message_count: 1,
-                preview: "New".to_string(),
-            },
-        ];
-
-        // Sort by last activity, most recent first (mimics list_sessions behavior)
-        sessions.sort_by(|a, b| b.last_activity_at.cmp(&a.last_activity_at));
-
-        assert_eq!(sessions[0].id, "new");
-        assert_eq!(sessions[1].id, "old");
-    }
-
-    #[test]
-    fn test_session_clone() {
-        let original = create_test_session("clone-test", "Clone Test");
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.name, cloned.name);
-    }
-
-    #[test]
-    fn test_message_clone() {
-        let original = create_test_message("msg-clone", "Content", "user");
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.content, cloned.content);
-    }
 }
@@ -205,19 +205,6 @@ pub async fn reset_default_snippets(app: AppHandle) -> Result<(), String> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use std::collections::HashSet;
-
-    fn create_test_snippet(id: &str, name: &str, category: &str, is_default: bool) -> Snippet {
-        Snippet {
-            id: id.to_string(),
-            name: name.to_string(),
-            content: "Test content".to_string(),
-            category: category.to_string(),
-            is_default,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-        }
-    }

    #[test]
    fn test_default_snippets_exist() {
@@ -236,204 +223,4 @@ mod tests {
            assert!(!snippet.category.is_empty());
        }
    }
-
-    #[test]
-    fn test_default_snippets_count() {
-        let defaults = get_default_snippets();
-        // Should have 8 default snippets
-        assert_eq!(defaults.len(), 8);
-    }
-
-    #[test]
-    fn test_default_snippets_have_unique_ids() {
-        let defaults = get_default_snippets();
-        let ids: HashSet<&String> = defaults.iter().map(|s| &s.id).collect();
-        assert_eq!(ids.len(), defaults.len());
-    }
-
-    #[test]
-    fn test_default_snippets_ids_start_with_default() {
-        let defaults = get_default_snippets();
-        assert!(defaults.iter().all(|s| s.id.starts_with("default-")));
-    }
-
-    #[test]
-    fn test_snippet_serialization() {
-        let snippet = create_test_snippet("test-1", "Test Snippet", "Testing", false);
-        let json = serde_json::to_string(&snippet).expect("Failed to serialize");
-        let parsed: Snippet = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, snippet.id);
-        assert_eq!(parsed.name, snippet.name);
-        assert_eq!(parsed.content, snippet.content);
-        assert_eq!(parsed.category, snippet.category);
-        assert_eq!(parsed.is_default, snippet.is_default);
-    }
-
-    #[test]
-    fn test_snippet_clone() {
-        let original = create_test_snippet("clone-test", "Clone Test", "Category", true);
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.name, cloned.name);
-        assert_eq!(original.is_default, cloned.is_default);
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_snippet_sorting_by_category_then_name() {
-        let mut snippets = vec![
-            create_test_snippet("s1", "Zebra", "B-Category", false),
-            create_test_snippet("s2", "Apple", "A-Category", false),
-            create_test_snippet("s3", "Banana", "B-Category", false),
-            create_test_snippet("s4", "Alpha", "A-Category", false),
-        ];
-
-        // Sort by category, then by name (mimics list_snippets behavior)
-        snippets.sort_by(|a, b| {
-            let cat_cmp = a.category.cmp(&b.category);
-            if cat_cmp == std::cmp::Ordering::Equal {
-                a.name.cmp(&b.name)
-            } else {
-                cat_cmp
-            }
-        });
-
-        // A-Category should come first
-        assert_eq!(snippets[0].category, "A-Category");
-        assert_eq!(snippets[1].category, "A-Category");
-        assert_eq!(snippets[2].category, "B-Category");
-        assert_eq!(snippets[3].category, "B-Category");
-
-        // Within categories, alphabetically by name
-        assert_eq!(snippets[0].name, "Alpha");
-        assert_eq!(snippets[1].name, "Apple");
-        assert_eq!(snippets[2].name, "Banana");
-        assert_eq!(snippets[3].name, "Zebra");
-    }
-
-    #[test]
-    fn test_known_default_snippets() {
-        let defaults = get_default_snippets();
-        let ids: Vec<&str> = defaults.iter().map(|s| s.id.as_str()).collect();
-
-        assert!(ids.contains(&"default-explain-code"));
-        assert!(ids.contains(&"default-fix-error"));
-        assert!(ids.contains(&"default-write-tests"));
-        assert!(ids.contains(&"default-refactor"));
-        assert!(ids.contains(&"default-optimize"));
-        assert!(ids.contains(&"default-review-pr"));
-        assert!(ids.contains(&"default-add-comments"));
-        assert!(ids.contains(&"default-security-review"));
-    }
-
-    #[test]
-    fn test_default_snippet_categories() {
-        let defaults = get_default_snippets();
-        let categories: HashSet<&String> = defaults.iter().map(|s| &s.category).collect();
-
-        assert!(categories.contains(&"Code Review".to_string()));
-        assert!(categories.contains(&"Debugging".to_string()));
-        assert!(categories.contains(&"Testing".to_string()));
-        assert!(categories.contains(&"Performance".to_string()));
-        assert!(categories.contains(&"Documentation".to_string()));
-        assert!(categories.contains(&"Security".to_string()));
-    }
-
-    #[test]
-    fn test_snippet_content_not_empty() {
-        let defaults = get_default_snippets();
-        for snippet in defaults {
-            assert!(
-                snippet.content.len() > 10,
-                "Content should be meaningful: {}",
-                snippet.name
-            );
-        }
-    }
-
-    #[test]
-    fn test_snippet_timestamps() {
-        let snippet = create_test_snippet("time-test", "Time Test", "Cat", false);
-        assert!(snippet.created_at <= snippet.updated_at);
-    }
-
-    #[test]
-    fn test_default_snippets_have_same_timestamps() {
-        let defaults = get_default_snippets();
-        // All defaults are created at the same instant
-        let first_created = defaults[0].created_at;
-        let first_updated = defaults[0].updated_at;
-
-        for snippet in &defaults {
-            assert_eq!(snippet.created_at, first_created);
-            assert_eq!(snippet.updated_at, first_updated);
-        }
-    }
-
-    #[test]
-    fn test_snippet_retain_non_default() {
-        let mut snippets = vec![
-            create_test_snippet("default-1", "Default 1", "Cat", true),
-            create_test_snippet("custom-1", "Custom 1", "Cat", false),
-            create_test_snippet("default-2", "Default 2", "Cat", true),
-            create_test_snippet("custom-2", "Custom 2", "Cat", false),
-        ];
-
-        // Mimics reset_default_snippets behavior (retain non-defaults)
-        snippets.retain(|s| !s.is_default);
-
-        assert_eq!(snippets.len(), 2);
-        assert!(snippets.iter().all(|s| !s.is_default));
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_snippet_find_by_id() {
-        let snippets = vec![
-            create_test_snippet("snippet-1", "First", "Cat", false),
-            create_test_snippet("snippet-2", "Second", "Cat", false),
-            create_test_snippet("snippet-3", "Third", "Cat", false),
-        ];
-
-        let found = snippets.iter().find(|s| s.id == "snippet-2");
-        assert!(found.is_some());
-        assert_eq!(found.unwrap().name, "Second");
-
-        let not_found = snippets.iter().find(|s| s.id == "snippet-999");
-        assert!(not_found.is_none());
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_extract_categories_sorted_and_deduped() {
-        let snippets = vec![
-            create_test_snippet("s1", "S1", "Zebra", false),
-            create_test_snippet("s2", "S2", "Alpha", false),
-            create_test_snippet("s3", "S3", "Beta", false),
-            create_test_snippet("s4", "S4", "Alpha", false), // Duplicate
-        ];
-
-        let mut categories: Vec<String> = snippets.iter().map(|s| s.category.clone()).collect();
-        categories.sort();
-        categories.dedup();
-
-        assert_eq!(categories.len(), 3);
-        assert_eq!(categories[0], "Alpha");
-        assert_eq!(categories[1], "Beta");
-        assert_eq!(categories[2], "Zebra");
-    }
-
-    #[test]
-    fn test_snippet_category_code_review_count() {
-        let defaults = get_default_snippets();
-        let code_review_count = defaults
-            .iter()
-            .filter(|s| s.category == "Code Review")
-            .count();
-
-        // There should be multiple code review snippets
-        assert!(code_review_count >= 2);
-    }
 }
@@ -1,9 +1,7 @@
 use crate::achievements::{check_achievements, AchievementProgress};
-use chrono::{Local, Timelike};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::Instant;
-use tauri_plugin_store::StoreExt;

 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct UsageStats {
@@ -30,14 +28,6 @@ pub struct UsageStats {
    #[serde(skip)]
    pub session_start: Option<Instant>,

-    // Extended tracking for achievements
-    pub sessions_started: u64,
-    pub consecutive_days: u64,
-    pub total_days_used: u64,
-    pub morning_sessions: u64, // Sessions started before 9 AM
-    pub night_sessions: u64,   // Sessions started after 10 PM
-    pub last_session_date: Option<String>, // ISO date string for streak tracking
-
    // Achievement tracking
    #[serde(skip)]
    pub achievements: AchievementProgress,
@@ -75,47 +65,6 @@ impl UsageStats {
        self.session_duration_seconds = 0;
        self.session_start = Some(Instant::now());
        self.achievements.start_session();
-
-        // Track session start for achievements
-        self.track_session_start();
-    }
-
-    pub fn track_session_start(&mut self) {
-        let now = Local::now();
-        let today = now.format("%Y-%m-%d").to_string();
-        let hour = now.hour();
-
-        // Increment session count
-        self.sessions_started += 1;
-
-        // Track morning/night sessions
-        if hour < 9 {
-            self.morning_sessions += 1;
-        }
-        if hour >= 22 {
-            self.night_sessions += 1;
-        }
-
-        // Track consecutive days and total days
-        if let Some(last_date) = &self.last_session_date {
-            if last_date != &today {
-                // Check if it's the next day (consecutive)
-                if is_consecutive_day(last_date, &today) {
-                    self.consecutive_days += 1;
-                } else {
-                    // Streak broken
-                    self.consecutive_days = 1;
-                }
-                self.total_days_used += 1;
-                self.last_session_date = Some(today);
-            }
-            // Same day - don't increment anything
-        } else {
-            // First session ever
-            self.consecutive_days = 1;
-            self.total_days_used = 1;
-            self.last_session_date = Some(today);
-        }
    }

    pub fn increment_messages(&mut self) {
@@ -178,34 +127,12 @@ impl UsageStats {
            session_tools_usage: self.session_tools_usage.clone(),
            session_duration_seconds: self.session_duration_seconds,
            session_start: self.session_start,
-            sessions_started: self.sessions_started,
-            consecutive_days: self.consecutive_days,
-            total_days_used: self.total_days_used,
-            morning_sessions: self.morning_sessions,
-            night_sessions: self.night_sessions,
-            last_session_date: self.last_session_date.clone(),
            achievements: AchievementProgress::new(), // Dummy for copy
        };
        check_achievements(&stats_copy, &mut self.achievements)
    }
 }

-// Helper function to check if two dates are consecutive
-fn is_consecutive_day(prev_date: &str, current_date: &str) -> bool {
-    use chrono::NaiveDate;
-
-    let prev = NaiveDate::parse_from_str(prev_date, "%Y-%m-%d").ok();
-    let current = NaiveDate::parse_from_str(current_date, "%Y-%m-%d").ok();
-
-    match (prev, current) {
-        (Some(p), Some(c)) => {
-            let diff = c.signed_duration_since(p).num_days();
-            diff == 1
-        }
-        _ => false,
-    }
-}
-
 // Pricing as of January 2025
 // https://www.anthropic.com/pricing
 fn calculate_cost(input_tokens: u64, output_tokens: u64, model: &str) -> f64 {
@@ -242,111 +169,6 @@ pub struct StatsUpdateEvent {
    pub stats: UsageStats,
 }

-/// Serializable struct for persisting only lifetime (total) stats
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct PersistedStats {
-    pub total_input_tokens: u64,
-    pub total_output_tokens: u64,
-    pub total_cost_usd: f64,
-    pub messages_exchanged: u64,
-    pub code_blocks_generated: u64,
-    pub files_edited: u64,
-    pub files_created: u64,
-    pub tools_usage: HashMap<String, u64>,
-    pub sessions_started: u64,
-    pub consecutive_days: u64,
-    pub total_days_used: u64,
-    pub morning_sessions: u64,
-    pub night_sessions: u64,
-    pub last_session_date: Option<String>,
-}
-
-impl From<&UsageStats> for PersistedStats {
-    fn from(stats: &UsageStats) -> Self {
-        PersistedStats {
-            total_input_tokens: stats.total_input_tokens,
-            total_output_tokens: stats.total_output_tokens,
-            total_cost_usd: stats.total_cost_usd,
-            messages_exchanged: stats.messages_exchanged,
-            code_blocks_generated: stats.code_blocks_generated,
-            files_edited: stats.files_edited,
-            files_created: stats.files_created,
-            tools_usage: stats.tools_usage.clone(),
-            sessions_started: stats.sessions_started,
-            consecutive_days: stats.consecutive_days,
-            total_days_used: stats.total_days_used,
-            morning_sessions: stats.morning_sessions,
-            night_sessions: stats.night_sessions,
-            last_session_date: stats.last_session_date.clone(),
-        }
-    }
-}
-
-impl UsageStats {
-    /// Apply persisted stats to restore lifetime totals
-    pub fn apply_persisted(&mut self, persisted: PersistedStats) {
-        self.total_input_tokens = persisted.total_input_tokens;
-        self.total_output_tokens = persisted.total_output_tokens;
-        self.total_cost_usd = persisted.total_cost_usd;
-        self.messages_exchanged = persisted.messages_exchanged;
-        self.code_blocks_generated = persisted.code_blocks_generated;
-        self.files_edited = persisted.files_edited;
-        self.files_created = persisted.files_created;
-        self.tools_usage = persisted.tools_usage;
-        self.sessions_started = persisted.sessions_started;
-        self.consecutive_days = persisted.consecutive_days;
-        self.total_days_used = persisted.total_days_used;
-        self.morning_sessions = persisted.morning_sessions;
-        self.night_sessions = persisted.night_sessions;
-        self.last_session_date = persisted.last_session_date;
-    }
-}
-
-/// Save lifetime stats to persistent store
-pub async fn save_stats(app: &tauri::AppHandle, stats: &UsageStats) -> Result<(), String> {
-    let store = app.store("stats.json").map_err(|e| e.to_string())?;
-
-    let persisted = PersistedStats::from(stats);
-
-    println!("Saving stats: {:?}", persisted);
-
-    store.set(
-        "lifetime_stats",
-        serde_json::to_value(persisted).map_err(|e| e.to_string())?,
-    );
-    store.save().map_err(|e| e.to_string())?;
-
-    println!("Stats saved successfully");
-    Ok(())
-}
-
-/// Load lifetime stats from persistent store
-pub async fn load_stats(app: &tauri::AppHandle) -> Option<PersistedStats> {
-    println!("Loading stats from store...");
-
-    let store = match app.store("stats.json") {
-        Ok(s) => s,
-        Err(e) => {
-            println!("Failed to open stats store: {}", e);
-            return None;
-        }
-    };
-
-    if let Some(stats_value) = store.get("lifetime_stats") {
-        println!("Found lifetime stats in store: {:?}", stats_value);
-        if let Ok(persisted) = serde_json::from_value::<PersistedStats>(stats_value.clone()) {
-            println!("Loaded lifetime stats successfully");
-            return Some(persisted);
-        } else {
-            println!("Failed to parse lifetime stats");
-        }
-    } else {
-        println!("No lifetime stats found in store");
-    }
-
-    None
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -369,36 +191,6 @@ mod tests {
        assert!((cost - 0.165).abs() < 0.0001);
    }

-    #[test]
-    fn test_cost_calculation_opus_45() {
-        let cost = calculate_cost(1000, 2000, "claude-opus-4-5-20251101");
-        // Same pricing as Opus 4
-        assert!((cost - 0.165).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_cost_calculation_haiku() {
-        let cost = calculate_cost(1000, 2000, "claude-3-5-haiku-20241022");
-        // 1000 input * $1/M = $0.001
-        // 2000 output * $5/M = $0.010
-        // Total = $0.011
-        assert!((cost - 0.011).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_cost_calculation_unknown_defaults_to_sonnet() {
-        let cost = calculate_cost(1000, 2000, "some-unknown-model");
-        // Should default to Sonnet pricing
-        assert!((cost - 0.033).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_cost_calculation_legacy_sonnet() {
-        let cost = calculate_cost(1000, 2000, "claude-3-5-sonnet-20241022");
-        // Same as Sonnet 4 pricing
-        assert!((cost - 0.033).abs() < 0.0001);
-    }
-
    #[test]
    fn test_usage_stats_accumulation() {
        let mut stats = UsageStats::new();
@@ -411,28 +203,6 @@ mod tests {
        assert!((stats.total_cost_usd - 0.033).abs() < 0.0001);
    }

-    #[test]
-    fn test_usage_stats_multiple_accumulations() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514");
-        stats.add_usage(500, 500, "claude-sonnet-4-20250514");
-
-        assert_eq!(stats.total_input_tokens, 1500);
-        assert_eq!(stats.total_output_tokens, 1500);
-        assert_eq!(stats.session_input_tokens, 1500);
-        assert_eq!(stats.session_output_tokens, 1500);
-    }
-
-    #[test]
-    fn test_usage_stats_model_updated() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514");
-        assert_eq!(stats.model, Some("claude-sonnet-4-20250514".to_string()));
-
-        stats.add_usage(500, 500, "claude-opus-4-20250514");
-        assert_eq!(stats.model, Some("claude-opus-4-20250514".to_string()));
-    }
-
    #[test]
    fn test_session_reset() {
        let mut stats = UsageStats::new();
@@ -446,230 +216,4 @@ mod tests {
        assert_eq!(stats.session_cost_usd, 0.0);
        assert!(stats.total_cost_usd > 0.0);
    }
-
-    #[test]
-    fn test_session_reset_clears_session_stats() {
-        let mut stats = UsageStats::new();
-        stats.increment_messages();
-        stats.increment_messages();
-        stats.increment_code_blocks();
-        stats.increment_files_edited();
-        stats.increment_files_created();
-        stats.increment_tool_usage("Read");
-
-        stats.reset_session();
-
-        assert_eq!(stats.session_messages_exchanged, 0);
-        assert_eq!(stats.session_code_blocks_generated, 0);
-        assert_eq!(stats.session_files_edited, 0);
-        assert_eq!(stats.session_files_created, 0);
-        assert!(stats.session_tools_usage.is_empty());
-    }
-
-    #[test]
-    fn test_increment_messages() {
-        let mut stats = UsageStats::new();
-        stats.increment_messages();
-        stats.increment_messages();
-        stats.increment_messages();
-
-        assert_eq!(stats.messages_exchanged, 3);
-        assert_eq!(stats.session_messages_exchanged, 3);
-    }
-
-    #[test]
-    fn test_increment_code_blocks() {
-        let mut stats = UsageStats::new();
-        stats.increment_code_blocks();
-        stats.increment_code_blocks();
-
-        assert_eq!(stats.code_blocks_generated, 2);
-        assert_eq!(stats.session_code_blocks_generated, 2);
-    }
-
-    #[test]
-    fn test_increment_files_edited() {
-        let mut stats = UsageStats::new();
-        stats.increment_files_edited();
-
-        assert_eq!(stats.files_edited, 1);
-        assert_eq!(stats.session_files_edited, 1);
-    }
-
-    #[test]
-    fn test_increment_files_created() {
-        let mut stats = UsageStats::new();
-        stats.increment_files_created();
-
-        assert_eq!(stats.files_created, 1);
-        assert_eq!(stats.session_files_created, 1);
-    }
-
-    #[test]
-    fn test_increment_tool_usage() {
-        let mut stats = UsageStats::new();
-        stats.increment_tool_usage("Read");
-        stats.increment_tool_usage("Read");
-        stats.increment_tool_usage("Write");
-
-        assert_eq!(stats.tools_usage.get("Read"), Some(&2));
-        assert_eq!(stats.tools_usage.get("Write"), Some(&1));
-        assert_eq!(stats.session_tools_usage.get("Read"), Some(&2));
-        assert_eq!(stats.session_tools_usage.get("Write"), Some(&1));
-    }
-
-    #[test]
-    fn test_session_duration_tracking() {
-        let mut stats = UsageStats::new();
-        stats.session_start = Some(Instant::now());
-
-        // Verify duration is returned (u64 is always non-negative)
-        let _duration = stats.get_session_duration();
-    }
-
-    #[test]
-    fn test_session_duration_without_start() {
-        let mut stats = UsageStats::new();
-        stats.session_start = None;
-        stats.session_duration_seconds = 100;
-
-        // Should return the stored value when no start time
-        let duration = stats.get_session_duration();
-        assert_eq!(duration, 100);
-    }
-
-    #[test]
-    fn test_is_consecutive_day_true() {
-        assert!(is_consecutive_day("2024-01-15", "2024-01-16"));
-        assert!(is_consecutive_day("2024-12-31", "2025-01-01"));
-    }
-
-    #[test]
-    fn test_is_consecutive_day_false() {
-        assert!(!is_consecutive_day("2024-01-15", "2024-01-15")); // Same day
-        assert!(!is_consecutive_day("2024-01-15", "2024-01-17")); // Gap
-        assert!(!is_consecutive_day("2024-01-15", "2024-01-14")); // Backwards
-    }
-
-    #[test]
-    fn test_is_consecutive_day_invalid_dates() {
-        assert!(!is_consecutive_day("invalid", "2024-01-01"));
-        assert!(!is_consecutive_day("2024-01-01", "invalid"));
-        assert!(!is_consecutive_day("invalid", "also-invalid"));
-    }
-
-    #[test]
-    fn test_persisted_stats_from_usage_stats() {
-        let mut stats = UsageStats::new();
-        stats.total_input_tokens = 5000;
-        stats.total_output_tokens = 10000;
-        stats.total_cost_usd = 1.23;
-        stats.messages_exchanged = 50;
-        stats.sessions_started = 5;
-        stats.consecutive_days = 3;
-
-        let persisted = PersistedStats::from(&stats);
-
-        assert_eq!(persisted.total_input_tokens, 5000);
-        assert_eq!(persisted.total_output_tokens, 10000);
-        assert_eq!(persisted.total_cost_usd, 1.23);
-        assert_eq!(persisted.messages_exchanged, 50);
-        assert_eq!(persisted.sessions_started, 5);
-        assert_eq!(persisted.consecutive_days, 3);
-    }
-
-    #[test]
-    fn test_apply_persisted_stats() {
-        let persisted = PersistedStats {
-            total_input_tokens: 10000,
-            total_output_tokens: 20000,
-            total_cost_usd: 5.50,
-            messages_exchanged: 100,
-            code_blocks_generated: 25,
-            files_edited: 10,
-            files_created: 5,
-            tools_usage: {
-                let mut map = HashMap::new();
-                map.insert("Read".to_string(), 50);
-                map
-            },
-            sessions_started: 10,
-            consecutive_days: 7,
-            total_days_used: 14,
-            morning_sessions: 3,
-            night_sessions: 2,
-            last_session_date: Some("2024-06-15".to_string()),
-        };
-
-        let mut stats = UsageStats::new();
-        stats.apply_persisted(persisted);
-
-        assert_eq!(stats.total_input_tokens, 10000);
-        assert_eq!(stats.total_output_tokens, 20000);
-        assert_eq!(stats.total_cost_usd, 5.50);
-        assert_eq!(stats.messages_exchanged, 100);
-        assert_eq!(stats.tools_usage.get("Read"), Some(&50));
-        assert_eq!(stats.consecutive_days, 7);
-        assert_eq!(stats.morning_sessions, 3);
-        assert_eq!(stats.last_session_date, Some("2024-06-15".to_string()));
-    }
-
-    #[test]
-    fn test_usage_stats_default() {
-        let stats = UsageStats::default();
-
-        assert_eq!(stats.total_input_tokens, 0);
-        assert_eq!(stats.total_output_tokens, 0);
-        assert_eq!(stats.total_cost_usd, 0.0);
-        assert!(stats.model.is_none());
-    }
-
-    #[test]
-    fn test_persisted_stats_default() {
-        let persisted = PersistedStats::default();
-
-        assert_eq!(persisted.total_input_tokens, 0);
-        assert!(persisted.last_session_date.is_none());
-    }
-
-    #[test]
-    fn test_usage_stats_serialization() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514");
-        stats.increment_messages();
-
-        // UsageStats should be serializable (for events)
-        let json = serde_json::to_string(&stats).expect("Failed to serialize");
-        assert!(json.contains("total_input_tokens"));
-        assert!(json.contains("1000"));
-    }
-
-    #[test]
-    fn test_persisted_stats_serialization() {
-        let persisted = PersistedStats {
-            total_input_tokens: 1234,
-            total_output_tokens: 5678,
-            total_cost_usd: 0.99,
-            ..Default::default()
-        };
-
-        let json = serde_json::to_string(&persisted).expect("Failed to serialize");
-        let parsed: PersistedStats = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.total_input_tokens, 1234);
-        assert_eq!(parsed.total_output_tokens, 5678);
-        assert!((parsed.total_cost_usd - 0.99).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_stats_update_event_serialization() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(100, 200, "claude-sonnet-4-20250514");
-
-        let event = StatsUpdateEvent { stats };
-        let json = serde_json::to_string(&event).expect("Failed to serialize");
-
-        assert!(json.contains("stats"));
-        assert!(json.contains("total_input_tokens"));
-    }
 }
@@ -137,290 +137,3 @@ pub type SharedTempFileManager = Arc<Mutex<TempFileManager>>;
 pub fn create_shared_temp_manager() -> Result<SharedTempFileManager, String> {
    Ok(Arc::new(Mutex::new(TempFileManager::new()?)))
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use tempfile::TempDir;
-
-    // Helper to create a TempFileManager with a custom base directory for testing
-    fn create_test_manager(base_dir: PathBuf) -> TempFileManager {
-        if !base_dir.exists() {
-            fs::create_dir_all(&base_dir).expect("Failed to create test temp dir");
-        }
-        TempFileManager {
-            base_dir,
-            files: HashMap::new(),
-        }
-    }
-
-    #[test]
-    fn test_new_creates_base_directory() {
-        let manager = TempFileManager::new().expect("Failed to create TempFileManager");
-        assert!(manager.base_dir.exists());
-    }
-
-    #[test]
-    fn test_get_base_dir_returns_correct_path() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let manager = create_test_manager(base_path.clone());
-
-        assert_eq!(manager.get_base_dir(), base_path.as_path());
-    }
-
-    #[test]
-    fn test_save_file_creates_file_with_content() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"Hello, world!";
-        let result = manager.save_file("conv-1", data, Some("test.txt"));
-
-        assert!(result.is_ok());
-        let file_path = result.unwrap();
-        assert!(file_path.exists());
-
-        let content = fs::read(&file_path).expect("Failed to read file");
-        assert_eq!(content, data);
-    }
-
-    #[test]
-    fn test_save_file_uses_correct_extension() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test data";
-        let result = manager.save_file("conv-1", data, Some("document.pdf"));
-
-        assert!(result.is_ok());
-        let file_path = result.unwrap();
-        assert_eq!(file_path.extension().unwrap(), "pdf");
-    }
-
-    #[test]
-    fn test_save_file_uses_bin_extension_when_no_filename() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"binary data";
-        let result = manager.save_file("conv-1", data, None);
-
-        assert!(result.is_ok());
-        let file_path = result.unwrap();
-        assert_eq!(file_path.extension().unwrap(), "bin");
-    }
-
-    #[test]
-    fn test_register_file_tracks_file_path() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let file_path = PathBuf::from("/some/path/file.txt");
-        manager.register_file("conv-1", file_path.clone());
-
-        let files = manager.get_files_for_conversation("conv-1");
-        assert_eq!(files.len(), 1);
-        assert_eq!(files[0], file_path);
-    }
-
-    #[test]
-    fn test_get_files_for_conversation_returns_empty_for_unknown() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let manager = create_test_manager(base_path);
-
-        let files = manager.get_files_for_conversation("unknown-conv");
-        assert!(files.is_empty());
-    }
-
-    #[test]
-    fn test_get_files_for_conversation_returns_all_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        manager.save_file("conv-1", data, Some("file1.txt")).unwrap();
-        manager.save_file("conv-1", data, Some("file2.txt")).unwrap();
-        manager.save_file("conv-2", data, Some("file3.txt")).unwrap();
-
-        let files_conv1 = manager.get_files_for_conversation("conv-1");
-        let files_conv2 = manager.get_files_for_conversation("conv-2");
-
-        assert_eq!(files_conv1.len(), 2);
-        assert_eq!(files_conv2.len(), 1);
-    }
-
-    #[test]
-    fn test_cleanup_conversation_removes_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        let file_path = manager.save_file("conv-1", data, Some("test.txt")).unwrap();
-        assert!(file_path.exists());
-
-        let result = manager.cleanup_conversation("conv-1");
-        assert!(result.is_ok());
-        assert!(!file_path.exists());
-        assert!(manager.get_files_for_conversation("conv-1").is_empty());
-    }
-
-    #[test]
-    fn test_cleanup_conversation_handles_missing_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        // Register a file that doesn't exist
-        manager.register_file("conv-1", PathBuf::from("/nonexistent/file.txt"));
-
-        // Should not error, just skip missing files
-        let result = manager.cleanup_conversation("conv-1");
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_cleanup_conversation_for_unknown_returns_ok() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let result = manager.cleanup_conversation("unknown-conv");
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_cleanup_all_removes_all_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        let file1 = manager.save_file("conv-1", data, Some("f1.txt")).unwrap();
-        let file2 = manager.save_file("conv-2", data, Some("f2.txt")).unwrap();
-
-        assert!(file1.exists());
-        assert!(file2.exists());
-
-        let result = manager.cleanup_all();
-        assert!(result.is_ok());
-
-        assert!(!file1.exists());
-        assert!(!file2.exists());
-        assert!(manager.files.is_empty());
-    }
-
-    #[test]
-    fn test_cleanup_orphaned_files_removes_untracked() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path.clone());
-
-        // Create a tracked file
-        let data = b"tracked";
-        let tracked_path = manager.save_file("conv-1", data, Some("tracked.txt")).unwrap();
-
-        // Create an untracked (orphaned) file directly in the temp directory
-        let orphan_path = base_path.join("orphan.txt");
-        fs::write(&orphan_path, b"orphan").expect("Failed to create orphan file");
-
-        assert!(tracked_path.exists());
-        assert!(orphan_path.exists());
-
-        let result = manager.cleanup_orphaned_files();
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 1); // One orphan removed
-
-        assert!(tracked_path.exists()); // Tracked file still exists
-        assert!(!orphan_path.exists()); // Orphan removed
-    }
-
-    #[test]
-    fn test_cleanup_orphaned_returns_zero_when_none() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        manager.save_file("conv-1", data, Some("test.txt")).unwrap();
-
-        let result = manager.cleanup_orphaned_files();
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0);
-    }
-
-    #[test]
-    fn test_cleanup_orphaned_returns_zero_when_dir_missing() {
-        let mut manager = TempFileManager {
-            base_dir: PathBuf::from("/nonexistent/dir"),
-            files: HashMap::new(),
-        };
-
-        let result = manager.cleanup_orphaned_files();
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0);
-    }
-
-    #[test]
-    fn test_default_creates_manager() {
-        // Default should work as long as we can create temp directories
-        let manager = TempFileManager::default();
-        assert!(manager.base_dir.exists());
-    }
-
-    #[test]
-    fn test_create_shared_temp_manager() {
-        let result = create_shared_temp_manager();
-        assert!(result.is_ok());
-
-        let shared = result.unwrap();
-        let manager = shared.lock();
-        assert!(manager.base_dir.exists());
-    }
-
-    #[test]
-    fn test_multiple_files_same_conversation() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        // Save multiple files to same conversation
-        for i in 0..5 {
-            let data = format!("content {}", i);
-            manager
-                .save_file("conv-1", data.as_bytes(), Some(&format!("file{}.txt", i)))
-                .unwrap();
-        }
-
-        let files = manager.get_files_for_conversation("conv-1");
-        assert_eq!(files.len(), 5);
-
-        // Each file should have unique content
-        for (i, file_path) in files.iter().enumerate() {
-            let content = fs::read_to_string(file_path).expect("Failed to read");
-            assert_eq!(content, format!("content {}", i));
-        }
-    }
-
-    #[test]
-    fn test_file_paths_contain_conversation_id() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let file_path = manager
-            .save_file("my-conversation-id", b"test", Some("test.txt"))
-            .unwrap();
-
-        let filename = file_path.file_name().unwrap().to_str().unwrap();
-        assert!(filename.starts_with("my-conversation-id_"));
-    }
-}
@@ -112,7 +112,7 @@ impl WslBridge {
            return Err("Process already running".to_string());
        }

-        // Load saved achievements and stats when starting a new session
+        // Load saved achievements when starting a new session
        let app_clone = app.clone();
        let stats = self.stats.clone();
        tauri::async_runtime::spawn(async move {
@@ -122,17 +122,7 @@ impl WslBridge {
                "Loaded {} unlocked achievements",
                achievements.unlocked.len()
            );
-
-            println!("Loading saved stats...");
-            let persisted_stats = crate::stats::load_stats(&app_clone).await;
-
-            let mut stats_guard = stats.write();
-            stats_guard.achievements = achievements;
-
-            if let Some(persisted) = persisted_stats {
-                println!("Applying persisted lifetime stats");
-                stats_guard.apply_persisted(persisted);
-            }
+            stats.write().achievements = achievements;
        });

        let working_dir = &options.working_dir;
@@ -450,18 +440,6 @@ impl WslBridge {
        self.session_id = None;
        self.mcp_config_file = None; // Temp file is automatically deleted when dropped

-        // Save lifetime stats before resetting session
-        let stats_snapshot = self.stats.read().clone();
-        let app_clone = app.clone();
-        tauri::async_runtime::spawn(async move {
-            println!("Saving stats on session stop...");
-            if let Err(e) = crate::stats::save_stats(&app_clone, &stats_snapshot).await {
-                eprintln!("Failed to save stats: {}", e);
-            } else {
-                println!("Stats saved successfully on session stop");
-            }
-        });
-
        // Reset session stats on explicit disconnect
        self.stats.write().reset_session();

@@ -755,23 +733,10 @@ fn process_json_line(

            let current_stats = stats.read().clone();
            let stats_event = StatsUpdateEvent {
-                stats: current_stats.clone(),
+                stats: current_stats,
            };
            let _ = app.emit("claude:stats", stats_event);

-            // Save stats periodically (every 10 messages to avoid excessive disk writes)
-            if current_stats.session_messages_exchanged.is_multiple_of(10)
-                && current_stats.session_messages_exchanged > 0
-            {
-                let app_handle = app.clone();
-                tauri::async_runtime::spawn(async move {
-                    println!("Periodic stats save (every 10 messages)...");
-                    if let Err(e) = crate::stats::save_stats(&app_handle, &current_stats).await {
-                        eprintln!("Failed to save stats: {}", e);
-                    }
-                });
-            }
-
            // Only emit error results - success content is already sent via Assistant message
            if subtype != "success" {
                if let Some(text) = result {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "hikari-desktop",
-  "version": "1.0.0",
+  "version": "0.3.0",
  "identifier": "com.naomi.hikari-desktop",
  "build": {
    "beforeDevCommand": "pnpm dev",
@@ -1,414 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import {
-  slashCommands,
-  parseSlashCommand,
-  getMatchingCommands,
-  isSlashCommand,
-  type SlashCommand,
-} from "./slashCommands";
-
-// Mock all external dependencies
-vi.mock("svelte/store", () => ({
-  get: vi.fn(),
-}));
-
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn(),
-}));
-
-vi.mock("$lib/stores/claude", () => ({
-  claudeStore: {
-    addLine: vi.fn(),
-    clearTerminal: vi.fn(),
-    activeConversationId: { subscribe: vi.fn() },
-    currentWorkingDirectory: { subscribe: vi.fn() },
-    setWorkingDirectory: vi.fn(),
-    getConversationHistory: vi.fn(),
-  },
-}));
-
-vi.mock("$lib/stores/character", () => ({
-  characterState: {
-    setState: vi.fn(),
-    setTemporaryState: vi.fn(),
-  },
-}));
-
-vi.mock("$lib/tauri", () => ({
-  setSkipNextGreeting: vi.fn(),
-}));
-
-vi.mock("$lib/stores/search", () => ({
-  searchState: {
-    setQuery: vi.fn(),
-    clear: vi.fn(),
-  },
-}));
-
-describe("slashCommands", () => {
-  describe("slashCommands array", () => {
-    it("contains expected commands", () => {
-      const commandNames = slashCommands.map((cmd) => cmd.name);
-      expect(commandNames).toContain("cd");
-      expect(commandNames).toContain("clear");
-      expect(commandNames).toContain("new");
-      expect(commandNames).toContain("help");
-      expect(commandNames).toContain("search");
-      expect(commandNames).toContain("summarise");
-      expect(commandNames).toContain("skill");
-    });
-
-    it("has 7 commands total", () => {
-      expect(slashCommands.length).toBe(7);
-    });
-
-    it("each command has required properties", () => {
-      slashCommands.forEach((cmd) => {
-        expect(cmd.name).toBeDefined();
-        expect(typeof cmd.name).toBe("string");
-        expect(cmd.name.length).toBeGreaterThan(0);
-
-        expect(cmd.description).toBeDefined();
-        expect(typeof cmd.description).toBe("string");
-        expect(cmd.description.length).toBeGreaterThan(0);
-
-        expect(cmd.usage).toBeDefined();
-        expect(typeof cmd.usage).toBe("string");
-        expect(cmd.usage.startsWith("/")).toBe(true);
-
-        expect(cmd.execute).toBeDefined();
-        expect(typeof cmd.execute).toBe("function");
-      });
-    });
-
-    it("cd command has correct metadata", () => {
-      const cdCmd = slashCommands.find((cmd) => cmd.name === "cd");
-      expect(cdCmd).toBeDefined();
-      expect(cdCmd!.description).toBe("Change the working directory");
-      expect(cdCmd!.usage).toBe("/cd <path>");
-    });
-
-    it("clear command has correct metadata", () => {
-      const clearCmd = slashCommands.find((cmd) => cmd.name === "clear");
-      expect(clearCmd).toBeDefined();
-      expect(clearCmd!.description).toBe("Clear the terminal display (keeps conversation context)");
-      expect(clearCmd!.usage).toBe("/clear");
-    });
-
-    it("new command has correct metadata", () => {
-      const newCmd = slashCommands.find((cmd) => cmd.name === "new");
-      expect(newCmd).toBeDefined();
-      expect(newCmd!.description).toBe("Start a fresh conversation (resets context)");
-      expect(newCmd!.usage).toBe("/new");
-    });
-
-    it("help command has correct metadata", () => {
-      const helpCmd = slashCommands.find((cmd) => cmd.name === "help");
-      expect(helpCmd).toBeDefined();
-      expect(helpCmd!.description).toBe("Show available slash commands");
-      expect(helpCmd!.usage).toBe("/help");
-    });
-
-    it("search command has correct metadata", () => {
-      const searchCmd = slashCommands.find((cmd) => cmd.name === "search");
-      expect(searchCmd).toBeDefined();
-      expect(searchCmd!.description).toBe("Search within the conversation (use /search to clear)");
-      expect(searchCmd!.usage).toBe("/search [query]");
-    });
-
-    it("summarise command has correct metadata", () => {
-      const summariseCmd = slashCommands.find((cmd) => cmd.name === "summarise");
-      expect(summariseCmd).toBeDefined();
-      expect(summariseCmd!.description).toBe("Get a summary of the entire conversation");
-      expect(summariseCmd!.usage).toBe("/summarise");
-    });
-
-    it("skill command has correct metadata", () => {
-      const skillCmd = slashCommands.find((cmd) => cmd.name === "skill");
-      expect(skillCmd).toBeDefined();
-      expect(skillCmd!.description).toBe("Invoke a Claude Code skill from ~/.claude/skills/");
-      expect(skillCmd!.usage).toBe("/skill [name] [data]");
-    });
-  });
-
-  describe("parseSlashCommand", () => {
-    it("returns null for non-slash input", () => {
-      const result = parseSlashCommand("hello world");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("returns null for empty string", () => {
-      const result = parseSlashCommand("");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("returns null for whitespace only", () => {
-      const result = parseSlashCommand("   ");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("parses /cd command without args", () => {
-      const result = parseSlashCommand("/cd");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /cd command with path argument", () => {
-      const result = parseSlashCommand("/cd /home/naomi/code");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("/home/naomi/code");
-    });
-
-    it("parses /clear command", () => {
-      const result = parseSlashCommand("/clear");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("clear");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /new command", () => {
-      const result = parseSlashCommand("/new");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("new");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /help command", () => {
-      const result = parseSlashCommand("/help");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("help");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /search command with query", () => {
-      const result = parseSlashCommand("/search hello world");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("search");
-      expect(result.args).toBe("hello world");
-    });
-
-    it("parses /search command without query", () => {
-      const result = parseSlashCommand("/search");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("search");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /summarise command", () => {
-      const result = parseSlashCommand("/summarise");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("summarise");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /skill command with name and data", () => {
-      const result = parseSlashCommand("/skill onboard-mentee john@example.com");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("skill");
-      expect(result.args).toBe("onboard-mentee john@example.com");
-    });
-
-    it("parses /skill command with name only", () => {
-      const result = parseSlashCommand("/skill onboard-mentee");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("skill");
-      expect(result.args).toBe("onboard-mentee");
-    });
-
-    it("parses /skill command without arguments", () => {
-      const result = parseSlashCommand("/skill");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("skill");
-      expect(result.args).toBe("");
-    });
-
-    it("returns null for unknown command", () => {
-      const result = parseSlashCommand("/unknown");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("is case insensitive for command names", () => {
-      const result1 = parseSlashCommand("/CD /path");
-      expect(result1.command).not.toBeNull();
-      expect(result1.command!.name).toBe("cd");
-
-      const result2 = parseSlashCommand("/CLEAR");
-      expect(result2.command).not.toBeNull();
-      expect(result2.command!.name).toBe("clear");
-
-      const result3 = parseSlashCommand("/Help");
-      expect(result3.command).not.toBeNull();
-      expect(result3.command!.name).toBe("help");
-    });
-
-    it("handles leading whitespace", () => {
-      const result = parseSlashCommand("  /cd /path");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("/path");
-    });
-
-    it("handles trailing whitespace", () => {
-      const result = parseSlashCommand("/cd /path  ");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("/path");
-    });
-
-    it("handles multiple spaces between args", () => {
-      const result = parseSlashCommand("/search   hello   world");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("search");
-      expect(result.args).toBe("hello world");
-    });
-  });
-
-  describe("getMatchingCommands", () => {
-    it("returns empty array for non-slash input", () => {
-      const result = getMatchingCommands("hello");
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array for empty string", () => {
-      const result = getMatchingCommands("");
-      expect(result).toEqual([]);
-    });
-
-    it("returns all commands for just slash", () => {
-      const result = getMatchingCommands("/");
-      expect(result.length).toBe(slashCommands.length);
-    });
-
-    it("returns matching commands for partial input", () => {
-      const result = getMatchingCommands("/c");
-      const names = result.map((cmd) => cmd.name);
-      expect(names).toContain("cd");
-      expect(names).toContain("clear");
-      expect(names).not.toContain("help");
-    });
-
-    it("returns single command for exact match", () => {
-      const result = getMatchingCommands("/cd");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("cd");
-    });
-
-    it("returns single command for partial unique match", () => {
-      const result = getMatchingCommands("/cl");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("clear");
-    });
-
-    it("returns matching commands for /s prefix", () => {
-      const result = getMatchingCommands("/s");
-      const names = result.map((cmd) => cmd.name);
-      expect(names).toContain("search");
-      expect(names).toContain("summarise");
-      expect(names).toContain("skill");
-    });
-
-    it("is case insensitive", () => {
-      const result1 = getMatchingCommands("/C");
-      const result2 = getMatchingCommands("/c");
-      expect(result1.length).toBe(result2.length);
-    });
-
-    it("returns empty array for no matches", () => {
-      const result = getMatchingCommands("/xyz");
-      expect(result).toEqual([]);
-    });
-
-    it("handles whitespace correctly", () => {
-      const result = getMatchingCommands("  /c");
-      const names = result.map((cmd) => cmd.name);
-      expect(names).toContain("cd");
-      expect(names).toContain("clear");
-    });
-
-    it("returns command for full command name", () => {
-      const result = getMatchingCommands("/help");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("help");
-    });
-
-    it("returns command for /new", () => {
-      const result = getMatchingCommands("/n");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("new");
-    });
-  });
-
-  describe("isSlashCommand", () => {
-    it("returns true for input starting with slash", () => {
-      expect(isSlashCommand("/cd")).toBe(true);
-      expect(isSlashCommand("/")).toBe(true);
-      expect(isSlashCommand("/help")).toBe(true);
-      expect(isSlashCommand("/unknown")).toBe(true);
-    });
-
-    it("returns false for non-slash input", () => {
-      expect(isSlashCommand("hello")).toBe(false);
-      expect(isSlashCommand("")).toBe(false);
-      expect(isSlashCommand("cd")).toBe(false);
-    });
-
-    it("handles whitespace correctly", () => {
-      expect(isSlashCommand("  /cd")).toBe(true);
-      expect(isSlashCommand("  hello")).toBe(false);
-    });
-
-    it("returns false for slash in middle of string", () => {
-      expect(isSlashCommand("hello/world")).toBe(false);
-    });
-  });
-
-  describe("SlashCommand interface", () => {
-    it("can create a valid slash command object", () => {
-      const testCommand: SlashCommand = {
-        name: "test",
-        description: "A test command",
-        usage: "/test [arg]",
-        execute: vi.fn(),
-      };
-
-      expect(testCommand.name).toBe("test");
-      expect(testCommand.description).toBe("A test command");
-      expect(testCommand.usage).toBe("/test [arg]");
-      expect(typeof testCommand.execute).toBe("function");
-    });
-
-    it("execute can be async function", () => {
-      const asyncCommand: SlashCommand = {
-        name: "async",
-        description: "An async command",
-        usage: "/async",
-        execute: async () => {
-          await Promise.resolve();
-        },
-      };
-
-      expect(asyncCommand.execute("")).toBeInstanceOf(Promise);
-    });
-
-    it("execute can be sync function", () => {
-      const syncCommand: SlashCommand = {
-        name: "sync",
-        description: "A sync command",
-        usage: "/sync",
-        execute: () => {
-          // Synchronous execution
-        },
-      };
-
-      const result = syncCommand.execute("");
-      // Sync function returns undefined, not a Promise
-      expect(result).toBeUndefined();
-    });
-  });
-});
@@ -249,9 +249,6 @@
    -webkit-mask:
      linear-gradient(#fff 0 0) content-box,
      linear-gradient(#fff 0 0);
-    mask:
-      linear-gradient(#fff 0 0) content-box,
-      linear-gradient(#fff 0 0);
    -webkit-mask-composite: xor;
    mask-composite: exclude;
    opacity: 0;
@@ -3,9 +3,7 @@
    configStore,
    type HikariConfig,
    type Theme,
-    type CustomThemeColors,
    applyFontSize,
-    applyCustomThemeColors,
    MIN_FONT_SIZE,
    MAX_FONT_SIZE,
    DEFAULT_FONT_SIZE,
@@ -32,23 +30,8 @@
    streamer_mode: false,
    streamer_hide_paths: false,
    compact_mode: false,
-    profile_name: null,
-    profile_avatar_path: null,
-    profile_bio: null,
-    custom_theme_colors: {
-      bg_primary: null,
-      bg_secondary: null,
-      bg_terminal: null,
-      accent_primary: null,
-      accent_secondary: null,
-      text_primary: null,
-      text_secondary: null,
-      border_color: null,
-    },
  });

-  let showCustomThemeEditor = $state(false);
-
  let isOpen = $state(false);
  let isSaving = $state(false);
  let saveError: string | null = $state(null);
@@ -105,33 +88,9 @@

  async function handleThemeChange(theme: Theme) {
    config.theme = theme;
-    showCustomThemeEditor = theme === "custom";
-    await configStore.setTheme(theme, config.custom_theme_colors);
+    await configStore.setTheme(theme);
  }

-  function handleCustomColorChange(key: keyof CustomThemeColors, value: string) {
-    config.custom_theme_colors = {
-      ...config.custom_theme_colors,
-      [key]: value || null,
-    };
-    // Live preview
-    if (config.theme === "custom") {
-      applyCustomThemeColors(config.custom_theme_colors);
-    }
-  }
-
-  // Default dark theme colors for color picker defaults
-  const defaultDarkColors: Required<Record<keyof CustomThemeColors, string>> = {
-    bg_primary: "#1a1a2e",
-    bg_secondary: "#16213e",
-    bg_terminal: "#0f0f1a",
-    accent_primary: "#e94560",
-    accent_secondary: "#ff6b9d",
-    text_primary: "#ffffff",
-    text_secondary: "#a0a0a0",
-    border_color: "#2a2a4a",
-  };
-
  function toggleTool(tool: string) {
    if (config.auto_granted_tools.includes(tool)) {
      config.auto_granted_tools = config.auto_granted_tools.filter((t) => t !== tool);
@@ -458,12 +417,11 @@

      <!-- Theme Selection -->
      <div class="mb-4">
-        <span class="block text-sm text-[var(--text-secondary)] mb-2">Theme</span>
-        <div class="flex flex-wrap gap-2" role="group" aria-label="Theme selection">
+        <label class="block text-sm text-[var(--text-secondary)] mb-2">Theme</label>
+        <div class="flex gap-2">
          <button
            onclick={() => handleThemeChange("dark")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
-            'dark'
+            class="flex-1 px-3 py-2 rounded-lg border transition-colors {config.theme === 'dark'
              ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
              : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
          >
@@ -471,8 +429,7 @@
          </button>
          <button
            onclick={() => handleThemeChange("light")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
-            'light'
+            class="flex-1 px-3 py-2 rounded-lg border transition-colors {config.theme === 'light'
              ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
              : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
          >
@@ -480,178 +437,17 @@
          </button>
          <button
            onclick={() => handleThemeChange("high-contrast")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
+            class="flex-1 px-3 py-2 rounded-lg border transition-colors {config.theme ===
            'high-contrast'
              ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
              : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
            title="High contrast mode for improved accessibility"
          >
-            Contrast
-          </button>
-          <button
-            onclick={() => handleThemeChange("custom")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
-            'custom'
-              ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
-              : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
-            title="Create your own custom theme"
-          >
-            Custom
+            High Contrast
          </button>
        </div>
      </div>

-      <!-- Custom Theme Editor -->
-      {#if config.theme === "custom" || showCustomThemeEditor}
-        <div class="mb-4 p-3 bg-[var(--bg-primary)] rounded-lg border border-[var(--border-color)]">
-          <h4 class="text-sm font-medium text-[var(--text-primary)] mb-3">Custom Theme Colors</h4>
-          <div class="grid grid-cols-2 gap-3">
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-bg-primary"
-                >Background</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-bg-primary"
-                  type="color"
-                  value={config.custom_theme_colors.bg_primary || defaultDarkColors.bg_primary}
-                  oninput={(e) => handleCustomColorChange("bg_primary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.bg_primary || defaultDarkColors.bg_primary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-bg-secondary"
-                >Secondary BG</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-bg-secondary"
-                  type="color"
-                  value={config.custom_theme_colors.bg_secondary || defaultDarkColors.bg_secondary}
-                  oninput={(e) => handleCustomColorChange("bg_secondary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.bg_secondary || defaultDarkColors.bg_secondary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-bg-terminal"
-                >Terminal BG</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-bg-terminal"
-                  type="color"
-                  value={config.custom_theme_colors.bg_terminal || defaultDarkColors.bg_terminal}
-                  oninput={(e) => handleCustomColorChange("bg_terminal", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.bg_terminal || defaultDarkColors.bg_terminal}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-border">Border</label>
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-border"
-                  type="color"
-                  value={config.custom_theme_colors.border_color || defaultDarkColors.border_color}
-                  oninput={(e) => handleCustomColorChange("border_color", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.border_color || defaultDarkColors.border_color}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-accent-primary"
-                >Accent Primary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-accent-primary"
-                  type="color"
-                  value={config.custom_theme_colors.accent_primary ||
-                    defaultDarkColors.accent_primary}
-                  oninput={(e) => handleCustomColorChange("accent_primary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.accent_primary || defaultDarkColors.accent_primary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-accent-secondary"
-                >Accent Secondary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-accent-secondary"
-                  type="color"
-                  value={config.custom_theme_colors.accent_secondary ||
-                    defaultDarkColors.accent_secondary}
-                  oninput={(e) =>
-                    handleCustomColorChange("accent_secondary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.accent_secondary ||
-                    defaultDarkColors.accent_secondary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-text-primary"
-                >Text Primary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-text-primary"
-                  type="color"
-                  value={config.custom_theme_colors.text_primary || defaultDarkColors.text_primary}
-                  oninput={(e) => handleCustomColorChange("text_primary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.text_primary || defaultDarkColors.text_primary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-text-secondary"
-                >Text Secondary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-text-secondary"
-                  type="color"
-                  value={config.custom_theme_colors.text_secondary ||
-                    defaultDarkColors.text_secondary}
-                  oninput={(e) => handleCustomColorChange("text_secondary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.text_secondary || defaultDarkColors.text_secondary}
-                </span>
-              </div>
-            </div>
-          </div>
-          <p class="text-xs text-[var(--text-tertiary)] mt-3">
-            Changes preview live. Click Save Settings to persist.
-          </p>
-        </div>
-      {/if}
-
      <!-- Font Size -->
      <div class="mb-4">
        <label for="font-size" class="block text-sm text-[var(--text-secondary)] mb-2">
@@ -865,39 +661,4 @@
    background: var(--text-tertiary);
    cursor: not-allowed;
  }
-
-  /* Color picker styling */
-  .color-input-group {
-    display: flex;
-    flex-direction: column;
-    gap: 0.25rem;
-  }
-
-  .color-picker {
-    width: 32px;
-    height: 32px;
-    padding: 0;
-    border: 2px solid var(--border-color);
-    border-radius: 6px;
-    cursor: pointer;
-    background: transparent;
-  }
-
-  .color-picker::-webkit-color-swatch-wrapper {
-    padding: 2px;
-  }
-
-  .color-picker::-webkit-color-swatch {
-    border-radius: 4px;
-    border: none;
-  }
-
-  .color-picker::-moz-color-swatch {
-    border-radius: 4px;
-    border: none;
-  }
-
-  .color-picker:hover {
-    border-color: var(--accent-primary);
-  }
 </style>
@@ -279,15 +279,8 @@
 <svelte:window on:keydown={handleKeydown} />

 {#if isOpen}
-  <!-- svelte-ignore a11y_click_events_have_key_events -->
  <div class="git-panel-overlay" on:click={onClose} role="presentation">
-    <div
-      class="git-panel"
-      on:click|stopPropagation
-      role="dialog"
-      aria-label="Git Panel"
-      tabindex="-1"
-    >
+    <div class="git-panel" on:click|stopPropagation role="dialog" aria-label="Git Panel">
      <div class="git-panel-header">
        <h2>🔀 Git</h2>
        <button class="close-btn" on:click={onClose} title="Close (Esc)">✕</button>
@@ -587,15 +580,8 @@
  </div>

  {#if showDiff}
-    <!-- svelte-ignore a11y_click_events_have_key_events -->
    <div class="diff-overlay" on:click={() => (showDiff = false)} role="presentation">
-      <div
-        class="diff-modal"
-        on:click|stopPropagation
-        role="dialog"
-        aria-label="Diff View"
-        tabindex="-1"
-      >
+      <div class="diff-modal" on:click|stopPropagation role="dialog" aria-label="Diff View">
        <div class="diff-header">
          <h3>📄 {diffFile}</h3>
          <button on:click={() => (showDiff = false)} title="Close">✕</button>
@@ -952,6 +938,10 @@
    cursor: pointer;
  }

+  .new-branch-input button:first-of-type {
+    /* Styling handled by btn-trans-gradient class */
+  }
+
  .new-branch-input button:last-of-type {
    background: var(--bg-tertiary);
    color: var(--text-primary);
@@ -1,929 +0,0 @@
-<script lang="ts">
-  import { configStore, type HikariConfig } from "$lib/stores/config";
-  import { formattedStats } from "$lib/stores/stats";
-  import { achievementsStore } from "$lib/stores/achievements";
-  import { open, save } from "@tauri-apps/plugin-dialog";
-  import { writeFile, readFile } from "@tauri-apps/plugin-fs";
-
-  export let onClose: () => void;
-
-  let config: HikariConfig;
-  configStore.config.subscribe((c) => (config = c));
-
-  let editingName = false;
-  let editingBio = false;
-  let nameInput = "";
-  let bioInput = "";
-  let avatarDataUrl: string | null = null;
-
-  // Initialize inputs when config is loaded
-  $: if (config) {
-    if (!editingName) nameInput = config.profile_name || "";
-    if (!editingBio) bioInput = config.profile_bio || "";
-  }
-
-  // Load avatar on mount and when path changes
-  let lastLoadedPath: string | null = null;
-
-  async function updateAvatarDisplay(path: string | null) {
-    if (path === lastLoadedPath) return;
-    lastLoadedPath = path;
-    if (path) {
-      avatarDataUrl = await loadAvatarAsDataUrl(path);
-    } else {
-      avatarDataUrl = null;
-    }
-  }
-
-  $: updateAvatarDisplay(config?.profile_avatar_path ?? null);
-
-  let isGeneratingImage = false;
-
-  $: unlockedCount = Object.values($achievementsStore.achievements).filter(
-    (a) => a.unlocked
-  ).length;
-  $: totalAchievements = Object.values($achievementsStore.achievements).length;
-  $: achievementPercentage =
-    totalAchievements > 0 ? Math.round((unlockedCount / totalAchievements) * 100) : 0;
-
-  async function selectAvatar() {
-    try {
-      const selected = await open({
-        multiple: false,
-        filters: [
-          {
-            name: "Images",
-            extensions: ["png", "jpg", "jpeg", "gif", "webp"],
-          },
-        ],
-      });
-
-      if (selected && typeof selected === "string") {
-        await configStore.updateConfig({ profile_avatar_path: selected });
-      }
-    } catch (error) {
-      console.error("Failed to select avatar:", error);
-    }
-  }
-
-  async function removeAvatar() {
-    await configStore.updateConfig({ profile_avatar_path: null });
-  }
-
-  async function saveName() {
-    await configStore.updateConfig({ profile_name: nameInput || null });
-    editingName = false;
-  }
-
-  async function saveBio() {
-    await configStore.updateConfig({ profile_bio: bioInput || null });
-    editingBio = false;
-  }
-
-  async function loadAvatarAsDataUrl(path: string): Promise<string | null> {
-    try {
-      const data = await readFile(path);
-      const extension = path.split(".").pop()?.toLowerCase() || "png";
-      const mimeType =
-        extension === "jpg" || extension === "jpeg"
-          ? "image/jpeg"
-          : extension === "gif"
-            ? "image/gif"
-            : extension === "webp"
-              ? "image/webp"
-              : "image/png";
-      // Convert Uint8Array to base64 in chunks to avoid stack overflow
-      const blob = new Blob([data], { type: mimeType });
-      return new Promise((resolve) => {
-        const reader = new FileReader();
-        reader.onloadend = () => resolve(reader.result as string);
-        reader.onerror = () => resolve(null);
-        reader.readAsDataURL(blob);
-      });
-    } catch (error) {
-      console.error("Failed to load avatar:", error);
-      return null;
-    }
-  }
-
-  async function generateShareImage(): Promise<Blob> {
-    const canvas = document.createElement("canvas");
-    const ctx = canvas.getContext("2d")!;
-
-    // Card dimensions (1080p for sharing)
-    const width = 1920;
-    const height = 1080;
-    canvas.width = width;
-    canvas.height = height;
-
-    // Background gradient (dark theme)
-    const bgGradient = ctx.createLinearGradient(0, 0, width, height);
-    bgGradient.addColorStop(0, "#1a1a2e");
-    bgGradient.addColorStop(1, "#16213e");
-    ctx.fillStyle = bgGradient;
-    ctx.fillRect(0, 0, width, height);
-
-    // Trans flag stripe accent at top
-    const stripeHeight = 25;
-    const stripeColors = ["#5bcefa", "#f5a9b8", "#ffffff", "#f5a9b8", "#5bcefa"];
-    stripeColors.forEach((color, i) => {
-      ctx.fillStyle = color;
-      ctx.fillRect(0, i * (stripeHeight / 5) * 2, width, (stripeHeight / 5) * 2);
-    });
-
-    // Border
-    ctx.strokeStyle = "#5bcefa";
-    ctx.lineWidth = 6;
-    ctx.strokeRect(3, 3, width - 6, height - 6);
-
-    // Avatar circle
-    const avatarX = 200;
-    const avatarY = 220;
-    const avatarRadius = 140;
-
-    ctx.save();
-    ctx.beginPath();
-    ctx.arc(avatarX, avatarY, avatarRadius, 0, Math.PI * 2);
-    ctx.closePath();
-    ctx.clip();
-
-    // Draw avatar if available, otherwise gradient placeholder
-    let avatarLoaded = false;
-    if (config.profile_avatar_path) {
-      try {
-        const dataUrl = await loadAvatarAsDataUrl(config.profile_avatar_path);
-        if (dataUrl) {
-          const img = new Image();
-          await new Promise<void>((resolve, reject) => {
-            img.onload = () => resolve();
-            img.onerror = () => reject();
-            img.src = dataUrl;
-          });
-          ctx.drawImage(
-            img,
-            avatarX - avatarRadius,
-            avatarY - avatarRadius,
-            avatarRadius * 2,
-            avatarRadius * 2
-          );
-          avatarLoaded = true;
-        }
-      } catch {
-        // Will use fallback gradient
-      }
-    }
-
-    if (!avatarLoaded) {
-      const avatarGradient = ctx.createLinearGradient(
-        avatarX - avatarRadius,
-        avatarY - avatarRadius,
-        avatarX + avatarRadius,
-        avatarY + avatarRadius
-      );
-      avatarGradient.addColorStop(0, "#5bcefa");
-      avatarGradient.addColorStop(0.5, "#f5a9b8");
-      avatarGradient.addColorStop(1, "#5bcefa");
-      ctx.fillStyle = avatarGradient;
-      ctx.fillRect(
-        avatarX - avatarRadius,
-        avatarY - avatarRadius,
-        avatarRadius * 2,
-        avatarRadius * 2
-      );
-    }
-    ctx.restore();
-
-    // Avatar border
-    ctx.beginPath();
-    ctx.arc(avatarX, avatarY, avatarRadius + 6, 0, Math.PI * 2);
-    ctx.strokeStyle = "#f5a9b8";
-    ctx.lineWidth = 8;
-    ctx.stroke();
-
-    // Name
-    ctx.fillStyle = "#ffffff";
-    ctx.font = "bold 72px system-ui, -apple-system, sans-serif";
-    ctx.fillText(config.profile_name || "Hikari User", 400, 180);
-
-    // Bio (truncated)
-    ctx.fillStyle = "#9ca3af";
-    ctx.font = "36px system-ui, -apple-system, sans-serif";
-    const bio = config.profile_bio || "A Hikari Desktop user";
-    const truncatedBio = bio.length > 100 ? bio.substring(0, 97) + "..." : bio;
-    ctx.fillText(truncatedBio, 400, 260);
-
-    // Stats section
-    const statsY = 420;
-    ctx.fillStyle = "#6b7280";
-    ctx.font = "bold 32px system-ui, -apple-system, sans-serif";
-    ctx.fillText("LIFETIME STATS", 80, statsY);
-
-    // Stats grid
-    const stats = [
-      { label: "Messages", value: $formattedStats.messagesTotal },
-      { label: "Tokens", value: $formattedStats.totalTokens },
-      { label: "Code Blocks", value: $formattedStats.codeBlocksTotal },
-      { label: "Files Edited", value: $formattedStats.filesEditedTotal },
-      { label: "Files Created", value: $formattedStats.filesCreatedTotal },
-      { label: "Total Cost", value: $formattedStats.totalCost },
-    ];
-
-    const statBoxWidth = 540;
-    const statBoxHeight = 160;
-    const statsPerRow = 3;
-    const startX = 80;
-    const startY = statsY + 40;
-
-    stats.forEach((stat, i) => {
-      const row = Math.floor(i / statsPerRow);
-      const col = i % statsPerRow;
-      const x = startX + col * (statBoxWidth + 50);
-      const y = startY + row * (statBoxHeight + 30);
-
-      // Stat box background
-      ctx.fillStyle = "rgba(255, 255, 255, 0.05)";
-      ctx.beginPath();
-      ctx.roundRect(x, y, statBoxWidth, statBoxHeight, 20);
-      ctx.fill();
-
-      // Stat value
-      ctx.fillStyle = "#5bcefa";
-      ctx.font = "bold 56px system-ui, -apple-system, sans-serif";
-      ctx.fillText(stat.value, x + 32, y + 75);
-
-      // Stat label
-      ctx.fillStyle = "#9ca3af";
-      ctx.font = "28px system-ui, -apple-system, sans-serif";
-      ctx.fillText(stat.label.toUpperCase(), x + 32, y + 128);
-    });
-
-    // Achievement progress
-    const achieveY = 870;
-    ctx.fillStyle = "#6b7280";
-    ctx.font = "bold 32px system-ui, -apple-system, sans-serif";
-    ctx.fillText("ACHIEVEMENTS", 80, achieveY);
-
-    // Progress bar background
-    const progressX = 80;
-    const progressY = achieveY + 30;
-    const progressWidth = 1200;
-    const progressHeight = 44;
-
-    ctx.fillStyle = "rgba(255, 255, 255, 0.1)";
-    ctx.beginPath();
-    ctx.roundRect(progressX, progressY, progressWidth, progressHeight, 22);
-    ctx.fill();
-
-    // Progress bar fill
-    const progressGradient = ctx.createLinearGradient(progressX, 0, progressX + progressWidth, 0);
-    progressGradient.addColorStop(0, "#5bcefa");
-    progressGradient.addColorStop(0.5, "#f5a9b8");
-    progressGradient.addColorStop(1, "#5bcefa");
-    ctx.fillStyle = progressGradient;
-    ctx.beginPath();
-    ctx.roundRect(
-      progressX,
-      progressY,
-      progressWidth * (achievementPercentage / 100),
-      progressHeight,
-      22
-    );
-    ctx.fill();
-
-    // Progress text
-    ctx.fillStyle = "#ffffff";
-    ctx.font = "bold 36px system-ui, -apple-system, sans-serif";
-    ctx.fillText(
-      `${unlockedCount} / ${totalAchievements} (${achievementPercentage}%)`,
-      progressX + progressWidth + 40,
-      progressY + 34
-    );
-
-    // Hikari branding
-    ctx.fillStyle = "#f5a9b8";
-    ctx.font = "bold 42px system-ui, -apple-system, sans-serif";
-    ctx.fillText("✨ Hikari Desktop", 80, height - 100);
-
-    // Discord promo
-    ctx.fillStyle = "#9ca3af";
-    ctx.font = "34px system-ui, -apple-system, sans-serif";
-    ctx.fillText("Join our community: chat.nhcarrigan.com", 80, height - 45);
-
-    // Convert canvas to blob
-    return new Promise((resolve) => {
-      canvas.toBlob((blob) => resolve(blob!), "image/png");
-    });
-  }
-
-  async function shareProfile() {
-    isGeneratingImage = true;
-    try {
-      const blob = await generateShareImage();
-      const arrayBuffer = await blob.arrayBuffer();
-      const uint8Array = new Uint8Array(arrayBuffer);
-
-      const filePath = await save({
-        filters: [{ name: "PNG Image", extensions: ["png"] }],
-        defaultPath: `hikari-profile-${config.profile_name?.replace(/\s+/g, "-").toLowerCase() || "user"}.png`,
-      });
-
-      if (filePath) {
-        await writeFile(filePath, uint8Array);
-      }
-    } catch (error) {
-      console.error("Failed to generate share image:", error);
-    } finally {
-      isGeneratingImage = false;
-    }
-  }
-</script>
-
-<div class="profile-overlay" role="dialog" aria-modal="true">
-  <div class="profile-panel">
-    <div class="profile-header">
-      <h2>Profile</h2>
-      <button class="close-btn" on:click={onClose} aria-label="Close profile">
-        <svg
-          width="20"
-          height="20"
-          viewBox="0 0 24 24"
-          fill="none"
-          stroke="currentColor"
-          stroke-width="2"
-        >
-          <path d="M18 6L6 18M6 6l12 12" />
-        </svg>
-      </button>
-    </div>
-
-    <div class="profile-content">
-      <!-- Avatar Section -->
-      <div class="avatar-section">
-        <div
-          class="avatar-container"
-          on:click={selectAvatar}
-          role="button"
-          tabindex="0"
-          on:keydown={(e) => e.key === "Enter" && selectAvatar()}
-        >
-          {#if avatarDataUrl}
-            <img src={avatarDataUrl} alt="Profile avatar" class="avatar-image" />
-            <div class="avatar-overlay">
-              <span>Change</span>
-            </div>
-          {:else}
-            <div class="avatar-placeholder">
-              <svg
-                width="48"
-                height="48"
-                viewBox="0 0 24 24"
-                fill="none"
-                stroke="currentColor"
-                stroke-width="1.5"
-              >
-                <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" />
-                <circle cx="12" cy="7" r="4" />
-              </svg>
-              <span>Add Photo</span>
-            </div>
-          {/if}
-        </div>
-        {#if config.profile_avatar_path}
-          <button class="remove-avatar-btn" on:click={removeAvatar}>Remove Photo</button>
-        {/if}
-      </div>
-
-      <!-- Name Section -->
-      <div class="name-section">
-        {#if editingName}
-          <input
-            type="text"
-            bind:value={nameInput}
-            placeholder="Enter your name"
-            class="name-input"
-            on:keydown={(e) => e.key === "Enter" && saveName()}
-            on:blur={saveName}
-          />
-        {:else}
-          <button
-            class="name-display"
-            on:click={() => {
-              editingName = true;
-              nameInput = config.profile_name || "";
-            }}
-          >
-            <span class="name-text">{config.profile_name || "Click to add name"}</span>
-            <svg
-              width="16"
-              height="16"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              stroke-width="2"
-            >
-              <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
-              <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" />
-            </svg>
-          </button>
-        {/if}
-      </div>
-
-      <!-- Bio Section -->
-      <div class="bio-section">
-        <h3>Bio</h3>
-        {#if editingBio}
-          <textarea
-            bind:value={bioInput}
-            placeholder="Tell us about yourself..."
-            class="bio-input"
-            rows="3"
-            on:blur={saveBio}
-          ></textarea>
-          <button class="save-bio-btn btn-trans-gradient" on:click={saveBio}>Save</button>
-        {:else}
-          <button
-            class="bio-display"
-            on:click={() => {
-              editingBio = true;
-              bioInput = config.profile_bio || "";
-            }}
-          >
-            <span class="bio-text">{config.profile_bio || "Click to add a bio..."}</span>
-          </button>
-        {/if}
-      </div>
-
-      <!-- Stats Section -->
-      <div class="stats-section">
-        <h3>Lifetime Stats</h3>
-        <div class="stats-grid">
-          <div class="stat-card">
-            <span class="stat-value">{$formattedStats.messagesTotal}</span>
-            <span class="stat-label">Messages</span>
-          </div>
-          <div class="stat-card">
-            <span class="stat-value">{$formattedStats.totalTokens}</span>
-            <span class="stat-label">Tokens</span>
-          </div>
-          <div class="stat-card">
-            <span class="stat-value">{$formattedStats.codeBlocksTotal}</span>
-            <span class="stat-label">Code Blocks</span>
-          </div>
-          <div class="stat-card">
-            <span class="stat-value">{$formattedStats.filesEditedTotal}</span>
-            <span class="stat-label">Files Edited</span>
-          </div>
-          <div class="stat-card">
-            <span class="stat-value">{$formattedStats.filesCreatedTotal}</span>
-            <span class="stat-label">Files Created</span>
-          </div>
-          <div class="stat-card">
-            <span class="stat-value">{$formattedStats.totalCost}</span>
-            <span class="stat-label">Total Cost</span>
-          </div>
-        </div>
-      </div>
-
-      <!-- Achievements Section -->
-      <div class="achievements-section">
-        <h3>Achievements</h3>
-        <div class="achievement-progress">
-          <div class="progress-bar">
-            <div class="progress-fill" style="width: {achievementPercentage}%"></div>
-          </div>
-          <span class="progress-text"
-            >{unlockedCount} / {totalAchievements} ({achievementPercentage}%)</span
-          >
-        </div>
-      </div>
-
-      <!-- Share Section -->
-      <div class="share-section">
-        <button
-          class="share-btn btn-trans-gradient"
-          on:click={shareProfile}
-          disabled={isGeneratingImage}
-        >
-          {#if isGeneratingImage}
-            <span class="spinner"></span>
-            Generating...
-          {:else}
-            <svg
-              width="18"
-              height="18"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              stroke-width="2"
-            >
-              <path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8" />
-              <polyline points="16 6 12 2 8 6" />
-              <line x1="12" y1="2" x2="12" y2="15" />
-            </svg>
-            Share Profile
-          {/if}
-        </button>
-        <p class="share-hint">Generate a shareable image of your profile</p>
-      </div>
-    </div>
-  </div>
-</div>
-
-<style>
-  .profile-overlay {
-    position: fixed;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background: rgba(0, 0, 0, 0.7);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    z-index: 1000;
-    backdrop-filter: blur(4px);
-  }
-
-  .profile-panel {
-    background: var(--bg-secondary);
-    border-radius: 16px;
-    width: 90%;
-    max-width: 480px;
-    max-height: 85vh;
-    overflow-y: auto;
-    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
-    border: 1px solid var(--border-color);
-  }
-
-  .profile-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    padding: 20px 24px;
-    border-bottom: 1px solid var(--border-color);
-    position: sticky;
-    top: 0;
-    background: var(--bg-secondary);
-    z-index: 1;
-  }
-
-  .profile-header h2 {
-    margin: 0;
-    font-size: 20px;
-    font-weight: 600;
-    color: var(--text-primary);
-  }
-
-  .close-btn {
-    background: none;
-    border: none;
-    color: var(--text-secondary);
-    cursor: pointer;
-    padding: 4px;
-    border-radius: 4px;
-    transition: all 0.2s;
-  }
-
-  .close-btn:hover {
-    background: var(--bg-tertiary);
-    color: var(--text-primary);
-  }
-
-  .profile-content {
-    padding: 24px;
-    display: flex;
-    flex-direction: column;
-    gap: 24px;
-  }
-
-  /* Avatar */
-  .avatar-section {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    gap: 12px;
-  }
-
-  .avatar-container {
-    width: 120px;
-    height: 120px;
-    border-radius: 50%;
-    overflow: hidden;
-    cursor: pointer;
-    position: relative;
-    background: var(--bg-tertiary);
-    border: 3px solid var(--trans-pink);
-    box-shadow: 0 0 20px rgba(245, 169, 184, 0.3);
-    transition: all 0.3s;
-  }
-
-  .avatar-container:hover {
-    border-color: var(--trans-blue);
-    box-shadow: 0 0 30px rgba(91, 206, 250, 0.4);
-    transform: scale(1.02);
-  }
-
-  .avatar-image {
-    width: 100%;
-    height: 100%;
-    object-fit: cover;
-  }
-
-  .avatar-overlay {
-    position: absolute;
-    inset: 0;
-    background: rgba(0, 0, 0, 0.6);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-    transition: opacity 0.2s;
-    color: white;
-    font-size: 14px;
-    font-weight: 500;
-  }
-
-  .avatar-container:hover .avatar-overlay {
-    opacity: 1;
-  }
-
-  .avatar-placeholder {
-    width: 100%;
-    height: 100%;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    gap: 8px;
-    color: var(--text-secondary);
-  }
-
-  .avatar-placeholder span {
-    font-size: 12px;
-  }
-
-  .remove-avatar-btn {
-    background: none;
-    border: none;
-    color: var(--text-secondary);
-    font-size: 12px;
-    cursor: pointer;
-    text-decoration: underline;
-  }
-
-  .remove-avatar-btn:hover {
-    color: var(--trans-pink);
-  }
-
-  /* Name */
-  .name-section {
-    text-align: center;
-  }
-
-  .name-display {
-    display: inline-flex;
-    align-items: center;
-    gap: 8px;
-    background: none;
-    border: none;
-    cursor: pointer;
-    padding: 8px 16px;
-    border-radius: 8px;
-    transition: all 0.2s;
-  }
-
-  .name-display:hover {
-    background: var(--bg-tertiary);
-  }
-
-  .name-display svg {
-    color: var(--text-secondary);
-    opacity: 0;
-    transition: opacity 0.2s;
-  }
-
-  .name-display:hover svg {
-    opacity: 1;
-  }
-
-  .name-text {
-    font-size: 24px;
-    font-weight: 600;
-    color: var(--text-primary);
-  }
-
-  .name-input {
-    width: 100%;
-    max-width: 300px;
-    padding: 12px 16px;
-    font-size: 24px;
-    font-weight: 600;
-    text-align: center;
-    background: var(--bg-tertiary);
-    border: 2px solid var(--trans-pink);
-    border-radius: 8px;
-    color: var(--text-primary);
-    outline: none;
-  }
-
-  .name-input:focus {
-    border-color: var(--trans-blue);
-    box-shadow: 0 0 10px rgba(91, 206, 250, 0.3);
-  }
-
-  /* Bio */
-  .bio-section h3,
-  .stats-section h3,
-  .achievements-section h3 {
-    margin: 0 0 12px;
-    font-size: 14px;
-    font-weight: 600;
-    color: var(--text-secondary);
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-  }
-
-  .bio-display {
-    width: 100%;
-    text-align: left;
-    background: var(--bg-tertiary);
-    border: 1px solid transparent;
-    border-radius: 8px;
-    padding: 12px;
-    cursor: pointer;
-    transition: all 0.2s;
-  }
-
-  .bio-display:hover {
-    border-color: var(--border-color);
-  }
-
-  .bio-text {
-    color: var(--text-secondary);
-    font-size: 14px;
-    line-height: 1.5;
-  }
-
-  .bio-input {
-    width: 100%;
-    padding: 12px;
-    font-size: 14px;
-    background: var(--bg-tertiary);
-    border: 2px solid var(--trans-pink);
-    border-radius: 8px;
-    color: var(--text-primary);
-    resize: none;
-    outline: none;
-    font-family: inherit;
-  }
-
-  .bio-input:focus {
-    border-color: var(--trans-blue);
-    box-shadow: 0 0 10px rgba(91, 206, 250, 0.3);
-  }
-
-  .save-bio-btn {
-    margin-top: 8px;
-    padding: 8px 16px;
-    border: none;
-    border-radius: 6px;
-    cursor: pointer;
-    font-size: 14px;
-    font-weight: 500;
-  }
-
-  /* Stats */
-  .stats-grid {
-    display: grid;
-    grid-template-columns: repeat(3, 1fr);
-    gap: 12px;
-  }
-
-  .stat-card {
-    background: var(--bg-tertiary);
-    border-radius: 12px;
-    padding: 16px 12px;
-    text-align: center;
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-    border: 1px solid var(--border-color);
-  }
-
-  .stat-value {
-    font-size: 20px;
-    font-weight: 700;
-    color: var(--text-primary);
-    background: linear-gradient(135deg, var(--trans-blue), var(--trans-pink));
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
-  }
-
-  .stat-label {
-    font-size: 11px;
-    color: var(--text-secondary);
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-  }
-
-  /* Achievements */
-  .achievement-progress {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-  }
-
-  .progress-bar {
-    height: 12px;
-    background: var(--bg-tertiary);
-    border-radius: 6px;
-    overflow: hidden;
-    border: 1px solid var(--border-color);
-  }
-
-  .progress-fill {
-    height: 100%;
-    background: linear-gradient(
-      90deg,
-      var(--trans-blue),
-      var(--trans-pink),
-      var(--trans-white),
-      var(--trans-pink),
-      var(--trans-blue)
-    );
-    background-size: 200% 100%;
-    animation: shimmer 3s linear infinite;
-    border-radius: 6px;
-    transition: width 0.5s ease;
-  }
-
-  @keyframes shimmer {
-    0% {
-      background-position: 200% 0;
-    }
-    100% {
-      background-position: -200% 0;
-    }
-  }
-
-  .progress-text {
-    font-size: 14px;
-    color: var(--text-secondary);
-    text-align: center;
-  }
-
-  /* Share */
-  .share-section {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    gap: 8px;
-    padding-top: 8px;
-    border-top: 1px solid var(--border-color);
-  }
-
-  .share-btn {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    gap: 8px;
-    padding: 12px 24px;
-    border: none;
-    border-radius: 8px;
-    cursor: pointer;
-    font-size: 15px;
-    font-weight: 600;
-    transition: all 0.2s;
-  }
-
-  .share-btn:disabled {
-    opacity: 0.7;
-    cursor: not-allowed;
-  }
-
-  .share-btn svg {
-    flex-shrink: 0;
-  }
-
-  .share-hint {
-    margin: 0;
-    font-size: 12px;
-    color: var(--text-secondary);
-  }
-
-  .spinner {
-    width: 16px;
-    height: 16px;
-    border: 2px solid transparent;
-    border-top-color: currentColor;
-    border-radius: 50%;
-    animation: spin 0.8s linear infinite;
-  }
-
-  @keyframes spin {
-    to {
-      transform: rotate(360deg);
-    }
-  }
-</style>
@@ -449,7 +449,6 @@
  .line-clamp-2 {
    display: -webkit-box;
    -webkit-line-clamp: 2;
-    line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
  }
@@ -469,7 +469,6 @@
  .line-clamp-2 {
    display: -webkit-box;
    -webkit-line-clamp: 2;
-    line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
  }
@@ -460,7 +460,6 @@
  .line-clamp-2 {
    display: -webkit-box;
    -webkit-line-clamp: 2;
-    line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
  }
@@ -14,6 +14,7 @@
  <div class="stats-row">
    <span class="stat-label">Messages:</span>
    <span class="stat-value">{$formattedStats.messagesSession}</span>
+    <span class="stat-secondary">/ {$formattedStats.messagesTotal}</span>
  </div>

  <div class="stats-section">
@@ -31,6 +32,11 @@
      <span class="stat-label">Output:</span>
      <span class="stat-value">{$formattedStats.sessionOutputTokens}</span>
    </div>
+    <div class="stat-row stat-highlight">
+      <span class="stat-label">Total:</span>
+      <span class="stat-value">{$formattedStats.totalTokens}</span>
+      <span class="stat-cost">{$formattedStats.totalCost}</span>
+    </div>
  </div>

  <div class="stats-section">
@@ -38,14 +44,17 @@
    <div class="stat-row">
      <span class="stat-label">Code blocks:</span>
      <span class="stat-value">{$formattedStats.codeBlocksSession}</span>
+      <span class="stat-secondary">/ {$formattedStats.codeBlocksTotal}</span>
    </div>
    <div class="stat-row">
      <span class="stat-label">Files edited:</span>
      <span class="stat-value">{$formattedStats.filesEditedSession}</span>
+      <span class="stat-secondary">/ {$formattedStats.filesEditedTotal}</span>
    </div>
    <div class="stat-row">
      <span class="stat-label">Files created:</span>
      <span class="stat-value">{$formattedStats.filesCreatedSession}</span>
+      <span class="stat-secondary">/ {$formattedStats.filesCreatedTotal}</span>
    </div>
  </div>

@@ -119,6 +128,14 @@
    opacity: 0.8;
  }

+  .stat-highlight {
+    font-weight: 600;
+    color: var(--accent-primary);
+    margin-top: 0.25rem;
+    padding-top: 0.25rem;
+    border-top: 1px solid var(--border-color);
+  }
+
  .stat-label {
    color: var(--text-secondary, #9ca3af);
  }
@@ -22,7 +22,6 @@
  import { achievementProgress } from "$lib/stores/achievements";
  import SessionHistoryPanel from "./SessionHistoryPanel.svelte";
  import GitPanel from "./GitPanel.svelte";
-  import ProfilePanel from "./ProfilePanel.svelte";

  const DISCORD_URL = "https://chat.nhcarrigan.com";
  const DONATE_URL = "https://donate.nhcarrigan.com";
@@ -39,7 +38,6 @@
  let showKeyboardShortcuts = $state(false);
  let showSessionHistory = $state(false);
  let showGitPanel = $state(false);
-  let showProfile = $state(false);
  const progress = $derived($achievementProgress);
  let currentConfig: HikariConfig = $state({
    model: null,
@@ -60,19 +58,6 @@
    streamer_mode: false,
    streamer_hide_paths: false,
    compact_mode: false,
-    profile_name: null,
-    profile_avatar_path: null,
-    profile_bio: null,
-    custom_theme_colors: {
-      bg_primary: null,
-      bg_secondary: null,
-      bg_terminal: null,
-      accent_primary: null,
-      accent_secondary: null,
-      text_primary: null,
-      text_secondary: null,
-      border_color: null,
-    },
  });

  let streamerModeActive = $state(false);
@@ -237,20 +222,6 @@
        title="Streamer mode active (Ctrl+Shift+S to toggle)"
      ></div>
    {/if}
-    <button
-      onclick={() => (showProfile = true)}
-      class="p-1 text-gray-500 icon-trans-hover"
-      title="Profile"
-    >
-      <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path
-          stroke-linecap="round"
-          stroke-linejoin="round"
-          stroke-width="2"
-          d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z"
-        />
-      </svg>
-    </button>
    <button
      onclick={onToggleCompact}
      class="p-1 text-gray-500 icon-trans-hover"
@@ -467,7 +438,3 @@
 {#if showGitPanel}
  <GitPanel isOpen={showGitPanel} onClose={() => (showGitPanel = false)} />
 {/if}
-
-{#if showProfile}
-  <ProfilePanel onClose={() => (showProfile = false)} />
-{/if}
@@ -17,7 +17,7 @@
  hasQuestionPending.subscribe((pending) => {
    isVisible = pending;
    if (!pending) {
-      selectedOptions.clear();
+      selectedOptions = new SvelteSet();
      customAnswer = "";
      showCustomInput = false;
    }
@@ -1,329 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { NotificationType, NOTIFICATION_SOUNDS, type NotificationSound } from "./types";
-
-// Mock HTMLAudioElement for soundPlayer tests
-class MockAudioElement {
-  src: string = "";
-  preload: string = "";
-  volume: number = 1;
-
-  constructor(src?: string) {
-    if (src) this.src = src;
-  }
-
-  cloneNode(): MockAudioElement {
-    const clone = new MockAudioElement(this.src);
-    clone.volume = this.volume;
-    return clone;
-  }
-
-  async play(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-// Store original Audio before mocking
-const OriginalAudio = globalThis.Audio;
-
-describe("notifications", () => {
-  describe("NotificationType enum", () => {
-    it("has SUCCESS type", () => {
-      expect(NotificationType.SUCCESS).toBe("success");
-    });
-
-    it("has ERROR type", () => {
-      expect(NotificationType.ERROR).toBe("error");
-    });
-
-    it("has PERMISSION type", () => {
-      expect(NotificationType.PERMISSION).toBe("permission");
-    });
-
-    it("has CONNECTION type", () => {
-      expect(NotificationType.CONNECTION).toBe("connection");
-    });
-
-    it("has TASK_START type", () => {
-      expect(NotificationType.TASK_START).toBe("task_start");
-    });
-
-    it("has ACHIEVEMENT type", () => {
-      expect(NotificationType.ACHIEVEMENT).toBe("achievement");
-    });
-
-    it("has exactly 6 notification types", () => {
-      const types = Object.values(NotificationType);
-      expect(types.length).toBe(6);
-    });
-  });
-
-  describe("NOTIFICATION_SOUNDS constant", () => {
-    it("has sounds for all notification types", () => {
-      Object.values(NotificationType).forEach((type) => {
-        expect(NOTIFICATION_SOUNDS[type]).toBeDefined();
-      });
-    });
-
-    it("each sound has required properties", () => {
-      Object.values(NOTIFICATION_SOUNDS).forEach((sound) => {
-        expect(sound.type).toBeDefined();
-        expect(sound.filename).toBeDefined();
-        expect(sound.phrase).toBeDefined();
-        expect(typeof sound.filename).toBe("string");
-        expect(typeof sound.phrase).toBe("string");
-        expect(sound.filename.endsWith(".mp3")).toBe(true);
-      });
-    });
-
-    it("SUCCESS sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.SUCCESS];
-      expect(sound.type).toBe(NotificationType.SUCCESS);
-      expect(sound.filename).toBe("im-done.mp3");
-      expect(sound.phrase).toBe("I'm done!");
-      expect(sound.volume).toBe(0.7);
-    });
-
-    it("ERROR sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.ERROR];
-      expect(sound.type).toBe(NotificationType.ERROR);
-      expect(sound.filename).toBe("oh-no.mp3");
-      expect(sound.phrase).toBe("Oh no...");
-      expect(sound.volume).toBe(0.8);
-    });
-
-    it("PERMISSION sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.PERMISSION];
-      expect(sound.type).toBe(NotificationType.PERMISSION);
-      expect(sound.filename).toBe("access-please.mp3");
-      expect(sound.phrase).toBe("Access please!");
-      expect(sound.volume).toBe(0.9);
-    });
-
-    it("CONNECTION sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.CONNECTION];
-      expect(sound.type).toBe(NotificationType.CONNECTION);
-      expect(sound.filename).toBe("connected.mp3");
-      expect(sound.phrase).toBe("Connected!");
-      expect(sound.volume).toBe(0.7);
-    });
-
-    it("TASK_START sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.TASK_START];
-      expect(sound.type).toBe(NotificationType.TASK_START);
-      expect(sound.filename).toBe("working-on-it.mp3");
-      expect(sound.phrase).toBe("Working on it!");
-      expect(sound.volume).toBe(0.6);
-    });
-
-    it("ACHIEVEMENT sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.ACHIEVEMENT];
-      expect(sound.type).toBe(NotificationType.ACHIEVEMENT);
-      expect(sound.filename).toBe("achievement.mp3");
-      expect(sound.phrase).toBe("Achievement Get~!");
-      expect(sound.volume).toBe(0.8);
-    });
-
-    it("all volumes are within valid range (0-1)", () => {
-      Object.values(NOTIFICATION_SOUNDS).forEach((sound) => {
-        if (sound.volume !== undefined) {
-          expect(sound.volume).toBeGreaterThanOrEqual(0);
-          expect(sound.volume).toBeLessThanOrEqual(1);
-        }
-      });
-    });
-  });
-
-  describe("NotificationSound interface", () => {
-    it("can create a valid notification sound object", () => {
-      const sound: NotificationSound = {
-        type: NotificationType.SUCCESS,
-        filename: "test-sound.mp3",
-        phrase: "Test phrase",
-        volume: 0.5,
-      };
-
-      expect(sound.type).toBe(NotificationType.SUCCESS);
-      expect(sound.filename).toBe("test-sound.mp3");
-      expect(sound.phrase).toBe("Test phrase");
-      expect(sound.volume).toBe(0.5);
-    });
-
-    it("volume is optional", () => {
-      const sound: NotificationSound = {
-        type: NotificationType.ERROR,
-        filename: "error.mp3",
-        phrase: "Error occurred",
-      };
-
-      expect(sound.volume).toBeUndefined();
-    });
-  });
-
-  describe("SoundPlayer class", () => {
-    beforeEach(() => {
-      // Mock Audio constructor
-      globalThis.Audio = MockAudioElement as unknown as typeof Audio;
-    });
-
-    afterEach(() => {
-      // Restore original Audio
-      globalThis.Audio = OriginalAudio;
-      vi.resetModules();
-    });
-
-    it("can import soundPlayer singleton", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-      expect(soundPlayer).toBeDefined();
-    });
-
-    it("setEnabled changes enabled state", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      soundPlayer.setEnabled(true);
-      expect(soundPlayer.isEnabled()).toBe(true);
-
-      soundPlayer.setEnabled(false);
-      expect(soundPlayer.isEnabled()).toBe(false);
-    });
-
-    it("starts disabled by default", async () => {
-      // Need to reimport to get fresh instance behavior
-      // But since it's a singleton, we just test the method
-      const { soundPlayer } = await import("./soundPlayer");
-
-      // Reset to default state
-      soundPlayer.setEnabled(false);
-      expect(soundPlayer.isEnabled()).toBe(false);
-    });
-
-    it("setGlobalVolume clamps values to 0-1 range", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      // Test that it doesn't throw on edge cases
-      soundPlayer.setGlobalVolume(0);
-      soundPlayer.setGlobalVolume(1);
-      soundPlayer.setGlobalVolume(0.5);
-
-      // Test clamping below 0
-      soundPlayer.setGlobalVolume(-0.5);
-
-      // Test clamping above 1
-      soundPlayer.setGlobalVolume(1.5);
-    });
-
-    it("play returns early when disabled", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      soundPlayer.setEnabled(false);
-
-      // Should not throw when disabled
-      await expect(soundPlayer.play(NotificationType.SUCCESS)).resolves.toBeUndefined();
-    });
-
-    it("play attempts to play when enabled", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      soundPlayer.setEnabled(true);
-
-      // Should not throw
-      await expect(soundPlayer.play(NotificationType.SUCCESS)).resolves.toBeUndefined();
-    });
-  });
-
-  describe("NotificationManager class", () => {
-    beforeEach(() => {
-      globalThis.Audio = MockAudioElement as unknown as typeof Audio;
-      vi.resetModules();
-    });
-
-    afterEach(() => {
-      globalThis.Audio = OriginalAudio;
-    });
-
-    it("can import notificationManager singleton", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(notificationManager).toBeDefined();
-    });
-
-    it("has notifySuccess method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifySuccess).toBe("function");
-    });
-
-    it("has notifyError method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyError).toBe("function");
-    });
-
-    it("has notifyPermission method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyPermission).toBe("function");
-    });
-
-    it("has notifyConnection method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyConnection).toBe("function");
-    });
-
-    it("has notifyTaskStart method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyTaskStart).toBe("function");
-    });
-
-    it("has notify method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notify).toBe("function");
-    });
-  });
-
-  describe("notification sounds file paths", () => {
-    it("all sound files have valid paths", () => {
-      Object.values(NOTIFICATION_SOUNDS).forEach((sound) => {
-        // Check that filename doesn't contain path traversal
-        expect(sound.filename).not.toContain("..");
-        expect(sound.filename).not.toContain("/");
-        expect(sound.filename).not.toContain("\\");
-      });
-    });
-
-    it("sound filenames are unique", () => {
-      const filenames = Object.values(NOTIFICATION_SOUNDS).map((s) => s.filename);
-      const uniqueFilenames = new Set(filenames);
-      expect(uniqueFilenames.size).toBe(filenames.length);
-    });
-
-    it("phrases are unique", () => {
-      const phrases = Object.values(NOTIFICATION_SOUNDS).map((s) => s.phrase);
-      const uniquePhrases = new Set(phrases);
-      expect(uniquePhrases.size).toBe(phrases.length);
-    });
-  });
-});
@@ -1,480 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import {
-  configStore,
-  maskPaths,
-  clampFontSize,
-  applyFontSize,
-  applyTheme,
-  applyCustomThemeColors,
-  clearCustomThemeColors,
-  MIN_FONT_SIZE,
-  MAX_FONT_SIZE,
-  DEFAULT_FONT_SIZE,
-  type HikariConfig,
-  type Theme,
-  type CustomThemeColors,
-} from "./config";
-
-// Mock Tauri APIs
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn(),
-}));
-
-describe("config store", () => {
-  describe("font size constants", () => {
-    it("has correct MIN_FONT_SIZE", () => {
-      expect(MIN_FONT_SIZE).toBe(10);
-    });
-
-    it("has correct MAX_FONT_SIZE", () => {
-      expect(MAX_FONT_SIZE).toBe(24);
-    });
-
-    it("has correct DEFAULT_FONT_SIZE", () => {
-      expect(DEFAULT_FONT_SIZE).toBe(14);
-    });
-  });
-
-  describe("clampFontSize", () => {
-    it("returns the same value when within range", () => {
-      expect(clampFontSize(14)).toBe(14);
-      expect(clampFontSize(10)).toBe(10);
-      expect(clampFontSize(24)).toBe(24);
-      expect(clampFontSize(18)).toBe(18);
-    });
-
-    it("clamps values below minimum", () => {
-      expect(clampFontSize(5)).toBe(MIN_FONT_SIZE);
-      expect(clampFontSize(0)).toBe(MIN_FONT_SIZE);
-      expect(clampFontSize(-10)).toBe(MIN_FONT_SIZE);
-      expect(clampFontSize(9)).toBe(MIN_FONT_SIZE);
-    });
-
-    it("clamps values above maximum", () => {
-      expect(clampFontSize(30)).toBe(MAX_FONT_SIZE);
-      expect(clampFontSize(100)).toBe(MAX_FONT_SIZE);
-      expect(clampFontSize(25)).toBe(MAX_FONT_SIZE);
-    });
-  });
-
-  describe("maskPaths", () => {
-    it("returns text unchanged when hidePaths is false", () => {
-      const text = "/home/naomi/code/project/file.ts";
-      expect(maskPaths(text, false)).toBe(text);
-    });
-
-    it("masks Unix home paths", () => {
-      const text = "/home/naomi/code/project/file.ts";
-      expect(maskPaths(text, true)).toBe("/home/****/code/project/file.ts");
-    });
-
-    it("masks macOS user paths", () => {
-      const text = "/Users/naomi/Documents/project/file.ts";
-      expect(maskPaths(text, true)).toBe("/Users/****/Documents/project/file.ts");
-    });
-
-    it("masks Windows user paths", () => {
-      const text = "C:\\Users\\naomi\\Documents\\project\\file.ts";
-      expect(maskPaths(text, true)).toBe("C:\\Users\\****\\Documents\\project\\file.ts");
-    });
-
-    it("masks tilde paths", () => {
-      const text = "~/code/project/file.ts";
-      expect(maskPaths(text, true)).toBe("****/code/project/file.ts");
-    });
-
-    it("masks multiple paths in the same text", () => {
-      const text = "Editing /home/naomi/file1.ts and /home/naomi/file2.ts";
-      expect(maskPaths(text, true)).toBe("Editing /home/****/file1.ts and /home/****/file2.ts");
-    });
-
-    it("handles mixed path types", () => {
-      const text = "Unix: /home/user/file, Mac: /Users/user/file, Win: C:\\Users\\user\\file";
-      const expected = "Unix: /home/****/file, Mac: /Users/****/file, Win: C:\\Users\\****\\file";
-      expect(maskPaths(text, true)).toBe(expected);
-    });
-
-    it("handles paths with special characters in username", () => {
-      const text = "/home/user-name_123/project";
-      expect(maskPaths(text, true)).toBe("/home/****/project");
-    });
-
-    it("does not mask non-path text", () => {
-      const text = "This is just regular text without any paths";
-      expect(maskPaths(text, true)).toBe(text);
-    });
-
-    it("handles empty string", () => {
-      expect(maskPaths("", true)).toBe("");
-      expect(maskPaths("", false)).toBe("");
-    });
-  });
-
-  describe("Theme type", () => {
-    it("accepts valid theme values", () => {
-      const themes: Theme[] = ["dark", "light", "high-contrast", "custom"];
-      themes.forEach((theme) => {
-        expect(["dark", "light", "high-contrast", "custom"]).toContain(theme);
-      });
-    });
-  });
-
-  describe("CustomThemeColors interface", () => {
-    it("can create a valid custom theme colors object", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#1a1a2e",
-        bg_secondary: "#16213e",
-        bg_terminal: "#0f0f23",
-        accent_primary: "#e94560",
-        accent_secondary: "#533483",
-        text_primary: "#eaeaea",
-        text_secondary: "#a0a0a0",
-        border_color: "#333355",
-      };
-
-      expect(colors.bg_primary).toBe("#1a1a2e");
-      expect(colors.accent_primary).toBe("#e94560");
-    });
-
-    it("allows null values for optional colors", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: null,
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: "#e94560",
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      expect(colors.bg_primary).toBeNull();
-      expect(colors.accent_primary).toBe("#e94560");
-    });
-  });
-
-  describe("HikariConfig interface", () => {
-    it("can create a valid config object with all fields", () => {
-      const config: HikariConfig = {
-        model: "claude-sonnet-4",
-        api_key: "test-key",
-        custom_instructions: "Be helpful",
-        mcp_servers_json: "{}",
-        auto_granted_tools: ["Read", "Write"],
-        theme: "dark",
-        greeting_enabled: true,
-        greeting_custom_prompt: "Hello!",
-        notifications_enabled: true,
-        notification_volume: 0.7,
-        always_on_top: false,
-        minimize_to_tray: true,
-        update_checks_enabled: true,
-        character_panel_width: 300,
-        font_size: 14,
-        streamer_mode: false,
-        streamer_hide_paths: false,
-        compact_mode: false,
-        profile_name: "Naomi",
-        profile_avatar_path: "/path/to/avatar.png",
-        profile_bio: "Developer",
-        custom_theme_colors: {
-          bg_primary: null,
-          bg_secondary: null,
-          bg_terminal: null,
-          accent_primary: null,
-          accent_secondary: null,
-          text_primary: null,
-          text_secondary: null,
-          border_color: null,
-        },
-      };
-
-      expect(config.model).toBe("claude-sonnet-4");
-      expect(config.auto_granted_tools).toEqual(["Read", "Write"]);
-      expect(config.theme).toBe("dark");
-    });
-
-    it("allows null values for optional fields", () => {
-      const config: HikariConfig = {
-        model: null,
-        api_key: null,
-        custom_instructions: null,
-        mcp_servers_json: null,
-        auto_granted_tools: [],
-        theme: "dark",
-        greeting_enabled: true,
-        greeting_custom_prompt: null,
-        notifications_enabled: true,
-        notification_volume: 0.7,
-        always_on_top: false,
-        minimize_to_tray: false,
-        update_checks_enabled: true,
-        character_panel_width: null,
-        font_size: 14,
-        streamer_mode: false,
-        streamer_hide_paths: false,
-        compact_mode: false,
-        profile_name: null,
-        profile_avatar_path: null,
-        profile_bio: null,
-        custom_theme_colors: {
-          bg_primary: null,
-          bg_secondary: null,
-          bg_terminal: null,
-          accent_primary: null,
-          accent_secondary: null,
-          text_primary: null,
-          text_secondary: null,
-          border_color: null,
-        },
-      };
-
-      expect(config.model).toBeNull();
-      expect(config.api_key).toBeNull();
-      expect(config.character_panel_width).toBeNull();
-    });
-  });
-
-  describe("applyFontSize", () => {
-    beforeEach(() => {
-      // Reset document state
-      if (typeof document !== "undefined") {
-        document.documentElement.style.removeProperty("--terminal-font-size");
-      }
-    });
-
-    it("sets CSS variable for valid font size", () => {
-      applyFontSize(16);
-      const value = document.documentElement.style.getPropertyValue("--terminal-font-size");
-      expect(value).toBe("16px");
-    });
-
-    it("clamps font size below minimum", () => {
-      applyFontSize(5);
-      const value = document.documentElement.style.getPropertyValue("--terminal-font-size");
-      expect(value).toBe(`${MIN_FONT_SIZE}px`);
-    });
-
-    it("clamps font size above maximum", () => {
-      applyFontSize(50);
-      const value = document.documentElement.style.getPropertyValue("--terminal-font-size");
-      expect(value).toBe(`${MAX_FONT_SIZE}px`);
-    });
-  });
-
-  describe("applyTheme", () => {
-    beforeEach(() => {
-      // Reset document state
-      if (typeof document !== "undefined") {
-        document.documentElement.removeAttribute("data-theme");
-        clearCustomThemeColors();
-      }
-    });
-
-    it("sets data-theme attribute for dark theme", () => {
-      applyTheme("dark");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("dark");
-    });
-
-    it("sets data-theme attribute for light theme", () => {
-      applyTheme("light");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("light");
-    });
-
-    it("sets data-theme attribute for high-contrast theme", () => {
-      applyTheme("high-contrast");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("high-contrast");
-    });
-
-    it("uses dark as base for custom theme", () => {
-      applyTheme("custom");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("dark");
-    });
-
-    it("applies custom colors when theme is custom", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#1a1a2e",
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: "#e94560",
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      applyTheme("custom", colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("#1a1a2e");
-      expect(document.documentElement.style.getPropertyValue("--accent-primary")).toBe("#e94560");
-    });
-
-    it("does not apply custom colors for non-custom themes", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#1a1a2e",
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: null,
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      applyTheme("dark", colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("");
-    });
-  });
-
-  describe("applyCustomThemeColors", () => {
-    beforeEach(() => {
-      clearCustomThemeColors();
-    });
-
-    it("applies all provided colors", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#111111",
-        bg_secondary: "#222222",
-        bg_terminal: "#333333",
-        accent_primary: "#444444",
-        accent_secondary: "#555555",
-        text_primary: "#666666",
-        text_secondary: "#777777",
-        border_color: "#888888",
-      };
-
-      applyCustomThemeColors(colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("#111111");
-      expect(document.documentElement.style.getPropertyValue("--bg-secondary")).toBe("#222222");
-      expect(document.documentElement.style.getPropertyValue("--bg-terminal")).toBe("#333333");
-      expect(document.documentElement.style.getPropertyValue("--accent-primary")).toBe("#444444");
-      expect(document.documentElement.style.getPropertyValue("--accent-secondary")).toBe("#555555");
-      expect(document.documentElement.style.getPropertyValue("--text-primary")).toBe("#666666");
-      expect(document.documentElement.style.getPropertyValue("--text-secondary")).toBe("#777777");
-      expect(document.documentElement.style.getPropertyValue("--border-color")).toBe("#888888");
-    });
-
-    it("skips null values", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#111111",
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: null,
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      applyCustomThemeColors(colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("#111111");
-      expect(document.documentElement.style.getPropertyValue("--bg-secondary")).toBe("");
-    });
-  });
-
-  describe("clearCustomThemeColors", () => {
-    it("removes all custom theme CSS properties", () => {
-      // First apply some colors
-      const colors: CustomThemeColors = {
-        bg_primary: "#111111",
-        bg_secondary: "#222222",
-        bg_terminal: "#333333",
-        accent_primary: "#444444",
-        accent_secondary: "#555555",
-        text_primary: "#666666",
-        text_secondary: "#777777",
-        border_color: "#888888",
-      };
-      applyCustomThemeColors(colors);
-
-      // Then clear them
-      clearCustomThemeColors();
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--bg-secondary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--bg-terminal")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--accent-primary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--accent-secondary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--text-primary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--text-secondary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--border-color")).toBe("");
-    });
-  });
-
-  describe("derived stores", () => {
-    // Note: These tests verify the derived store logic by testing the derivation functions
-    // The actual stores depend on configStore which requires Tauri invoke mocking
-
-    it("isDarkTheme returns true for dark theme config", () => {
-      // Test the derivation logic
-      const darkConfig = { theme: "dark" as Theme };
-      expect(darkConfig.theme === "dark").toBe(true);
-    });
-
-    it("isDarkTheme returns false for light theme config", () => {
-      const lightConfig = { theme: "light" as Theme };
-      expect(lightConfig.theme === "dark").toBe(false);
-    });
-
-    it("isStreamerMode derives from streamer_mode config", () => {
-      const configWithStreamerMode = { streamer_mode: true };
-      const configWithoutStreamerMode = { streamer_mode: false };
-
-      expect(configWithStreamerMode.streamer_mode).toBe(true);
-      expect(configWithoutStreamerMode.streamer_mode).toBe(false);
-    });
-
-    it("isCompactMode derives from compact_mode config", () => {
-      const configWithCompactMode = { compact_mode: true };
-      const configWithoutCompactMode = { compact_mode: false };
-
-      expect(configWithCompactMode.compact_mode).toBe(true);
-      expect(configWithoutCompactMode.compact_mode).toBe(false);
-    });
-
-    it("shouldHidePaths requires both streamer_mode and streamer_hide_paths", () => {
-      const config1 = { streamer_mode: true, streamer_hide_paths: true };
-      const config2 = { streamer_mode: true, streamer_hide_paths: false };
-      const config3 = { streamer_mode: false, streamer_hide_paths: true };
-      const config4 = { streamer_mode: false, streamer_hide_paths: false };
-
-      expect(config1.streamer_mode && config1.streamer_hide_paths).toBe(true);
-      expect(config2.streamer_mode && config2.streamer_hide_paths).toBe(false);
-      expect(config3.streamer_mode && config3.streamer_hide_paths).toBe(false);
-      expect(config4.streamer_mode && config4.streamer_hide_paths).toBe(false);
-    });
-  });
-
-  describe("configStore methods", () => {
-    it("has all expected methods", () => {
-      expect(typeof configStore.loadConfig).toBe("function");
-      expect(typeof configStore.saveConfig).toBe("function");
-      expect(typeof configStore.updateConfig).toBe("function");
-      expect(typeof configStore.openSidebar).toBe("function");
-      expect(typeof configStore.closeSidebar).toBe("function");
-      expect(typeof configStore.toggleSidebar).toBe("function");
-      expect(typeof configStore.setTheme).toBe("function");
-      expect(typeof configStore.setCustomThemeColors).toBe("function");
-      expect(typeof configStore.setFontSize).toBe("function");
-      expect(typeof configStore.increaseFontSize).toBe("function");
-      expect(typeof configStore.decreaseFontSize).toBe("function");
-      expect(typeof configStore.resetFontSize).toBe("function");
-      expect(typeof configStore.addAutoGrantedTool).toBe("function");
-      expect(typeof configStore.removeAutoGrantedTool).toBe("function");
-      expect(typeof configStore.getConfig).toBe("function");
-      expect(typeof configStore.toggleStreamerMode).toBe("function");
-      expect(typeof configStore.toggleCompactMode).toBe("function");
-      expect(typeof configStore.setCompactMode).toBe("function");
-    });
-
-    it("has subscribable stores", () => {
-      expect(typeof configStore.config.subscribe).toBe("function");
-      expect(typeof configStore.isLoading.subscribe).toBe("function");
-      expect(typeof configStore.isSidebarOpen.subscribe).toBe("function");
-      expect(typeof configStore.saveError.subscribe).toBe("function");
-    });
-  });
-});
@@ -1,18 +1,7 @@
 import { writable, derived } from "svelte/store";
 import { invoke } from "@tauri-apps/api/core";

-export type Theme = "dark" | "light" | "high-contrast" | "custom";
-
-export interface CustomThemeColors {
-  bg_primary: string | null;
-  bg_secondary: string | null;
-  bg_terminal: string | null;
-  accent_primary: string | null;
-  accent_secondary: string | null;
-  text_primary: string | null;
-  text_secondary: string | null;
-  border_color: string | null;
-}
+export type Theme = "dark" | "light" | "high-contrast";

 export interface HikariConfig {
  model: string | null;
@@ -33,10 +22,6 @@ export interface HikariConfig {
  streamer_mode: boolean;
  streamer_hide_paths: boolean;
  compact_mode: boolean;
-  profile_name: string | null;
-  profile_avatar_path: string | null;
-  profile_bio: string | null;
-  custom_theme_colors: CustomThemeColors;
 }

 const defaultConfig: HikariConfig = {
@@ -58,19 +43,6 @@ const defaultConfig: HikariConfig = {
  streamer_mode: false,
  streamer_hide_paths: false,
  compact_mode: false,
-  profile_name: null,
-  profile_avatar_path: null,
-  profile_bio: null,
-  custom_theme_colors: {
-    bg_primary: null,
-    bg_secondary: null,
-    bg_terminal: null,
-    accent_primary: null,
-    accent_secondary: null,
-    text_primary: null,
-    text_secondary: null,
-    border_color: null,
-  },
 };

 function createConfigStore() {
@@ -126,24 +98,9 @@ function createConfigStore() {
    closeSidebar: () => isSidebarOpen.set(false),
    toggleSidebar: () => isSidebarOpen.update((open) => !open),

-    setTheme: async (theme: Theme, customColors?: CustomThemeColors) => {
-      const updates: Partial<HikariConfig> = { theme };
-      if (customColors) {
-        updates.custom_theme_colors = customColors;
-      }
-      await updateConfig(updates);
-      let currentConfig: HikariConfig = defaultConfig;
-      config.subscribe((c) => (currentConfig = c))();
-      applyTheme(theme, currentConfig.custom_theme_colors);
-    },
-
-    setCustomThemeColors: async (colors: CustomThemeColors) => {
-      await updateConfig({ custom_theme_colors: colors });
-      let currentConfig: HikariConfig = defaultConfig;
-      config.subscribe((c) => (currentConfig = c))();
-      if (currentConfig.theme === "custom") {
-        applyCustomThemeColors(colors);
-      }
+    setTheme: async (theme: Theme) => {
+      await updateConfig({ theme });
+      applyTheme(theme);
    },

    setFontSize: async (size: number) => {
@@ -213,52 +170,11 @@ function createConfigStore() {
  };
 }

-export function applyTheme(theme: Theme, customColors?: CustomThemeColors) {
+export function applyTheme(theme: Theme) {
  if (typeof document !== "undefined") {
-    // For custom theme, we use dark as the base and override with custom colors
-    document.documentElement.setAttribute("data-theme", theme === "custom" ? "dark" : theme);
-
-    // Clear any previously applied custom colors
-    clearCustomThemeColors();
-
-    // Apply custom colors if theme is custom
-    if (theme === "custom" && customColors) {
-      applyCustomThemeColors(customColors);
+    document.documentElement.setAttribute("data-theme", theme);
  }
 }
-}
-
-export function applyCustomThemeColors(colors: CustomThemeColors) {
-  if (typeof document === "undefined") return;
-
-  const root = document.documentElement;
-  if (colors.bg_primary) root.style.setProperty("--bg-primary", colors.bg_primary);
-  if (colors.bg_secondary) root.style.setProperty("--bg-secondary", colors.bg_secondary);
-  if (colors.bg_terminal) root.style.setProperty("--bg-terminal", colors.bg_terminal);
-  if (colors.accent_primary) root.style.setProperty("--accent-primary", colors.accent_primary);
-  if (colors.accent_secondary)
-    root.style.setProperty("--accent-secondary", colors.accent_secondary);
-  if (colors.text_primary) root.style.setProperty("--text-primary", colors.text_primary);
-  if (colors.text_secondary) root.style.setProperty("--text-secondary", colors.text_secondary);
-  if (colors.border_color) root.style.setProperty("--border-color", colors.border_color);
-}
-
-export function clearCustomThemeColors() {
-  if (typeof document === "undefined") return;
-
-  const root = document.documentElement;
-  const customProperties = [
-    "--bg-primary",
-    "--bg-secondary",
-    "--bg-terminal",
-    "--accent-primary",
-    "--accent-secondary",
-    "--text-primary",
-    "--text-secondary",
-    "--border-color",
-  ];
-  customProperties.forEach((prop) => root.style.removeProperty(prop));
-}

 const MIN_FONT_SIZE = 10;
 const MAX_FONT_SIZE = 24;
@@ -1,525 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-// Test the Conversation interface and store behavior
-describe("Conversation interface", () => {
-  it("defines all required fields", () => {
-    const conversation = {
-      id: "conv-123",
-      name: "Test Conversation",
-      terminalLines: [],
-      sessionId: null,
-      connectionStatus: "disconnected" as const,
-      workingDirectory: "",
-      characterState: "idle" as const,
-      isProcessing: false,
-      grantedTools: new Set<string>(),
-      pendingPermission: null,
-      pendingQuestion: null,
-      scrollPosition: -1,
-      createdAt: new Date(),
-      lastActivityAt: new Date(),
-      attachments: [],
-    };
-
-    expect(conversation.id).toBe("conv-123");
-    expect(conversation.name).toBe("Test Conversation");
-    expect(conversation.terminalLines).toEqual([]);
-    expect(conversation.sessionId).toBeNull();
-    expect(conversation.connectionStatus).toBe("disconnected");
-    expect(conversation.workingDirectory).toBe("");
-    expect(conversation.characterState).toBe("idle");
-    expect(conversation.isProcessing).toBe(false);
-    expect(conversation.grantedTools.size).toBe(0);
-    expect(conversation.pendingPermission).toBeNull();
-    expect(conversation.pendingQuestion).toBeNull();
-    expect(conversation.scrollPosition).toBe(-1);
-    expect(conversation.attachments).toEqual([]);
-  });
-
-  it("handles terminal lines array", () => {
-    const lines = [
-      {
-        id: "line-1",
-        type: "user" as const,
-        content: "Hello",
-        timestamp: new Date(),
-      },
-      {
-        id: "line-2",
-        type: "assistant" as const,
-        content: "Hi there!",
-        timestamp: new Date(),
-      },
-    ];
-
-    expect(lines).toHaveLength(2);
-    expect(lines[0].type).toBe("user");
-    expect(lines[1].type).toBe("assistant");
-  });
-});
-
-describe("conversation ID generation", () => {
-  it("generates unique IDs with timestamp prefix", () => {
-    let counter = 0;
-    const generateId = () => `conv-${Date.now()}-${counter++}`;
-
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).toMatch(/^conv-\d+-\d+$/);
-    expect(id2).toMatch(/^conv-\d+-\d+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("line ID generation", () => {
-  it("generates unique line IDs", () => {
-    let counter = 0;
-    const generateLineId = () => `line-${Date.now()}-${counter++}`;
-
-    const id1 = generateLineId();
-    const id2 = generateLineId();
-
-    expect(id1).toMatch(/^line-\d+-\d+$/);
-    expect(id2).toMatch(/^line-\d+-\d+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("connection status types", () => {
-  it("supports all connection status values", () => {
-    const statuses = ["connected", "disconnected", "connecting", "error"] as const;
-
-    statuses.forEach((status) => {
-      expect(typeof status).toBe("string");
-    });
-  });
-});
-
-describe("character state types", () => {
-  it("supports all character state values", () => {
-    const states = [
-      "idle",
-      "thinking",
-      "typing",
-      "searching",
-      "coding",
-      "mcp",
-      "permission",
-      "success",
-      "error",
-    ] as const;
-
-    states.forEach((state) => {
-      expect(typeof state).toBe("string");
-    });
-  });
-});
-
-describe("terminal line types", () => {
-  it("supports all terminal line types", () => {
-    const types = ["user", "assistant", "system", "tool", "error"] as const;
-
-    types.forEach((type) => {
-      expect(typeof type).toBe("string");
-    });
-  });
-
-  it("creates terminal line with required fields", () => {
-    const line = {
-      id: "line-123",
-      type: "user" as const,
-      content: "Test message",
-      timestamp: new Date(),
-      toolName: undefined,
-    };
-
-    expect(line.id).toBe("line-123");
-    expect(line.type).toBe("user");
-    expect(line.content).toBe("Test message");
-    expect(line.timestamp).toBeInstanceOf(Date);
-    expect(line.toolName).toBeUndefined();
-  });
-
-  it("creates terminal line with tool name", () => {
-    const line = {
-      id: "line-456",
-      type: "tool" as const,
-      content: "Tool output",
-      timestamp: new Date(),
-      toolName: "Read",
-    };
-
-    expect(line.toolName).toBe("Read");
-  });
-});
-
-describe("permission request structure", () => {
-  it("creates valid permission request", () => {
-    const request = {
-      id: "perm-123",
-      tool: "Bash",
-      description: "Run shell command",
-      input: '{"command": "ls"}',
-    };
-
-    expect(request.id).toBe("perm-123");
-    expect(request.tool).toBe("Bash");
-    expect(request.description).toBe("Run shell command");
-    expect(request.input).toContain("command");
-  });
-});
-
-describe("user question structure", () => {
-  it("creates valid question event", () => {
-    const question = {
-      id: "q-123",
-      question: "Which option?",
-      options: [
-        { label: "A", description: "Option A" },
-        { label: "B", description: "Option B" },
-      ],
-      conversation_id: "conv-123",
-    };
-
-    expect(question.id).toBe("q-123");
-    expect(question.question).toBe("Which option?");
-    expect(question.options).toHaveLength(2);
-  });
-});
-
-describe("attachment structure", () => {
-  it("creates valid file attachment", () => {
-    const attachment = {
-      id: "att-123",
-      type: "file" as const,
-      name: "test.txt",
-      path: "/tmp/test.txt",
-      size: 1024,
-      mimeType: "text/plain",
-    };
-
-    expect(attachment.id).toBe("att-123");
-    expect(attachment.type).toBe("file");
-    expect(attachment.name).toBe("test.txt");
-  });
-
-  it("creates valid image attachment", () => {
-    const attachment = {
-      id: "att-456",
-      type: "image" as const,
-      name: "screenshot.png",
-      path: "/tmp/screenshot.png",
-      size: 50000,
-      mimeType: "image/png",
-      previewUrl: "data:image/png;base64,...",
-    };
-
-    expect(attachment.type).toBe("image");
-    expect(attachment.previewUrl).toContain("data:image");
-  });
-});
-
-describe("conversation management operations", () => {
-  it("creates new conversation with default values", () => {
-    let counter = 1;
-    const createNewConversation = (name?: string) => {
-      const id = `conv-${Date.now()}-${counter++}`;
-      return {
-        id,
-        name: name || `Conversation ${counter}`,
-        terminalLines: [],
-        sessionId: null,
-        connectionStatus: "disconnected" as const,
-        workingDirectory: "",
-        characterState: "idle" as const,
-        isProcessing: false,
-        grantedTools: new Set<string>(),
-        pendingPermission: null,
-        pendingQuestion: null,
-        scrollPosition: -1,
-        createdAt: new Date(),
-        lastActivityAt: new Date(),
-        attachments: [],
-      };
-    };
-
-    const conv = createNewConversation("My Chat");
-    expect(conv.name).toBe("My Chat");
-    expect(conv.connectionStatus).toBe("disconnected");
-    expect(conv.characterState).toBe("idle");
-  });
-
-  it("uses default name when not provided", () => {
-    const counter = 5;
-    const createNewConversation = (name?: string) => ({
-      name: name || `Conversation ${counter}`,
-    });
-
-    const conv = createNewConversation();
-    expect(conv.name).toBe("Conversation 5");
-  });
-});
-
-describe("conversation history formatting", () => {
-  it("formats user and assistant messages for history", () => {
-    const lines = [
-      { type: "user" as const, content: "Hello" },
-      { type: "assistant" as const, content: "Hi there!" },
-      { type: "system" as const, content: "Connected" },
-      { type: "user" as const, content: "How are you?" },
-    ];
-
-    const relevantLines = lines.filter((line) => line.type === "user" || line.type === "assistant");
-
-    const history = relevantLines
-      .map((line) => {
-        const role = line.type === "user" ? "User" : "Assistant";
-        return `${role}: ${line.content}`;
-      })
-      .join("\n\n");
-
-    expect(history).toContain("User: Hello");
-    expect(history).toContain("Assistant: Hi there!");
-    expect(history).toContain("User: How are you?");
-    expect(history).not.toContain("Connected");
-  });
-
-  it("returns empty string for no messages", () => {
-    const lines: Array<{ type: string; content: string }> = [];
-    const relevantLines = lines.filter((line) => line.type === "user" || line.type === "assistant");
-
-    expect(relevantLines.length).toBe(0);
-    const history = relevantLines.length === 0 ? "" : "has content";
-    expect(history).toBe("");
-  });
-});
-
-describe("tool granting", () => {
-  it("tracks granted tools with Set", () => {
-    const grantedTools = new Set<string>();
-
-    grantedTools.add("Read");
-    grantedTools.add("Write");
-    grantedTools.add("Bash");
-
-    expect(grantedTools.has("Read")).toBe(true);
-    expect(grantedTools.has("Write")).toBe(true);
-    expect(grantedTools.has("Bash")).toBe(true);
-    expect(grantedTools.has("Edit")).toBe(false);
-    expect(grantedTools.size).toBe(3);
-  });
-
-  it("clears all granted tools", () => {
-    const grantedTools = new Set<string>(["Read", "Write"]);
-    expect(grantedTools.size).toBe(2);
-
-    grantedTools.clear();
-    expect(grantedTools.size).toBe(0);
-  });
-});
-
-describe("scroll position handling", () => {
-  it("uses -1 for auto-scroll (scroll to bottom)", () => {
-    const scrollPosition = -1;
-    const isAutoScroll = scrollPosition === -1;
-
-    expect(isAutoScroll).toBe(true);
-  });
-
-  it("uses positive values for manual scroll position", () => {
-    const scrollPosition: number = 500;
-    const isAutoScroll = scrollPosition === -1;
-
-    expect(isAutoScroll).toBe(false);
-    expect(scrollPosition).toBeGreaterThan(0);
-  });
-});
-
-describe("conversation deletion rules", () => {
-  it("prevents deletion of last conversation", () => {
-    const conversations = new Map([["conv-1", { id: "conv-1", name: "Main" }]]);
-
-    const canDelete = conversations.size > 1;
-    expect(canDelete).toBe(false);
-  });
-
-  it("allows deletion when multiple conversations exist", () => {
-    const conversations = new Map([
-      ["conv-1", { id: "conv-1", name: "Main" }],
-      ["conv-2", { id: "conv-2", name: "Second" }],
-    ]);
-
-    const canDelete = conversations.size > 1;
-    expect(canDelete).toBe(true);
-  });
-
-  it("switches to remaining conversation after deletion", () => {
-    const conversations = new Map([
-      ["conv-1", { id: "conv-1", name: "Main" }],
-      ["conv-2", { id: "conv-2", name: "Second" }],
-    ]);
-
-    const activeId = "conv-1";
-    conversations.delete(activeId);
-
-    const remaining = Array.from(conversations.keys());
-    expect(remaining).toEqual(["conv-2"]);
-    expect(remaining[0]).toBe("conv-2");
-  });
-});
-
-describe("activity timestamp tracking", () => {
-  it("updates lastActivityAt on changes", () => {
-    const before = new Date();
-
-    // Simulate a small delay
-    const after = new Date(before.getTime() + 100);
-
-    expect(after.getTime()).toBeGreaterThan(before.getTime());
-  });
-});
-
-describe("Map operations for conversations", () => {
-  it("stores and retrieves conversations by ID", () => {
-    const conversations = new Map<string, { id: string; name: string }>();
-
-    conversations.set("conv-1", { id: "conv-1", name: "First" });
-    conversations.set("conv-2", { id: "conv-2", name: "Second" });
-
-    expect(conversations.get("conv-1")?.name).toBe("First");
-    expect(conversations.get("conv-2")?.name).toBe("Second");
-    expect(conversations.get("conv-3")).toBeUndefined();
-  });
-
-  it("checks if conversation exists", () => {
-    const conversations = new Map([["conv-1", { id: "conv-1" }]]);
-
-    expect(conversations.has("conv-1")).toBe(true);
-    expect(conversations.has("conv-2")).toBe(false);
-  });
-
-  it("iterates over all conversations", () => {
-    const conversations = new Map([
-      ["conv-1", { id: "conv-1", name: "First" }],
-      ["conv-2", { id: "conv-2", name: "Second" }],
-    ]);
-
-    const names: string[] = [];
-    conversations.forEach((conv) => names.push(conv.name));
-
-    expect(names).toContain("First");
-    expect(names).toContain("Second");
-  });
-});
-
-describe("conversation rename", () => {
-  it("updates conversation name", () => {
-    const conversation = { id: "conv-1", name: "Old Name", lastActivityAt: new Date() };
-
-    conversation.name = "New Name";
-    conversation.lastActivityAt = new Date();
-
-    expect(conversation.name).toBe("New Name");
-  });
-});
-
-describe("attachment management", () => {
-  it("adds attachment to array", () => {
-    const attachments: Array<{ id: string; name: string }> = [];
-
-    attachments.push({ id: "att-1", name: "file1.txt" });
-    expect(attachments).toHaveLength(1);
-
-    attachments.push({ id: "att-2", name: "file2.txt" });
-    expect(attachments).toHaveLength(2);
-  });
-
-  it("removes attachment by ID", () => {
-    const attachments = [
-      { id: "att-1", name: "file1.txt" },
-      { id: "att-2", name: "file2.txt" },
-    ];
-
-    const filtered = attachments.filter((a) => a.id !== "att-1");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0].id).toBe("att-2");
-  });
-
-  it("clears all attachments", () => {
-    const cleared: Array<{ id: string }> = [];
-    expect(cleared).toHaveLength(0);
-  });
-});
-
-describe("derived store behavior", () => {
-  it("derives connection status from active conversation", () => {
-    const activeConv = { connectionStatus: "connected" as const };
-    const derivedStatus = activeConv?.connectionStatus || "disconnected";
-
-    expect(derivedStatus).toBe("connected");
-  });
-
-  it("defaults to disconnected when no active conversation", () => {
-    const activeConv = null as { connectionStatus?: string } | null;
-    const derivedStatus = activeConv?.connectionStatus || "disconnected";
-
-    expect(derivedStatus).toBe("disconnected");
-  });
-
-  it("derives terminal lines from active conversation", () => {
-    const activeConv = {
-      terminalLines: [
-        { id: "1", content: "Hello" },
-        { id: "2", content: "World" },
-      ],
-    };
-    const derivedLines = activeConv?.terminalLines || [];
-
-    expect(derivedLines).toHaveLength(2);
-  });
-
-  it("defaults to empty array when no active conversation", () => {
-    const activeConv = null as { terminalLines?: Array<{ id: string; content: string }> } | null;
-    const derivedLines = activeConv?.terminalLines || [];
-
-    expect(derivedLines).toEqual([]);
-  });
-});
-
-describe("line update operations", () => {
-  it("updates line content by ID", () => {
-    const lines = [
-      { id: "line-1", content: "Original" },
-      { id: "line-2", content: "Other" },
-    ];
-
-    const line = lines.find((l) => l.id === "line-1");
-    if (line) {
-      line.content = "Updated";
-    }
-
-    expect(lines[0].content).toBe("Updated");
-    expect(lines[1].content).toBe("Other");
-  });
-
-  it("appends to line content", () => {
-    const line = { id: "line-1", content: "Hello" };
-
-    line.content += " World";
-
-    expect(line.content).toBe("Hello World");
-  });
-});
-
-describe("pending retry message", () => {
-  it("stores and clears retry message", () => {
-    let pendingRetryMessage: string | null = null;
-
-    pendingRetryMessage = "Retry this message";
-    expect(pendingRetryMessage).toBe("Retry this message");
-
-    pendingRetryMessage = null;
-    expect(pendingRetryMessage).toBeNull();
-  });
-});
@@ -1,351 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { invoke } from "@tauri-apps/api/core";
-import { setMockInvokeResult } from "../../../vitest.setup";
-import { quickActionsStore, type QuickAction } from "./quickActions";
-
-describe("QuickAction interface", () => {
-  it("defines all required fields", () => {
-    const action: QuickAction = {
-      id: "action-123",
-      name: "Run Tests",
-      prompt: "Please run the tests",
-      icon: "play",
-      is_default: false,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(action.id).toBe("action-123");
-    expect(action.name).toBe("Run Tests");
-    expect(action.prompt).toBe("Please run the tests");
-    expect(action.icon).toBe("play");
-    expect(action.is_default).toBe(false);
-    expect(action.created_at).toBe("2024-01-01T00:00:00Z");
-    expect(action.updated_at).toBe("2024-01-01T00:00:00Z");
-  });
-
-  it("supports default actions", () => {
-    const defaultAction: QuickAction = {
-      id: "default-review-pr",
-      name: "Review PR",
-      prompt: "Please review this pull request",
-      icon: "git-pull-request",
-      is_default: true,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(defaultAction.is_default).toBe(true);
-    expect(defaultAction.id).toContain("default-");
-  });
-});
-
-describe("quickActionsStore", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("store structure", () => {
-    it("has all expected methods", () => {
-      expect(typeof quickActionsStore.loadQuickActions).toBe("function");
-      expect(typeof quickActionsStore.saveQuickAction).toBe("function");
-      expect(typeof quickActionsStore.createQuickAction).toBe("function");
-      expect(typeof quickActionsStore.updateQuickAction).toBe("function");
-      expect(typeof quickActionsStore.deleteQuickAction).toBe("function");
-      expect(typeof quickActionsStore.resetDefaults).toBe("function");
-    });
-
-    it("has subscribable stores", () => {
-      expect(typeof quickActionsStore.actions.subscribe).toBe("function");
-      expect(typeof quickActionsStore.isLoading.subscribe).toBe("function");
-    });
-  });
-
-  describe("loadQuickActions", () => {
-    it("loads quick actions from backend", async () => {
-      const mockActions: QuickAction[] = [
-        {
-          id: "action-1",
-          name: "Action 1",
-          prompt: "prompt 1",
-          icon: "star",
-          is_default: false,
-          created_at: "2024-01-01T00:00:00Z",
-          updated_at: "2024-01-01T00:00:00Z",
-        },
-      ];
-
-      setMockInvokeResult("list_quick_actions", mockActions);
-
-      await quickActionsStore.loadQuickActions();
-
-      expect(invoke).toHaveBeenCalledWith("list_quick_actions");
-    });
-
-    it("handles load errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_quick_actions", new Error("Failed to load"));
-
-      await quickActionsStore.loadQuickActions();
-
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to load quick actions:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("saveQuickAction", () => {
-    it("saves action and reloads list", async () => {
-      const action: QuickAction = {
-        id: "action-123",
-        name: "Test",
-        prompt: "test prompt",
-        icon: "star",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("save_quick_action", undefined);
-      setMockInvokeResult("list_quick_actions", [action]);
-
-      const result = await quickActionsStore.saveQuickAction(action);
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("save_quick_action", { action });
-    });
-
-    it("handles save errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("save_quick_action", new Error("Failed to save"));
-
-      const action: QuickAction = {
-        id: "action-123",
-        name: "Test",
-        prompt: "test prompt",
-        icon: "star",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      const result = await quickActionsStore.saveQuickAction(action);
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to save quick action:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("createQuickAction", () => {
-    it("creates new action with generated ID and timestamps", async () => {
-      setMockInvokeResult("save_quick_action", undefined);
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.createQuickAction("My Action", "Do something", "star");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_quick_action",
-        expect.objectContaining({
-          action: expect.objectContaining({
-            name: "My Action",
-            prompt: "Do something",
-            icon: "star",
-            is_default: false,
-          }),
-        })
-      );
-    });
-  });
-
-  describe("updateQuickAction", () => {
-    it("updates existing action preserving created_at", async () => {
-      const existingAction: QuickAction = {
-        id: "action-123",
-        name: "Old Name",
-        prompt: "old prompt",
-        icon: "old-icon",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("list_quick_actions", [existingAction]);
-      setMockInvokeResult("save_quick_action", undefined);
-
-      const result = await quickActionsStore.updateQuickAction(
-        "action-123",
-        "New Name",
-        "new prompt",
-        "new-icon"
-      );
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_quick_action",
-        expect.objectContaining({
-          action: expect.objectContaining({
-            id: "action-123",
-            name: "New Name",
-            prompt: "new prompt",
-            icon: "new-icon",
-            created_at: "2024-01-01T00:00:00Z",
-          }),
-        })
-      );
-    });
-
-    it("returns false for non-existent action", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.updateQuickAction(
-        "non-existent",
-        "Name",
-        "prompt",
-        "icon"
-      );
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Quick action not found for update");
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("deleteQuickAction", () => {
-    it("deletes action by ID", async () => {
-      setMockInvokeResult("delete_quick_action", undefined);
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.deleteQuickAction("action-123");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("delete_quick_action", { actionId: "action-123" });
-    });
-
-    it("handles delete errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("delete_quick_action", new Error("Cannot delete default action"));
-
-      const result = await quickActionsStore.deleteQuickAction("default-1");
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to delete quick action:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("resetDefaults", () => {
-    it("resets default actions", async () => {
-      setMockInvokeResult("reset_default_quick_actions", undefined);
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.resetDefaults();
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("reset_default_quick_actions");
-    });
-
-    it("handles reset errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("reset_default_quick_actions", new Error("Reset failed"));
-
-      const result = await quickActionsStore.resetDefaults();
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        "Failed to reset default quick actions:",
-        expect.any(Error)
-      );
-      consoleSpy.mockRestore();
-    });
-  });
-});
-
-describe("quick action ID generation", () => {
-  it("generates unique custom action IDs", () => {
-    const generateId = () => `custom-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id2).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("action validation", () => {
-  it("requires non-empty name", () => {
-    const action = { name: "" };
-    const isValid = action.name.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty prompt", () => {
-    const action = { prompt: "   " };
-    const isValid = action.prompt.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty icon", () => {
-    const action = { icon: "star" };
-    const isValid = action.icon.trim().length > 0;
-    expect(isValid).toBe(true);
-  });
-});
-
-describe("action icons", () => {
-  it("supports various icon names", () => {
-    const validIcons = [
-      "git-pull-request",
-      "play",
-      "file-text",
-      "alert-circle",
-      "check-square",
-      "refresh-cw",
-      "star",
-      "code",
-      "terminal",
-    ];
-
-    validIcons.forEach((icon) => {
-      expect(typeof icon).toBe("string");
-      expect(icon.length).toBeGreaterThan(0);
-    });
-  });
-});
-
-describe("action sorting", () => {
-  it("sorts default actions before custom actions", () => {
-    const actions = [
-      { id: "custom-1", name: "Custom", is_default: false },
-      { id: "default-1", name: "Default", is_default: true },
-    ];
-
-    const sorted = [...actions].sort((a, b) => {
-      const defaultCmp = (b.is_default ? 1 : 0) - (a.is_default ? 1 : 0);
-      if (defaultCmp !== 0) return defaultCmp;
-      return a.name.localeCompare(b.name);
-    });
-
-    expect(sorted[0].is_default).toBe(true);
-    expect(sorted[1].is_default).toBe(false);
-  });
-
-  it("sorts alphabetically within same default status", () => {
-    const actions = [
-      { id: "default-2", name: "Zebra", is_default: true },
-      { id: "default-1", name: "Apple", is_default: true },
-    ];
-
-    const sorted = [...actions].sort((a, b) => {
-      const defaultCmp = (b.is_default ? 1 : 0) - (a.is_default ? 1 : 0);
-      if (defaultCmp !== 0) return defaultCmp;
-      return a.name.localeCompare(b.name);
-    });
-
-    expect(sorted[0].name).toBe("Apple");
-    expect(sorted[1].name).toBe("Zebra");
-  });
-});
@@ -1,353 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { get } from "svelte/store";
-import { invoke } from "@tauri-apps/api/core";
-import { setMockInvokeResult } from "../../../vitest.setup";
-import { snippetsStore, type Snippet } from "./snippets";
-
-describe("Snippet interface", () => {
-  it("defines all required fields", () => {
-    const snippet: Snippet = {
-      id: "snippet-123",
-      name: "Git Status",
-      content: "git status",
-      category: "Git",
-      is_default: false,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(snippet.id).toBe("snippet-123");
-    expect(snippet.name).toBe("Git Status");
-    expect(snippet.content).toBe("git status");
-    expect(snippet.category).toBe("Git");
-    expect(snippet.is_default).toBe(false);
-    expect(snippet.created_at).toBe("2024-01-01T00:00:00Z");
-    expect(snippet.updated_at).toBe("2024-01-01T00:00:00Z");
-  });
-
-  it("supports default snippets", () => {
-    const defaultSnippet: Snippet = {
-      id: "default-git-status",
-      name: "Git Status",
-      content: "git status --short",
-      category: "Git",
-      is_default: true,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(defaultSnippet.is_default).toBe(true);
-  });
-});
-
-describe("snippetsStore", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("store structure", () => {
-    it("has all expected methods", () => {
-      expect(typeof snippetsStore.loadSnippets).toBe("function");
-      expect(typeof snippetsStore.saveSnippet).toBe("function");
-      expect(typeof snippetsStore.createSnippet).toBe("function");
-      expect(typeof snippetsStore.updateSnippet).toBe("function");
-      expect(typeof snippetsStore.deleteSnippet).toBe("function");
-      expect(typeof snippetsStore.resetDefaults).toBe("function");
-      expect(typeof snippetsStore.setSelectedCategory).toBe("function");
-    });
-
-    it("has subscribable stores", () => {
-      expect(typeof snippetsStore.snippets.subscribe).toBe("function");
-      expect(typeof snippetsStore.categories.subscribe).toBe("function");
-      expect(typeof snippetsStore.filteredSnippets.subscribe).toBe("function");
-      expect(typeof snippetsStore.isLoading.subscribe).toBe("function");
-      expect(typeof snippetsStore.selectedCategory.subscribe).toBe("function");
-    });
-  });
-
-  describe("loadSnippets", () => {
-    it("loads snippets and categories from backend", async () => {
-      const mockSnippets: Snippet[] = [
-        {
-          id: "snippet-1",
-          name: "Snippet 1",
-          content: "content 1",
-          category: "Git",
-          is_default: false,
-          created_at: "2024-01-01T00:00:00Z",
-          updated_at: "2024-01-01T00:00:00Z",
-        },
-      ];
-      const mockCategories = ["Git", "Shell", "Docker"];
-
-      setMockInvokeResult("list_snippets", mockSnippets);
-      setMockInvokeResult("get_snippet_categories", mockCategories);
-
-      await snippetsStore.loadSnippets();
-
-      expect(invoke).toHaveBeenCalledWith("list_snippets");
-      expect(invoke).toHaveBeenCalledWith("get_snippet_categories");
-    });
-
-    it("handles load errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_snippets", new Error("Failed to load"));
-
-      await snippetsStore.loadSnippets();
-
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to load snippets:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("saveSnippet", () => {
-    it("saves snippet and reloads list", async () => {
-      const snippet: Snippet = {
-        id: "snippet-123",
-        name: "Test",
-        content: "test content",
-        category: "Test",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("save_snippet", undefined);
-      setMockInvokeResult("list_snippets", [snippet]);
-      setMockInvokeResult("get_snippet_categories", ["Test"]);
-
-      const result = await snippetsStore.saveSnippet(snippet);
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("save_snippet", { snippet });
-    });
-
-    it("handles save errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("save_snippet", new Error("Failed to save"));
-
-      const snippet: Snippet = {
-        id: "snippet-123",
-        name: "Test",
-        content: "test content",
-        category: "Test",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      const result = await snippetsStore.saveSnippet(snippet);
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to save snippet:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("createSnippet", () => {
-    it("creates new snippet with generated ID and timestamps", async () => {
-      setMockInvokeResult("save_snippet", undefined);
-      setMockInvokeResult("list_snippets", []);
-      setMockInvokeResult("get_snippet_categories", ["Shell"]);
-
-      const result = await snippetsStore.createSnippet("My Snippet", "echo hello", "Shell");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_snippet",
-        expect.objectContaining({
-          snippet: expect.objectContaining({
-            name: "My Snippet",
-            content: "echo hello",
-            category: "Shell",
-            is_default: false,
-          }),
-        })
-      );
-    });
-  });
-
-  describe("updateSnippet", () => {
-    it("updates existing snippet preserving created_at", async () => {
-      const existingSnippet: Snippet = {
-        id: "snippet-123",
-        name: "Old Name",
-        content: "old content",
-        category: "Old Category",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("list_snippets", [existingSnippet]);
-      setMockInvokeResult("save_snippet", undefined);
-      setMockInvokeResult("get_snippet_categories", ["New Category"]);
-
-      const result = await snippetsStore.updateSnippet(
-        "snippet-123",
-        "New Name",
-        "new content",
-        "New Category"
-      );
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_snippet",
-        expect.objectContaining({
-          snippet: expect.objectContaining({
-            id: "snippet-123",
-            name: "New Name",
-            content: "new content",
-            category: "New Category",
-            created_at: "2024-01-01T00:00:00Z",
-          }),
-        })
-      );
-    });
-
-    it("returns false for non-existent snippet", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_snippets", []);
-
-      const result = await snippetsStore.updateSnippet(
-        "non-existent",
-        "Name",
-        "content",
-        "Category"
-      );
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Snippet not found for update");
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("deleteSnippet", () => {
-    it("deletes snippet by ID", async () => {
-      setMockInvokeResult("delete_snippet", undefined);
-      setMockInvokeResult("list_snippets", []);
-      setMockInvokeResult("get_snippet_categories", []);
-
-      const result = await snippetsStore.deleteSnippet("snippet-123");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("delete_snippet", { snippetId: "snippet-123" });
-    });
-
-    it("handles delete errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("delete_snippet", new Error("Cannot delete default snippet"));
-
-      const result = await snippetsStore.deleteSnippet("default-1");
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to delete snippet:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("resetDefaults", () => {
-    it("resets default snippets", async () => {
-      setMockInvokeResult("reset_default_snippets", undefined);
-      setMockInvokeResult("list_snippets", []);
-      setMockInvokeResult("get_snippet_categories", []);
-
-      const result = await snippetsStore.resetDefaults();
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("reset_default_snippets");
-    });
-
-    it("handles reset errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("reset_default_snippets", new Error("Reset failed"));
-
-      const result = await snippetsStore.resetDefaults();
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        "Failed to reset default snippets:",
-        expect.any(Error)
-      );
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("setSelectedCategory", () => {
-    it("updates selected category", () => {
-      snippetsStore.setSelectedCategory("Git");
-      expect(get(snippetsStore.selectedCategory)).toBe("Git");
-    });
-
-    it("can be cleared with null", () => {
-      snippetsStore.setSelectedCategory("Git");
-      snippetsStore.setSelectedCategory(null);
-      expect(get(snippetsStore.selectedCategory)).toBeNull();
-    });
-  });
-});
-
-describe("snippet ID generation", () => {
-  it("generates unique custom snippet IDs", () => {
-    const generateId = () => `custom-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id2).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("snippet validation", () => {
-  it("requires non-empty name", () => {
-    const snippet = { name: "" };
-    const isValid = snippet.name.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty content", () => {
-    const snippet = { content: "   " };
-    const isValid = snippet.content.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty category", () => {
-    const snippet = { category: "Git" };
-    const isValid = snippet.category.trim().length > 0;
-    expect(isValid).toBe(true);
-  });
-});
-
-describe("snippet content types", () => {
-  it("supports multiline content", () => {
-    const snippet = {
-      content: `git add .
-git commit -m "message"
-git push`,
-    };
-
-    expect(snippet.content.includes("\n")).toBe(true);
-    expect(snippet.content.split("\n")).toHaveLength(3);
-  });
-
-  it("supports content with special characters", () => {
-    const snippet = {
-      content: "echo \"Hello, World!\" && echo 'Single quotes'",
-    };
-
-    expect(snippet.content).toContain('"');
-    expect(snippet.content).toContain("'");
-    expect(snippet.content).toContain("&&");
-  });
-
-  it("supports content with variables", () => {
-    const snippet = {
-      content: "docker run -v $PWD:/app ${IMAGE_NAME}:${TAG}",
-    };
-
-    expect(snippet.content).toContain("$PWD");
-    expect(snippet.content).toContain("${IMAGE_NAME}");
-  });
-});
@@ -1,346 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { get } from "svelte/store";
-import { stats, formattedStats, resetSessionStats } from "./stats";
-import type { UsageStats } from "./stats";
-
-// Mock Tauri APIs
-vi.mock("@tauri-apps/api/event", () => ({
-  listen: vi.fn(),
-}));
-
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn(),
-}));
-
-describe("stats store", () => {
-  beforeEach(() => {
-    // Reset stats to default before each test
-    stats.set({
-      total_input_tokens: 0,
-      total_output_tokens: 0,
-      total_cost_usd: 0,
-      session_input_tokens: 0,
-      session_output_tokens: 0,
-      session_cost_usd: 0,
-      model: null,
-      messages_exchanged: 0,
-      session_messages_exchanged: 0,
-      code_blocks_generated: 0,
-      session_code_blocks_generated: 0,
-      files_edited: 0,
-      session_files_edited: 0,
-      files_created: 0,
-      session_files_created: 0,
-      tools_usage: {},
-      session_tools_usage: {},
-      session_duration_seconds: 0,
-    });
-  });
-
-  describe("stats writable store", () => {
-    it("has correct default values", () => {
-      const currentStats = get(stats);
-      expect(currentStats.total_input_tokens).toBe(0);
-      expect(currentStats.total_output_tokens).toBe(0);
-      expect(currentStats.total_cost_usd).toBe(0);
-      expect(currentStats.model).toBeNull();
-    });
-
-    it("can be updated with set", () => {
-      const newStats: UsageStats = {
-        total_input_tokens: 1000,
-        total_output_tokens: 2000,
-        total_cost_usd: 0.05,
-        session_input_tokens: 500,
-        session_output_tokens: 1000,
-        session_cost_usd: 0.025,
-        model: "claude-sonnet-4",
-        messages_exchanged: 10,
-        session_messages_exchanged: 5,
-        code_blocks_generated: 3,
-        session_code_blocks_generated: 2,
-        files_edited: 5,
-        session_files_edited: 2,
-        files_created: 1,
-        session_files_created: 1,
-        tools_usage: { Read: 5, Edit: 3 },
-        session_tools_usage: { Read: 2, Edit: 1 },
-        session_duration_seconds: 300,
-      };
-
-      stats.set(newStats);
-      const currentStats = get(stats);
-
-      expect(currentStats.total_input_tokens).toBe(1000);
-      expect(currentStats.total_output_tokens).toBe(2000);
-      expect(currentStats.model).toBe("claude-sonnet-4");
-      expect(currentStats.tools_usage).toEqual({ Read: 5, Edit: 3 });
-    });
-
-    it("can be updated with update function", () => {
-      stats.update((current) => ({
-        ...current,
-        total_input_tokens: 500,
-        session_messages_exchanged: 3,
-      }));
-
-      const currentStats = get(stats);
-      expect(currentStats.total_input_tokens).toBe(500);
-      expect(currentStats.session_messages_exchanged).toBe(3);
-    });
-  });
-
-  describe("resetSessionStats", () => {
-    it("resets all session fields to zero", () => {
-      // First set some values
-      stats.set({
-        total_input_tokens: 1000,
-        total_output_tokens: 2000,
-        total_cost_usd: 0.05,
-        session_input_tokens: 500,
-        session_output_tokens: 1000,
-        session_cost_usd: 0.025,
-        model: "claude-sonnet-4",
-        messages_exchanged: 10,
-        session_messages_exchanged: 5,
-        code_blocks_generated: 3,
-        session_code_blocks_generated: 2,
-        files_edited: 5,
-        session_files_edited: 2,
-        files_created: 1,
-        session_files_created: 1,
-        tools_usage: { Read: 5, Edit: 3 },
-        session_tools_usage: { Read: 2, Edit: 1 },
-        session_duration_seconds: 300,
-      });
-
-      // Reset session stats
-      resetSessionStats();
-
-      const currentStats = get(stats);
-
-      // Total stats should be preserved
-      expect(currentStats.total_input_tokens).toBe(1000);
-      expect(currentStats.total_output_tokens).toBe(2000);
-      expect(currentStats.total_cost_usd).toBe(0.05);
-      expect(currentStats.messages_exchanged).toBe(10);
-      expect(currentStats.code_blocks_generated).toBe(3);
-      expect(currentStats.files_edited).toBe(5);
-      expect(currentStats.files_created).toBe(1);
-      expect(currentStats.tools_usage).toEqual({ Read: 5, Edit: 3 });
-      expect(currentStats.model).toBe("claude-sonnet-4");
-
-      // Session stats should be reset
-      expect(currentStats.session_input_tokens).toBe(0);
-      expect(currentStats.session_output_tokens).toBe(0);
-      expect(currentStats.session_cost_usd).toBe(0);
-      expect(currentStats.session_messages_exchanged).toBe(0);
-      expect(currentStats.session_code_blocks_generated).toBe(0);
-      expect(currentStats.session_files_edited).toBe(0);
-      expect(currentStats.session_files_created).toBe(0);
-      expect(currentStats.session_tools_usage).toEqual({});
-      expect(currentStats.session_duration_seconds).toBe(0);
-    });
-  });
-
-  describe("formattedStats derived store", () => {
-    it("formats token numbers with locale string", () => {
-      stats.update((current) => ({
-        ...current,
-        total_input_tokens: 1234567,
-        total_output_tokens: 7654321,
-        session_input_tokens: 12345,
-        session_output_tokens: 54321,
-      }));
-
-      const formatted = get(formattedStats);
-
-      expect(formatted.totalTokens).toBe("8,888,888");
-      expect(formatted.totalInputTokens).toBe("1,234,567");
-      expect(formatted.totalOutputTokens).toBe("7,654,321");
-      expect(formatted.sessionTokens).toBe("66,666");
-      expect(formatted.sessionInputTokens).toBe("12,345");
-      expect(formatted.sessionOutputTokens).toBe("54,321");
-    });
-
-    it("formats cost with 4 decimal places", () => {
-      stats.update((current) => ({
-        ...current,
-        total_cost_usd: 1.23456,
-        session_cost_usd: 0.00123,
-      }));
-
-      const formatted = get(formattedStats);
-
-      expect(formatted.totalCost).toBe("$1.2346");
-      expect(formatted.sessionCost).toBe("$0.0012");
-    });
-
-    it("formats duration seconds only", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 45,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("45s");
-    });
-
-    it("formats duration minutes and seconds", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 125, // 2m 5s
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("2m 5s");
-    });
-
-    it("formats duration hours, minutes, and seconds", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 3725, // 1h 2m 5s
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("1h 2m 5s");
-    });
-
-    it("formats duration with zero seconds", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 3600, // exactly 1h
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("1h 0m 0s");
-    });
-
-    it("shows model name when available", () => {
-      stats.update((current) => ({
-        ...current,
-        model: "claude-opus-4-5",
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.model).toBe("claude-opus-4-5");
-    });
-
-    it("shows placeholder when model is null", () => {
-      stats.update((current) => ({
-        ...current,
-        model: null,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.model).toBe("No model selected");
-    });
-
-    it("formats message counts", () => {
-      stats.update((current) => ({
-        ...current,
-        messages_exchanged: 100,
-        session_messages_exchanged: 10,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.messagesTotal).toBe("100");
-      expect(formatted.messagesSession).toBe("10");
-    });
-
-    it("formats code block counts", () => {
-      stats.update((current) => ({
-        ...current,
-        code_blocks_generated: 50,
-        session_code_blocks_generated: 5,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.codeBlocksTotal).toBe("50");
-      expect(formatted.codeBlocksSession).toBe("5");
-    });
-
-    it("formats file counts", () => {
-      stats.update((current) => ({
-        ...current,
-        files_edited: 25,
-        session_files_edited: 3,
-        files_created: 10,
-        session_files_created: 2,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.filesEditedTotal).toBe("25");
-      expect(formatted.filesEditedSession).toBe("3");
-      expect(formatted.filesCreatedTotal).toBe("10");
-      expect(formatted.filesCreatedSession).toBe("2");
-    });
-
-    it("exposes tools usage directly", () => {
-      const toolsUsage = { Read: 10, Edit: 5, Write: 3 };
-      const sessionToolsUsage = { Read: 2, Edit: 1 };
-
-      stats.update((current) => ({
-        ...current,
-        tools_usage: toolsUsage,
-        session_tools_usage: sessionToolsUsage,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.toolsUsage).toEqual(toolsUsage);
-      expect(formatted.sessionToolsUsage).toEqual(sessionToolsUsage);
-    });
-
-    it("handles zero values correctly", () => {
-      const formatted = get(formattedStats);
-
-      expect(formatted.totalTokens).toBe("0");
-      expect(formatted.totalCost).toBe("$0.0000");
-      expect(formatted.sessionDuration).toBe("0s");
-      expect(formatted.messagesTotal).toBe("0");
-    });
-
-    it("handles large numbers with proper formatting", () => {
-      stats.update((current) => ({
-        ...current,
-        total_input_tokens: 1000000000, // 1 billion
-        messages_exchanged: 999999,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.totalInputTokens).toBe("1,000,000,000");
-      expect(formatted.messagesTotal).toBe("999,999");
-    });
-  });
-
-  describe("UsageStats interface", () => {
-    it("supports all expected fields", () => {
-      const fullStats: UsageStats = {
-        total_input_tokens: 100,
-        total_output_tokens: 200,
-        total_cost_usd: 0.01,
-        session_input_tokens: 50,
-        session_output_tokens: 100,
-        session_cost_usd: 0.005,
-        model: "test-model",
-        messages_exchanged: 5,
-        session_messages_exchanged: 2,
-        code_blocks_generated: 3,
-        session_code_blocks_generated: 1,
-        files_edited: 2,
-        session_files_edited: 1,
-        files_created: 1,
-        session_files_created: 0,
-        tools_usage: { Read: 3 },
-        session_tools_usage: { Read: 1 },
-        session_duration_seconds: 60,
-      };
-
-      stats.set(fullStats);
-      const currentStats = get(stats);
-
-      // Verify all fields are present and correct
-      expect(currentStats).toEqual(fullStats);
-    });
-  });
-});
@@ -104,11 +104,10 @@ export async function initStatsListener() {
    stats.set(newStats);
  });

-  // Load initial persisted stats from backend (no bridge required)
+  // Load initial stats from backend
  try {
-    const initialStats = await invoke<UsageStats>("get_persisted_stats");
+    const initialStats = await invoke<UsageStats>("get_usage_stats");
    stats.set(initialStats);
-    console.log("Loaded persisted stats:", initialStats);
  } catch (error) {
    console.error("Failed to load initial stats:", error);
  }
@@ -1,388 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { emitMockEvent, setMockInvokeResult } from "../../vitest.setup";
-
-// We need to test the helper functions that are exported
-// The main listener initialization is tested through integration
-
-describe("tauri helpers", () => {
-  describe("getTimeOfDay (inferred from greeting behavior)", () => {
-    it("returns morning for hours 5-11", () => {
-      const date = new Date();
-      date.setHours(8, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      // The getTimeOfDay function is private, but we can verify the greeting prompt includes the time
-      // This tests the logic indirectly
-      expect(date.getHours()).toBeGreaterThanOrEqual(5);
-      expect(date.getHours()).toBeLessThan(12);
-    });
-
-    it("returns afternoon for hours 12-16", () => {
-      const date = new Date();
-      date.setHours(14, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      expect(date.getHours()).toBeGreaterThanOrEqual(12);
-      expect(date.getHours()).toBeLessThan(17);
-    });
-
-    it("returns evening for hours 17-20", () => {
-      const date = new Date();
-      date.setHours(19, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      expect(date.getHours()).toBeGreaterThanOrEqual(17);
-      expect(date.getHours()).toBeLessThan(21);
-    });
-
-    it("returns late night for hours 21-4", () => {
-      const date = new Date();
-      date.setHours(23, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      expect(date.getHours() >= 21 || date.getHours() < 5).toBe(true);
-    });
-  });
-});
-
-describe("tauri event handling", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  describe("connection events", () => {
-    it("emits connected status payload", () => {
-      const payload = {
-        status: "connected",
-        conversation_id: "test-conv-1",
-      };
-
-      // Verify payload structure
-      expect(payload.status).toBe("connected");
-      expect(payload.conversation_id).toBe("test-conv-1");
-    });
-
-    it("emits disconnected status payload", () => {
-      const payload = {
-        status: "disconnected",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.status).toBe("disconnected");
-    });
-
-    it("emits error status payload", () => {
-      const payload = {
-        status: "error",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.status).toBe("error");
-    });
-  });
-
-  describe("state change events", () => {
-    it("maps idle state correctly", () => {
-      const payload = {
-        state: "idle",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("idle");
-    });
-
-    it("maps thinking state correctly", () => {
-      const payload = {
-        state: "thinking",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("thinking");
-    });
-
-    it("maps typing state correctly", () => {
-      const payload = {
-        state: "typing",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("typing");
-    });
-
-    it("maps searching state correctly", () => {
-      const payload = {
-        state: "searching",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("searching");
-    });
-
-    it("maps coding state correctly", () => {
-      const payload = {
-        state: "coding",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("coding");
-    });
-
-    it("maps mcp state correctly", () => {
-      const payload = {
-        state: "mcp",
-        tool_name: "some-tool",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("mcp");
-      expect(payload.tool_name).toBe("some-tool");
-    });
-
-    it("maps permission state correctly", () => {
-      const payload = {
-        state: "permission",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("permission");
-    });
-
-    it("maps success state correctly", () => {
-      const payload = {
-        state: "success",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("success");
-    });
-
-    it("maps error state correctly", () => {
-      const payload = {
-        state: "error",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("error");
-    });
-
-    it("defaults unknown state to idle", () => {
-      const stateMap: Record<string, string> = {
-        idle: "idle",
-        thinking: "thinking",
-        typing: "typing",
-        searching: "searching",
-        coding: "coding",
-        mcp: "mcp",
-        permission: "permission",
-        success: "success",
-        error: "error",
-      };
-
-      const unknownState = "unknown-state";
-      const mappedState = stateMap[unknownState.toLowerCase()] || "idle";
-      expect(mappedState).toBe("idle");
-    });
-  });
-
-  describe("output events", () => {
-    it("handles user output type", () => {
-      const payload = {
-        line_type: "user",
-        content: "Hello, world!",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("user");
-      expect(payload.content).toBe("Hello, world!");
-    });
-
-    it("handles assistant output type", () => {
-      const payload = {
-        line_type: "assistant",
-        content: "Hi there!",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("assistant");
-    });
-
-    it("handles system output type", () => {
-      const payload = {
-        line_type: "system",
-        content: "Connected to Claude Code",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("system");
-    });
-
-    it("handles tool output type with tool name", () => {
-      const payload = {
-        line_type: "tool",
-        content: "Tool executed successfully",
-        tool_name: "Read",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("tool");
-      expect(payload.tool_name).toBe("Read");
-    });
-
-    it("handles error output type", () => {
-      const payload = {
-        line_type: "error",
-        content: "An error occurred",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("error");
-    });
-  });
-
-  describe("session events", () => {
-    it("handles session payload with conversation id", () => {
-      const payload = {
-        session_id: "sess-12345678",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.session_id).toBe("sess-12345678");
-      expect(payload.conversation_id).toBe("test-conv-1");
-    });
-
-    it("creates truncated session display", () => {
-      const sessionId = "sess-12345678-90ab-cdef";
-      const display = `Session: ${sessionId.substring(0, 8)}...`;
-
-      expect(display).toBe("Session: sess-123...");
-    });
-  });
-
-  describe("working directory events", () => {
-    it("handles cwd payload", () => {
-      const payload = {
-        directory: "/home/user/project",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.directory).toBe("/home/user/project");
-    });
-  });
-
-  describe("permission events", () => {
-    it("handles permission payload structure", () => {
-      const payload = {
-        id: "perm-123",
-        tool_name: "Bash",
-        tool_input: '{"command": "ls -la"}',
-        description: "Run shell command",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.id).toBe("perm-123");
-      expect(payload.tool_name).toBe("Bash");
-      expect(payload.tool_input).toContain("command");
-      expect(payload.description).toBe("Run shell command");
-    });
-  });
-
-  describe("question events", () => {
-    it("handles question payload structure", () => {
-      const payload = {
-        id: "q-123",
-        question: "Which option would you like?",
-        options: [
-          { label: "Option A", description: "First option" },
-          { label: "Option B", description: "Second option" },
-        ],
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.id).toBe("q-123");
-      expect(payload.question).toBe("Which option would you like?");
-      expect(payload.options).toHaveLength(2);
-    });
-  });
-});
-
-describe("mock event system", () => {
-  it("can emit events through mock system", () => {
-    // The emitMockEvent function should work
-    expect(typeof emitMockEvent).toBe("function");
-  });
-
-  it("can set mock invoke results", () => {
-    setMockInvokeResult("test_command", { result: "success" });
-    // This verifies the mock setup is working
-    expect(typeof setMockInvokeResult).toBe("function");
-  });
-});
-
-describe("greeting system", () => {
-  it("generates greeting prompt with time of day", () => {
-    const timeOfDay = "morning";
-    const prompt = `[System: A new session has started. It's currently ${timeOfDay}. Please greet the user warmly and briefly. Keep it short - just 1-2 sentences.]`;
-
-    expect(prompt).toContain("morning");
-    expect(prompt).toContain("greet the user");
-  });
-
-  it("uses custom greeting prompt when provided", () => {
-    const customPrompt = "Say hello in pirate speak!";
-    const greetingPrompt = customPrompt.trim() || "default greeting";
-
-    expect(greetingPrompt).toBe("Say hello in pirate speak!");
-  });
-
-  it("uses default prompt when custom is empty", () => {
-    const customPrompt = "   ";
-    const defaultPrompt = "default greeting";
-    const greetingPrompt = customPrompt.trim() || defaultPrompt;
-
-    expect(greetingPrompt).toBe(defaultPrompt);
-  });
-});
-
-describe("conversation tracking", () => {
-  it("tracks connected conversations with Set", () => {
-    const connectedConversations = new Set<string>();
-
-    connectedConversations.add("conv-1");
-    expect(connectedConversations.has("conv-1")).toBe(true);
-    expect(connectedConversations.size).toBe(1);
-
-    connectedConversations.add("conv-2");
-    expect(connectedConversations.size).toBe(2);
-
-    connectedConversations.delete("conv-1");
-    expect(connectedConversations.has("conv-1")).toBe(false);
-    expect(connectedConversations.size).toBe(1);
-  });
-});
-
-describe("skip greeting flag", () => {
-  it("flag can be set and reset", () => {
-    let skipNextGreeting = false;
-
-    skipNextGreeting = true;
-    expect(skipNextGreeting).toBe(true);
-
-    // Simulate reset after use
-    if (skipNextGreeting) {
-      skipNextGreeting = false;
-    }
-    expect(skipNextGreeting).toBe(false);
-  });
-});
@@ -14,52 +14,34 @@ export type AchievementId =
  | "GrowingStrong" // 10,000 tokens
  | "BlossomingCoder" // 100,000 tokens
  | "TokenMaster" // 1,000,000 tokens
-  | "TokenBillionaire" // 10,000,000 tokens
-  | "TokenTreasure" // 50,000,000 tokens
-
  // Code Generation
  | "HelloWorld" // First code block
  | "CodeWizard" // 100 code blocks
  | "ThousandBlocks" // 1,000 code blocks
-  | "CodeFactory" // 5,000 code blocks
-  | "CodeEmpire" // 10,000 code blocks
-
  // File Operations
  | "FileManipulator" // 10 files edited
  | "FileArchitect" // 100 files edited
-  | "FileEngineer" // 500 files edited
-  | "FileLegend" // 1,000 files edited
-
  // Conversation milestones
  | "ConversationStarter" // 10 messages
  | "ChattyKathy" // 100 messages
  | "Conversationalist" // 1,000 messages
-  | "ChatMarathon" // 5,000 messages
-  | "ChatLegend" // 10,000 messages
-
  // Tool usage
  | "Toolsmith" // 5 different tools
  | "ToolMaster" // 10 different tools
-
  // Time-based achievements
  | "EarlyBird" // Started session 5-7 AM
  | "NightOwl" // Coding after midnight
  | "AllNighter" // Worked 2-5 AM
  | "WeekendWarrior" // Coding on weekend
  | "DedicatedDeveloper" // 30 days in a row
-
  // Search and exploration
  | "Explorer" // 50 searches
  | "MasterSearcher" // 500 searches
-
  // Session achievements
  | "QuickSession" // Productive session < 5 min
  | "FocusedWork" // 30 min session
  | "DeepDive" // 2 hour session
  | "MarathonSession" // 5+ hour session
-  | "UltraMarathon" // 8 hour session
-  | "CodingRetreat" // 12 hour session
-
  // Special achievements
  | "FirstMessage" // First message sent
  | "FirstTool" // First tool used
@@ -69,165 +51,28 @@ export type AchievementId =
  | "SpeedCoder" // 10 code blocks in 10 minutes
  | "ClaudeConnoisseur" // Used all Claude models
  | "MarathonCoder" // 10k tokens in one session
-
  // Relationship & Greetings
-  | "GoodMorning" // Say "good morning"
-  | "GoodNight" // Say "good night" or "goodnight"
-  | "ThankYou" // Say "thank you" or "thanks"
-  | "LoveYou" // Say "love you" or "ily"
-  | "HelloHikari" // Say "hello hikari" or "hi hikari"
-  | "HowAreYou" // Ask "how are you"
-  | "MissedYou" // Say "missed you"
-  | "BackAgain" // Say "i'm back" or "back again"
-
+  | "GoodMorning" // Said good morning
+  | "GoodNight" // Said good night
+  | "ThankYou" // Said thank you
+  | "LoveYou" // Said love you
  // Personality & Fun
-  | "EmojiUser" // Use an emoji in a message
-  | "QuestionMaster" // Use "?" in 20 messages
-  | "CapsLock" // Send a message in ALL CAPS
-  | "PleaseAndThankYou" // Use "please" in messages
-
-  // Emotional
-  | "Frustrated" // Say "frustrated" or "ugh" or "argh"
-  | "Excited" // Say "excited" or "yay" or "woohoo"
-  | "Confused" // Say "confused" or "don't understand"
-  | "Curious" // Ask "why" or "how does"
-  | "Impressed" // Say "wow" or "amazing" or "incredible"
-
+  | "EmojiUser" // Used 20+ emojis
+  | "CapsLock" // ALL CAPS MESSAGE
+  | "QuestionMaster" // Asked 50 questions
+  | "PleaseAndThankYou" // Polite user
  // Git & Development
-  | "GitGuru" // Use git commands 10 times
-  | "TestWriter" // Create test files
-  | "Debugger" // Fix bugs (messages with "fix", "bug", "error")
-  | "CommitKing" // 50 commits
-  | "CommitLegend" // 200 commits
-  | "BranchMaster" // Create 10 branches
-  | "MergeExpert" // Merge 20 PRs
-  | "ConflictResolver" // Resolve merge conflicts
-
+  | "CommitMaster" // 100 commits
+  | "PRO" // Created 10 PRs
+  | "Reviewer" // Reviewed 10 PRs
+  | "IssueTracker" // Created 25 issues
+  | "GitGuru" // Used git commands
  // Tool Mastery
-  | "BashMaster" // Use Bash tool 50 times
-  | "FileExplorer" // Use Read tool 100 times
-  | "SearchExpert" // Use Grep tool 50 times
-  | "EditMaster" // Use Edit tool 100 times
-  | "WriteMaster" // Use Write tool 50 times
-  | "GlobMaster" // Use Glob tool 100 times
-  | "TaskMaster" // Use Task tool 50 times
-  | "WebFetcher" // Use WebFetch tool 20 times
-  | "McpExplorer" // Use MCP tools 50 times
-
-  // Daily Streaks
-  | "WeekStreak" // 7 days in a row
-  | "TwoWeekStreak" // 14 days in a row
-  | "MonthStreak" // 30 days in a row
-  | "QuarterStreak" // 90 days in a row
-
-  // Time Challenges
-  | "MorningPerson" // 10 sessions started before 9 AM
-  | "NightCoder" // 10 sessions after 10 PM
-  | "LunchBreakCoder" // Session during 12-1 PM
-  | "CoffeeTime" // Session during 3-4 PM
-
-  // Day-specific
-  | "MondayMotivation" // Coding on Monday
-  | "FridayFinisher" // Coding on Friday
-  | "HumpDay" // Coding on Wednesday
-
-  // Seasonal/Special Times
-  | "NewYearCoder" // Coding on January 1st
-  | "ValentinesDev" // Coding on February 14th
-  | "SpookyCode" // Coding on October 31st
-  | "HolidayCoder" // Coding on December 25th
-  | "LeapDayCoder" // Coding on February 29th
-
-  // Message Content
-  | "LongMessage" // Send a message over 500 characters
-  | "NovelWriter" // Send a message over 2000 characters
-  | "ShortAndSweet" // Complete a task with messages under 50 chars each
-  | "CodeInMessage" // Include code block in user message
-  | "MarkdownMaster" // Use markdown formatting in message
-
-  // Programming Languages
-  | "RustDeveloper" // Generate Rust code
-  | "PythonDeveloper" // Generate Python code
-  | "JavaScriptDev" // Generate JavaScript code
-  | "TypeScriptDev" // Generate TypeScript code
-  | "GoDeveloper" // Generate Go code
-  | "CppDeveloper" // Generate C++ code
-  | "JavaDeveloper" // Generate Java code
-  | "HtmlCssDev" // Generate HTML/CSS code
-  | "SqlDeveloper" // Generate SQL code
-  | "ShellScripter" // Generate shell/bash scripts
-  | "FullStackDev" // Generate code in 10+ languages
-
-  // Project Types
-  | "FrontendDev" // Work on frontend files
-  | "BackendDev" // Work on backend files
-  | "ConfigEditor" // Edit config files
-  | "DocWriter" // Edit documentation
-
-  // Error Handling
-  | "ErrorHunter" // Fix 10 errors
-  | "ExceptionSlayer" // Fix 50 errors
-  | "BugExterminator" // Fix 100 bugs
-
-  // Refactoring
-  | "CleanCoder" // Refactor code
-  | "Optimizer" // Optimize performance
-  | "Simplifier" // Simplify complex code
-
-  // Testing
-  | "TestNovice" // Write 10 tests
-  | "TestEnthusiast" // Write 50 tests
-  | "TestMaster" // Write 100 tests
-  | "CoverageKing" // Achieve test coverage mentions
-
-  // Documentation
-  | "Documenter" // Write documentation
-  | "CommentWriter" // Add comments to code
-  | "ReadmeHero" // Create/edit README files
-
-  // API & Integration
-  | "ApiExplorer" // Work with APIs
-  | "DatabaseDev" // Work with databases
-  | "CloudCoder" // Work with cloud services
-
-  // Special Milestones
-  | "CenturyClub" // 100 sessions
-  | "ThousandSessions" // 1000 sessions
-  | "Veteran" // Used Hikari for 30+ days total
-  | "OldTimer" // Used Hikari for 90+ days total
-  | "Loyalist" // Used Hikari for 365+ days total
-
-  // Fun & Easter Eggs
-  | "Perfectionist" // Redo something 5 times
-  | "Persistent" // Ask same question 3 times
-  | "Patient" // Wait for long response
-  | "Speedy" // Send 10 messages in 1 minute
-
-  // UI Exploration
-  | "MultiTasker" // Multiple conversations
-  | "Minimalist" // Use compact mode
-  | "PrivacyFirst" // Use streamer mode
-  | "ThemeChanger" // Change themes
-  | "SettingsTweaker" // Adjust settings
-
-  // Achievement Meta
-  | "AchievementHunter" // Unlock 25 achievements
-  | "Completionist" // Unlock 50 achievements
-  | "MasterUnlocker" // Unlock 100 achievements
-  | "PlatinumStatus" // Unlock all achievements
-
-  // Clipboard & Snippets
-  | "ClipboardCollector" // Use clipboard history
-  | "SnippetCreator" // Create a snippet
-  | "SnippetMaster" // Create 20 snippets
-
-  // Other Features
-  | "QuickActionUser" // Use quick actions
-  | "HistoryBuff" // Browse history
-  | "Archivist" // Export sessions
-  | "SessionExporter" // Export a session
-  | "GitPanelUser" // Use Git panel
-  | "FeatureExplorer"; // Use 10+ features
+  | "BashMaster" // Used bash 100 times
+  | "FileExplorer" // Searched files 100 times
+  | "SearchExpert" // Advanced searches
+  | "AgentCommander" // Used task agents
+  | "MCPMaster"; // Used MCP tools

 export interface Achievement {
  id: AchievementId;
@@ -24,7 +24,7 @@
  import UpdateNotification from "$lib/components/UpdateNotification.svelte";

  let initialized = false;
-  let updateNotification: UpdateNotification | undefined = $state(undefined);
+  let updateNotification: UpdateNotification;
  let achievementPanelOpen = $state(false);
  let currentCharacterState: CharacterState = $state("idle");
  let compactModeActive = $state(false);
@@ -255,7 +255,7 @@

      // Apply saved settings on startup
      const config = configStore.getConfig();
-      applyTheme(config.theme, config.custom_theme_colors);
+      applyTheme(config.theme);
      applyFontSize(config.font_size);

      // Apply always-on-top setting
@@ -375,9 +375,6 @@
    -webkit-mask:
      linear-gradient(#fff 0 0) content-box,
      linear-gradient(#fff 0 0);
-    mask:
-      linear-gradient(#fff 0 0) content-box,
-      linear-gradient(#fff 0 0);
    -webkit-mask-composite: xor;
    mask-composite: exclude;
    opacity: 0;
@@ -8,23 +8,5 @@ export default defineConfig({
    environment: "jsdom",
    setupFiles: ["./vitest.setup.ts"],
    globals: true,
-    coverage: {
-      provider: "v8",
-      reporter: ["text", "json", "html"],
-      reportsDirectory: "./coverage",
-      include: ["src/lib/**/*.ts"],
-      exclude: [
-        "src/lib/**/*.test.ts",
-        "src/lib/**/*.spec.ts",
-        "src/lib/**/*.d.ts",
-        "src/lib/components/**",
-      ],
-      thresholds: {
-        statements: 15,
-        branches: 13,
-        functions: 13,
-        lines: 15,
-      },
-    },
  },
 });
@@ -1,288 +1 @@
 import "@testing-library/jest-dom/vitest";
-import { vi, beforeEach } from "vitest";
-
-// Mock Tauri invoke API
-const mockInvokeResults: Record<string, unknown> = {};
-
-export function setMockInvokeResult(command: string, result: unknown) {
-  mockInvokeResults[command] = result;
-}
-
-export function clearMockInvokeResults() {
-  Object.keys(mockInvokeResults).forEach((key) => delete mockInvokeResults[key]);
-}
-
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn((command: string) => {
-    if (command in mockInvokeResults) {
-      const result = mockInvokeResults[command];
-      if (result instanceof Error) {
-        return Promise.reject(result);
-      }
-      return Promise.resolve(result);
-    }
-    // Default return values for common commands
-    switch (command) {
-      case "get_config":
-        return Promise.resolve({
-          model: null,
-          api_key: null,
-          custom_instructions: null,
-          mcp_servers_json: null,
-          auto_granted_tools: [],
-          theme: "dark",
-          greeting_enabled: true,
-          greeting_custom_prompt: null,
-          notifications_enabled: true,
-          notification_volume: 0.7,
-          always_on_top: false,
-          update_checks_enabled: true,
-          character_panel_width: null,
-          font_size: 14,
-          minimize_to_tray: false,
-          streamer_mode: false,
-          streamer_hide_paths: false,
-          compact_mode: false,
-          profile_name: null,
-          profile_avatar_path: null,
-          profile_bio: null,
-          custom_theme_colors: {},
-        });
-      case "list_quick_actions":
-        return Promise.resolve([]);
-      case "list_snippets":
-        return Promise.resolve([]);
-      case "list_sessions":
-        return Promise.resolve([]);
-      case "get_usage_stats":
-        return Promise.resolve({
-          total_messages: 0,
-          total_sessions: 0,
-          total_tokens: 0,
-          total_cost: 0,
-        });
-      case "get_persisted_stats":
-        return Promise.resolve({
-          lifetime_messages: 0,
-          lifetime_sessions: 0,
-          lifetime_tokens: 0,
-          lifetime_cost: 0,
-          achievements: [],
-          unlocked_achievements: [],
-        });
-      case "load_saved_achievements":
-        return Promise.resolve([]);
-      case "list_clipboard_entries":
-        return Promise.resolve([]);
-      case "cleanup_temp_files":
-        return Promise.resolve();
-      case "validate_directory":
-        return Promise.resolve(true);
-      case "git_status":
-        return Promise.resolve({
-          branch: "main",
-          files: [],
-          ahead: 0,
-          behind: 0,
-        });
-      default:
-        return Promise.resolve(null);
-    }
-  }),
-}));
-
-// Mock Tauri event API
-const eventListeners: Map<string, Array<(event: { payload: unknown }) => void>> = new Map();
-
-export function emitMockEvent(eventName: string, payload: unknown) {
-  const listeners = eventListeners.get(eventName) || [];
-  listeners.forEach((listener) => listener({ payload }));
-}
-
-export function clearMockEventListeners() {
-  eventListeners.clear();
-}
-
-vi.mock("@tauri-apps/api/event", () => ({
-  listen: vi.fn((eventName: string, handler: (event: { payload: unknown }) => void) => {
-    const listeners = eventListeners.get(eventName) || [];
-    listeners.push(handler);
-    eventListeners.set(eventName, listeners);
-    // Return an unlisten function
-    return Promise.resolve(() => {
-      const currentListeners = eventListeners.get(eventName) || [];
-      const index = currentListeners.indexOf(handler);
-      if (index > -1) {
-        currentListeners.splice(index, 1);
-      }
-    });
-  }),
-  emit: vi.fn(),
-}));
-
-// Mock Tauri plugins
-vi.mock("@tauri-apps/plugin-dialog", () => ({
-  save: vi.fn(() => Promise.resolve(null)),
-  open: vi.fn(() => Promise.resolve(null)),
-  message: vi.fn(() => Promise.resolve()),
-  ask: vi.fn(() => Promise.resolve(true)),
-  confirm: vi.fn(() => Promise.resolve(true)),
-}));
-
-vi.mock("@tauri-apps/plugin-fs", () => ({
-  writeTextFile: vi.fn(() => Promise.resolve()),
-  readTextFile: vi.fn(() => Promise.resolve("{}")),
-  exists: vi.fn(() => Promise.resolve(false)),
-  mkdir: vi.fn(() => Promise.resolve()),
-  remove: vi.fn(() => Promise.resolve()),
-  readDir: vi.fn(() => Promise.resolve([])),
-}));
-
-vi.mock("@tauri-apps/plugin-opener", () => ({
-  openPath: vi.fn(() => Promise.resolve()),
-  openUrl: vi.fn(() => Promise.resolve()),
-}));
-
-vi.mock("@tauri-apps/plugin-notification", () => ({
-  sendNotification: vi.fn(() => Promise.resolve()),
-  requestPermission: vi.fn(() => Promise.resolve("granted")),
-  isPermissionGranted: vi.fn(() => Promise.resolve(true)),
-}));
-
-vi.mock("@tauri-apps/plugin-clipboard-manager", () => ({
-  writeText: vi.fn(() => Promise.resolve()),
-  readText: vi.fn(() => Promise.resolve("")),
-  writeImage: vi.fn(() => Promise.resolve()),
-  readImage: vi.fn(() => Promise.resolve(null)),
-}));
-
-vi.mock("@tauri-apps/plugin-os", () => ({
-  platform: vi.fn(() => Promise.resolve("linux")),
-  arch: vi.fn(() => Promise.resolve("x86_64")),
-  type: vi.fn(() => Promise.resolve("Linux")),
-  version: vi.fn(() => Promise.resolve("1.0.0")),
-}));
-
-vi.mock("@tauri-apps/plugin-http", () => ({
-  fetch: vi.fn(() =>
-    Promise.resolve({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve(""),
-    })
-  ),
-}));
-
-// Mock browser APIs
-class MockAudioElement {
-  src = "";
-  volume = 1;
-  loop = false;
-  currentTime = 0;
-  paused = true;
-  preload = "auto";
-  onloadeddata: (() => void) | null = null;
-  onended: (() => void) | null = null;
-  onerror: ((e: Event) => void) | null = null;
-
-  play() {
-    this.paused = false;
-    return Promise.resolve();
-  }
-
-  pause() {
-    this.paused = true;
-  }
-
-  load() {
-    if (this.onloadeddata) {
-      setTimeout(() => this.onloadeddata?.(), 0);
-    }
-  }
-
-  addEventListener(event: string, handler: () => void) {
-    if (event === "loadeddata") this.onloadeddata = handler;
-    if (event === "ended") this.onended = handler;
-  }
-
-  removeEventListener() {
-    // No-op for tests
-  }
-}
-
-// @ts-expect-error - Mock Audio constructor
-globalThis.Audio = MockAudioElement;
-
-// Mock localStorage
-const localStorageStore: Record<string, string> = {};
-
-Object.defineProperty(globalThis, "localStorage", {
-  value: {
-    getItem: vi.fn((key: string) => localStorageStore[key] || null),
-    setItem: vi.fn((key: string, value: string) => {
-      localStorageStore[key] = value;
-    }),
-    removeItem: vi.fn((key: string) => {
-      delete localStorageStore[key];
-    }),
-    clear: vi.fn(() => {
-      Object.keys(localStorageStore).forEach((key) => delete localStorageStore[key]);
-    }),
-    key: vi.fn((index: number) => Object.keys(localStorageStore)[index] || null),
-    get length() {
-      return Object.keys(localStorageStore).length;
-    },
-  },
-  writable: true,
-});
-
-// Mock matchMedia
-Object.defineProperty(globalThis, "matchMedia", {
-  writable: true,
-  value: vi.fn((query: string) => ({
-    matches: query.includes("dark"),
-    media: query,
-    onchange: null,
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-  })),
-});
-
-// Mock ResizeObserver
-class MockResizeObserver {
-  observe = vi.fn();
-  unobserve = vi.fn();
-  disconnect = vi.fn();
-}
-
-globalThis.ResizeObserver = MockResizeObserver as unknown as typeof ResizeObserver;
-
-// Mock IntersectionObserver
-class MockIntersectionObserver {
-  observe = vi.fn();
-  unobserve = vi.fn();
-  disconnect = vi.fn();
-}
-
-globalThis.IntersectionObserver =
-  MockIntersectionObserver as unknown as typeof IntersectionObserver;
-
-// Mock requestAnimationFrame
-globalThis.requestAnimationFrame = vi.fn((callback) => {
-  return setTimeout(callback, 0) as unknown as number;
-});
-
-globalThis.cancelAnimationFrame = vi.fn((id) => {
-  clearTimeout(id);
-});
-
-// Reset all mocks before each test
-beforeEach(() => {
-  vi.clearAllMocks();
-  clearMockInvokeResults();
-  clearMockEventListeners();
-});
Author	SHA1	Message	Date
hikari	43f92f227c	style: fix lint errors and format issues Security Scan and Upload / Security & DefectDojo Upload (pull_request) Successful in 52s Details CI / Lint & Test (pull_request) Successful in 14m33s Details CI / Build Linux (pull_request) Successful in 18m56s Details CI / Build Windows (cross-compile) (pull_request) Successful in 28m46s Details - Remove unused configStore import from CompactMode.svelte - Add key to each block in CompactMode.svelte - Fix useless escape characters in config.ts path masking - Apply Prettier formatting to StatusBar, Terminal, and +page.svelte	2026-01-25 19:09:03 -08:00
hikari	c5e0d5302c	feat: add compact mode for minimal widget interface (#36 ) Security Scan and Upload / Security & DefectDojo Upload (pull_request) Successful in 54s Details CI / Lint & Test (pull_request) Failing after 5m38s Details CI / Build Linux (pull_request) Has been skipped Details CI / Build Windows (cross-compile) (pull_request) Has been skipped Details Add a compact mode that shrinks the window to a small widget showing just the character sprite, recent messages, and a quick input box. Perfect for quick questions while working without the full UI. - Add CompactMode.svelte component with minimal widget interface - Add compact mode toggle in StatusBar (Ctrl+Shift+M shortcut) - Save/restore window size when toggling compact mode - Handle display scaling by converting physical to logical pixels - Add compact_mode to config (Rust + TypeScript) - Add required Tauri window permissions for resize operations	2026-01-25 18:51:39 -08:00
hikari	ff50b28641	feat: add streamer mode for privacy during streaming CI / Lint & Test (pull_request) Failing after 5m40s Details CI / Build Linux (pull_request) Has been skipped Details CI / Build Windows (cross-compile) (pull_request) Has been skipped Details Security Scan and Upload / Security & DefectDojo Upload (pull_request) Successful in 49s Details - Add quick toggle button in InputBar for easy access - Mask API keys in settings when streamer mode active - Optional path masking to hide usernames in file paths - Visual LIVE indicator in both InputBar and StatusBar - Keyboard shortcut Ctrl+Shift+S for quick toggle - Privacy section in settings for additional options Closes #35	2026-01-25 18:15:47 -08:00
naomi	0ac52c8c8d	style: apply linter formatting and eslint-disable comments Security Scan and Upload / Security & DefectDojo Upload (pull_request) Successful in 55s Details CI / Lint & Test (pull_request) Successful in 14m40s Details CI / Build Linux (pull_request) Successful in 19m9s Details CI / Build Windows (cross-compile) (pull_request) Successful in 28m34s Details - Format multiline CSS gradients for readability - Clean up whitespace in Svelte components - Add eslint-disable comments for controlled @html directives - Format function signatures consistently Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 17:41:20 -08:00
naomi	0a73d2238c	feat: add clipboard history for code snippets Implements issue #25 - Clipboard History feature that tracks copied code snippets with language detection, search, and filtering. Backend (Rust): - New clipboard.rs module with persistent storage via tauri-plugin-store - Commands: capture, list, delete, toggle pin, clear, search, update language - Auto-deduplication and max history size (100 entries) - Pinned entries stay at top and persist through clear Frontend (Svelte/TypeScript): - Clipboard store with filtering, search, and language detection - ClipboardHistoryPanel component with search, language filter, pin/delete - Clipboard button added to InputBar next to Snippets/Actions - Auto-capture from code block copy buttons - Auto-capture from manual text selection in terminal - Insert snippets directly into input field Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 17:40:03 -08:00
naomi	c34720346e	feat: apply trans-pride gradient theme across UI elements - Add global CSS classes for trans gradient styling (btn-trans-gradient, input-trans-focus, icon-trans-hover) - Update all primary action buttons to use trans gradient - Add trans-pride glow effect to character panel based on state - Update StatusBar icon buttons with trans gradient hover - Update chat input focus border with trans gradient glow - Update stop button to use trans gradient	2026-01-25 17:07:32 -08:00
hikari	02cc8bd0d5	feat: add quick actions panel for common prompts - Add Rust backend for managing quick actions with persistent storage - Create QuickActionsPanel component with edit/delete functionality - Add quickActions store for frontend state management - Move Actions and Snippets buttons to input controls row - Include 6 default quick actions: Review PR, Run Tests, Explain File, Fix Error, Write Tests, and Refactor - Support custom quick action creation and management Closes #15	2026-01-25 16:25:59 -08:00
hikari	87cf633564	feat: add git integration panel - Add Rust backend for git operations (status, diff, branches, commit, push, pull, fetch, stage, unstage, discard, create branch) - Add GitPanel.svelte component with three tabs: Changes, Branches, History - Integrate git button into StatusBar with link icon - Use consistent accent color theming for buttons	2026-01-25 16:04:09 -08:00
naomi	a30b3a282c	feat: add session import/export functionality - Add HTML export with dark/light theme support and styled message types - Add PDF export via print-optimized HTML opened in browser - Include metadata toggle option for all export formats - Add export buttons to SessionHistoryPanel dropdown Closes #34	2026-01-25 15:28:06 -08:00
hikari	02987f1a17	feat: add snippet library for prompt templates - Add Rust backend with persistent storage for snippets - Include 8 default snippets across categories (Code Review, Debugging, Testing, etc.) - Create SnippetLibraryPanel component with category filtering - Support create/edit/delete operations for custom snippets - Default snippets can be edited but not deleted - Add snippet button to InputBar for quick access Closes #22	2026-01-25 15:15:52 -08:00
naomi	4a8a1d564a	feat: add session import/export functionality - Add JSON export with full session metadata for backup/restore - Add Markdown export with formatted conversation history - Add import capability for previously exported sessions - Add tauri-plugin-fs for file system operations - Add export dropdown menu and import button to session history panel	2026-01-25 15:00:52 -08:00
hikari	89cc655fd1	feat: add copy button to code blocks Adds a convenient copy-to-clipboard button on all code snippets in markdown output. Each code block now displays: - Language label in the header - Copy button with visual feedback ("Copied!" for 2 seconds) Refs #68	2026-01-25 14:47:24 -08:00
hikari	ce97c51cd8	feat: add session history with auto-save - Add Rust backend for session persistence using tauri-plugin-store - Create SessionHistoryPanel component for browsing saved sessions - Implement debounced auto-save (2s delay) when messages are added - Add session search, resume, and delete functionality - Add clock icon button in StatusBar to access session history Closes #14	2026-01-25 14:10:05 -08:00
hikari	b1a45ed00e	feat: add high contrast mode for accessibility - Add HighContrast variant to Theme enum in Rust backend - Add high-contrast CSS theme with pure black/white for max contrast - Use bright saturated colors for syntax highlighting - Add High Contrast button to theme selector with accessibility tooltip - Follows WCAG guidelines for contrast ratios Closes #20	2026-01-25 13:44:52 -08:00
hikari	457722dc3a	feat: add minimize to system tray option Add ability to minimize Hikari to the system tray when closing the window instead of fully exiting. When enabled, clicking the close button hides the window and shows a tray icon with "Show Hikari" and "Quit" options. - Add tray module with system tray setup and menu handling - Add minimize_to_tray config option in settings - Handle window close event to hide instead of close when enabled - Add tray icon click handler to restore window	2026-01-25 13:38:30 -08:00