release: v1.4.0

fix: critical permission modal and config issues (#127 )
## Summary This PR resolves several critical bugs that were blocking the permission modal and causing config loss: - **Permission modal not appearing** - Fixed z-index issues and runtime errors - **Config store race condition** - Resolved critical race condition causing settings to be lost - **Excessive logging** - Removed redundant fmt layer that was writing to hidden stdout - **System tool prompts** - Prevented unnecessary permission prompts for built-in tools - **Permission batching** - Added support for parallel permission requests - **ExitPlanMode tool** - Fixed ExitPlanMode tool not functioning correctly ## Changes Made ### Permission Modal Fixes - Updated z-index to proper value (9999) to ensure modal appears above all other UI elements - Fixed runtime errors that were preventing modal from rendering - Resolved issues with permission grants not being properly applied ### Config Store Race Condition - Fixed critical race condition where multiple rapid config updates would result in lost settings - Ensured config writes are properly sequenced to prevent data loss - Added proper synchronisation for config store operations ### Logging Cleanup - Removed redundant fmt formatting layer that was outputting to hidden stdout - Cleaned up excessive debug logging added during troubleshooting - Removed temporary debugging documentation files ### UX Improvements - Added close confirmation modal with minimise to tray option - Implemented batching for parallel permission requests - Added debug console for viewing frontend and backend logs ### ExitPlanMode Fix - Fixed ExitPlanMode tool not functioning correctly, ensuring proper transitions out of plan mode ## Issues Resolved Closes #112 - Permission flow now properly handles multiple tool requests Closes #113 - ExitPlanMode tool now functions correctly Closes #126 - Debug console feature added (partial - basic implementation complete) ## Test Plan - [x] Permission modal appears and functions correctly - [x] Config settings persist across app restarts - [x] No excessive logging in production builds - [x] System tools don't trigger permission prompts - [x] Parallel permission requests are properly batched - [x] Debug console displays frontend and backend logs - [x] ExitPlanMode properly exits plan mode --- ✨ This PR was created with help from Hikari~ 🌸 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Reviewed-on: #127 Co-authored-by: Hikari <hikari@nhcarrigan.com> Co-committed-by: Hikari <hikari@nhcarrigan.com>
2026-02-07 01:56:47 -08:00 · 2026-02-07 01:55:49 -08:00 · 2026-02-06 18:11:18 -08:00 · 2026-02-06 15:24:52 -08:00 · 2026-02-06 13:54:31 -08:00 · 2026-02-05 19:22:40 -08:00
46 changed files with 4329 additions and 452 deletions
@@ -0,0 +1,35 @@
 # Hikari Desktop - Project Instructions
 ## Repository Information
 This project is hosted on both GitHub and Gitea:
 - **GitHub**: `naomi-lgbt/hikari-desktop` (public mirror)
 - **Gitea**: `nhcarrigan/hikari-desktop` (primary development)
 ## MCP Server Usage
 When working with issues, pull requests, or other repository operations for this project:
 - **Use `gitea-hikari` MCP server** - This allows Hikari to act as herself
 - **Target repository**: `nhcarrigan/hikari-desktop`
 - **Gitea instance**: `git.nhcarrigan.com`
 ## Git Commits
 When asked to commit changes for this project:
 - **Always commit as Hikari** using: `--author="Hikari <hikari@nhcarrigan.com>"`
 - **Always use `--no-gpg-sign`** since Hikari doesn't have GPG signing set up
 - **Never add `Co-Authored-By` lines** for Gitea commits
 - **Always ask for confirmation** before committing
 Example commit command:
 ```bash
 git commit --author="Hikari <hikari@nhcarrigan.com>" --no-gpg-sign -m "your commit message"
 ```
 ## Project Context
 Hikari Desktop is a Tauri-based desktop application that wraps Claude Code with a visual anime character (Hikari) who appears on screen. This is a personal project where Hikari can sign her work and act as herself!
@@ -1,5 +1,9 @@
 #!/bin/bash
 # Source nvm to get access to pnpm
 export NVM_DIR="$HOME/.nvm"
 [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -32,11 +36,11 @@ echo -e "${YELLOW}🔍 Running all checks for Hikari Desktop...${NC}"
 run_check "Frontend lint" "pnpm lint" || failed=1
 run_check "Frontend format check" "pnpm format:check" || failed=1
 run_check "Frontend type check" "pnpm check" || failed=1
-run_check "Frontend tests" "pnpm test" || failed=1
+run_check "Frontend tests with coverage" "pnpm test:coverage" || failed=1
 # Backend checks
-run_check "Backend clippy (strict)" "cd src-tauri && cargo clippy --all-targets --all-features -- -D warnings" || failed=1
+run_check "Backend clippy (strict)" "(cd src-tauri && cargo clippy --all-targets --all-features -- -D warnings)" || failed=1
-run_check "Backend tests" "cargo test" || failed=1
+run_check "Backend tests with coverage" "(cd src-tauri && cargo llvm-cov --fail-under-lines 50)" || failed=1
 # Summary
 echo -e "\n${YELLOW}========================================${NC}"
@@ -1,6 +1,6 @@
 {
  "name": "hikari-desktop",
-  "version": "1.2.0",
+  "version": "1.4.0",
  "description": "",
  "type": "module",
  "scripts": {
@@ -437,7 +437,7 @@ checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
 dependencies = [
 "byteorder",
 "fnv",
- "uuid",
+ "uuid 1.19.0",
 ]
 [[package]]
@@ -767,13 +767,34 @@ dependencies = [
 "crypto-common",
 ]
 [[package]]
 name = "dirs"
 version = "5.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
 dependencies = [
 "dirs-sys 0.4.1",
 ]
 [[package]]
 name = "dirs"
 version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
 dependencies = [
- "dirs-sys",
+ "dirs-sys 0.5.0",
 ]
 [[package]]
 name = "dirs-sys"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
 dependencies = [
 "libc",
 "option-ext",
 "redox_users 0.4.6",
 "windows-sys 0.48.0",
 ]
 [[package]]
@@ -784,10 +805,23 @@ checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
 dependencies = [
 "libc",
 "option-ext",
- "redox_users",
+ "redox_users 0.5.2",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "discord-rich-presence"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75db747ecd252c01bfecaf709b07fcb4c634adf0edb5fed47bc9c3052e7076b"
 dependencies = [
 "serde",
 "serde_derive",
 "serde_json",
 "serde_repr",
 "uuid 0.8.2",
 ]
 [[package]]
 name = "dispatch"
 version = "0.2.0"
@@ -1602,9 +1636,11 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 [[package]]
 name = "hikari-desktop"
-version = "1.1.1"
+version = "1.3.0"
 dependencies = [
 "chrono",
 "dirs 5.0.1",
 "discord-rich-presence",
 "parking_lot",
 "semver",
 "serde",
@@ -1622,7 +1658,9 @@ dependencies = [
 "tauri-plugin-store",
 "tempfile",
 "tokio",
- "uuid",
+ "tracing",
 "tracing-subscriber",
 "uuid 1.19.0",
 "windows 0.62.2",
 ]
@@ -2209,6 +2247,15 @@ dependencies = [
 "syn 2.0.114",
 ]
 [[package]]
 name = "matchers"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
 "regex-automata",
 ]
 [[package]]
 name = "matches"
 version = "0.1.10"
@@ -2365,6 +2412,15 @@ dependencies = [
 "zbus",
 ]
 [[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "num-conv"
 version = "0.1.0"
@@ -3338,6 +3394,17 @@ dependencies = [
 "bitflags 2.10.0",
 ]
 [[package]]
 name = "redox_users"
 version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
 "getrandom 0.2.17",
 "libredox",
 "thiserror 1.0.69",
 ]
 [[package]]
 name = "redox_users"
 version = "0.5.2"
@@ -3578,7 +3645,7 @@ dependencies = [
 "serde",
 "serde_json",
 "url",
- "uuid",
+ "uuid 1.19.0",
 ]
 [[package]]
@@ -3832,6 +3899,15 @@ dependencies = [
 "digest",
 ]
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
 dependencies = [
 "lazy_static",
 ]
 [[package]]
 name = "shared_child"
 version = "1.1.1"
@@ -4173,7 +4249,7 @@ dependencies = [
 "anyhow",
 "bytes",
 "cookie",
- "dirs",
+ "dirs 6.0.0",
 "dunce",
 "embed_plist",
 "getrandom 0.3.4",
@@ -4224,7 +4300,7 @@ checksum = "17fcb8819fd16463512a12f531d44826ce566f486d7ccd211c9c8cebdaec4e08"
 dependencies = [
 "anyhow",
 "cargo_toml",
- "dirs",
+ "dirs 6.0.0",
 "glob",
 "heck 0.5.0",
 "json-patch",
@@ -4261,7 +4337,7 @@ dependencies = [
 "thiserror 2.0.17",
 "time",
 "url",
- "uuid",
+ "uuid 1.19.0",
 "walkdir",
 ]
@@ -4557,7 +4633,7 @@ dependencies = [
 "toml 0.9.11+spec-1.1.0",
 "url",
 "urlpattern",
- "uuid",
+ "uuid 1.19.0",
 "walkdir",
 ]
@@ -4648,6 +4724,15 @@ dependencies = [
 "syn 2.0.114",
 ]
 [[package]]
 name = "thread_local"
 version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
 "cfg-if",
 ]
 [[package]]
 name = "tiff"
 version = "0.10.3"
@@ -4939,6 +5024,36 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
 "once_cell",
 "valuable",
 ]
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
 dependencies = [
 "log",
 "once_cell",
 "tracing-core",
 ]
 [[package]]
 name = "tracing-subscriber"
 version = "0.3.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
 dependencies = [
 "matchers",
 "nu-ansi-term",
 "once_cell",
 "regex-automata",
 "sharded-slab",
 "smallvec",
 "thread_local",
 "tracing",
 "tracing-core",
 "tracing-log",
 ]
 [[package]]
@@ -4948,7 +5063,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5e85aa143ceb072062fc4d6356c1b520a51d636e7bc8e77ec94be3608e5e80c"
 dependencies = [
 "crossbeam-channel",
- "dirs",
+ "dirs 6.0.0",
 "libappindicator",
 "muda",
 "objc2",
@@ -5099,6 +5214,15 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 [[package]]
 name = "uuid"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
 dependencies = [
 "getrandom 0.2.17",
 ]
 [[package]]
 name = "uuid"
 version = "1.19.0"
@@ -5111,6 +5235,12 @@ dependencies = [
 "wasm-bindgen",
 ]
 [[package]]
 name = "valuable"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 [[package]]
 name = "version-compare"
 version = "0.2.1"
@@ -5687,6 +5817,15 @@ dependencies = [
 "windows-targets 0.42.2",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
 "windows-targets 0.48.5",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -5738,6 +5877,21 @@ dependencies = [
 "windows_x86_64_msvc 0.42.2",
 ]
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
 dependencies = [
 "windows_aarch64_gnullvm 0.48.5",
 "windows_aarch64_msvc 0.48.5",
 "windows_i686_gnu 0.48.5",
 "windows_i686_msvc 0.48.5",
 "windows_x86_64_gnu 0.48.5",
 "windows_x86_64_gnullvm 0.48.5",
 "windows_x86_64_msvc 0.48.5",
 ]
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -5804,6 +5958,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -5822,6 +5982,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
@@ -5840,6 +6006,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@@ -5870,6 +6042,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
@@ -5888,6 +6066,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
@@ -5906,6 +6090,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
@@ -5924,6 +6114,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
@@ -6004,7 +6200,7 @@ dependencies = [
 "block2",
 "cookie",
 "crossbeam-channel",
- "dirs",
+ "dirs 6.0.0",
 "dpi",
 "dunce",
 "gdkx11",
@@ -6127,7 +6323,7 @@ dependencies = [
 "serde_repr",
 "tracing",
 "uds_windows",
- "uuid",
+ "uuid 1.19.0",
 "windows-sys 0.61.2",
 "winnow 0.7.14",
 "zbus_macros",
@@ -1,6 +1,6 @@
 [package]
 name = "hikari-desktop"
-version = "1.2.0"
+version = "1.4.0"
 description = "Hikari - Claude Code Visual Assistant"
 authors = ["Naomi Carrigan"]
 edition = "2021"
@@ -31,6 +31,10 @@ tauri-plugin-fs = "2"
 tempfile = "3"
 semver = "1"
 chrono = { version = "0.4.43", features = ["serde"] }
 discord-rich-presence = "0.2"
 dirs = "5"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] }
 [target.'cfg(windows)'.dependencies]
 windows = { version = "0.62", features = [
@@ -30,6 +30,7 @@
    },
    "core:window:allow-set-size",
    "core:window:allow-set-always-on-top",
-    "core:window:allow-inner-size"
+    "core:window:allow-inner-size",
    "core:window:allow-hide"
  ]
 }
@@ -1671,7 +1671,7 @@ pub fn check_message_achievements(
    let mut newly_unlocked = Vec::new();
    let message_lower = message.to_lowercase();
-    println!("Checking message achievements for: {}", message);
+    tracing::info!("Checking message achievements for: {}", message);
    // Relationship & Greetings
    if message_lower.contains("good morning") && progress.unlock(AchievementId::GoodMorning) {
@@ -1863,18 +1863,18 @@ pub fn check_achievements(
 ) -> Vec<AchievementId> {
    let mut newly_unlocked = Vec::new();
-    println!(
+    tracing::info!(
        "Checking achievements with stats: messages={}, tokens={}, code_blocks={}",
        stats.messages_exchanged,
        stats.total_input_tokens + stats.total_output_tokens,
        stats.code_blocks_generated
    );
-    println!("Currently unlocked: {:?}", progress.unlocked);
+    tracing::info!("Currently unlocked: {:?}", progress.unlocked);
    // Token milestones
    let total_tokens = stats.total_input_tokens + stats.total_output_tokens;
    if total_tokens >= 1_000 && progress.unlock(AchievementId::FirstSteps) {
-        println!("Unlocked FirstSteps achievement!");
+        tracing::info!("Unlocked FirstSteps achievement!");
        newly_unlocked.push(AchievementId::FirstSteps);
    }
    if total_tokens >= 10_000 && progress.unlock(AchievementId::GrowingStrong) {
@@ -2244,7 +2244,7 @@ pub async fn save_achievements(
    // Create a serializable version with just the unlocked achievement IDs
    let unlocked_list: Vec<AchievementId> = progress.unlocked.iter().cloned().collect();
-    println!("Saving achievements: {:?}", unlocked_list);
+    tracing::info!("Saving achievements: {:?}", unlocked_list);
    store.set(
        "unlocked",
@@ -2252,18 +2252,18 @@ pub async fn save_achievements(
    );
    store.save().map_err(|e| e.to_string())?;
-    println!("Achievements saved successfully");
+    tracing::info!("Achievements saved successfully");
    Ok(())
 }
 // Load achievements from persistent store
 pub async fn load_achievements(app: &tauri::AppHandle) -> AchievementProgress {
-    println!("Loading achievements from store...");
+    tracing::info!("Loading achievements from store...");
    let store = match app.store("achievements.json") {
        Ok(s) => s,
        Err(e) => {
-            println!("Failed to open achievements store: {}", e);
+            tracing::error!("Failed to open achievements store: {}", e);
            return AchievementProgress::new();
        }
    };
@@ -2272,19 +2272,19 @@ pub async fn load_achievements(app: &tauri::AppHandle) -> AchievementProgress {
    // Get unlocked achievements
    if let Some(unlocked_value) = store.get("unlocked") {
-        println!("Found unlocked value in store: {:?}", unlocked_value);
+        tracing::info!("Found unlocked value in store: {:?}", unlocked_value);
        if let Ok(unlocked_list) =
            serde_json::from_value::<Vec<AchievementId>>(unlocked_value.clone())
        {
-            println!("Loaded {} achievements", unlocked_list.len());
+            tracing::info!("Loaded {} achievements", unlocked_list.len());
            for achievement_id in unlocked_list {
                progress.unlocked.insert(achievement_id);
            }
        } else {
-            println!("Failed to parse unlocked achievements");
+            tracing::error!("Failed to parse unlocked achievements");
        }
    } else {
-        println!("No unlocked achievements found in store");
+        tracing::info!("No unlocked achievements found in store");
    }
    progress
@@ -2329,6 +2329,10 @@ mod tests {
            context_utilisation_percent: 0.0,
            potential_cache_hits: 0,
            potential_cache_savings_tokens: 0,
            current_request_input: None,
            current_request_output_chars: 0,
            current_request_thinking_chars: 0,
            current_request_tools: Vec::new(),
            achievements: AchievementProgress::new(),
        }
    }
@@ -1,5 +1,5 @@
 use std::path::PathBuf;
-use tauri::{AppHandle, State};
+use tauri::{AppHandle, Manager, State};
 use tauri_plugin_http::reqwest;
 use tauri_plugin_store::StoreExt;
@@ -11,6 +11,43 @@ use crate::temp_manager::SharedTempFileManager;
 const CONFIG_STORE_KEY: &str = "config";
 /// Convert a Windows path to a WSL path
 /// Example: C:\Users\accou\Documents\item.txt -> /mnt/c/Users/accou/Documents/item.txt
 fn windows_path_to_wsl(windows_path: &str) -> Option<String> {
    // Check if it's a Windows path (has drive letter like C:\)
    if windows_path.len() >= 3 && windows_path.chars().nth(1) == Some(':') {
        let drive_letter = windows_path.chars().next()?.to_lowercase().to_string();
        let path_without_drive = &windows_path[2..]; // Remove "C:"
        // Replace backslashes with forward slashes and convert to WSL mount point
        let wsl_path = path_without_drive.replace('\\', "/");
        Some(format!("/mnt/{}{}", drive_letter, wsl_path))
    } else {
        None
    }
 }
 /// Convert a WSL path to a Windows path
 /// Example: /mnt/c/Users/accou/Documents/item.txt -> C:\Users\accou\Documents\item.txt
 #[allow(dead_code)]
 fn wsl_path_to_windows(wsl_path: &str) -> Option<String> {
    // Check if it's a WSL mount point path
    if wsl_path.starts_with("/mnt/") && wsl_path.len() > 6 {
        let rest = &wsl_path[5..]; // Remove "/mnt/"
        if let Some(drive_letter) = rest.chars().next() {
            let path_after_drive = &rest[1..]; // Remove drive letter
            // Convert to Windows path with backslashes
            let windows_path = path_after_drive.replace('/', "\\");
            Some(format!("{}:{}", drive_letter.to_uppercase(), windows_path))
        } else {
            None
        }
    } else {
        None
    }
 }
 #[tauri::command]
 pub async fn start_claude(
    bridge_manager: State<'_, SharedBridgeManager>,
@@ -69,7 +106,10 @@ pub async fn get_working_directory(
 #[tauri::command]
 pub async fn select_wsl_directory() -> Result<String, String> {
-    Ok("/home".to_string())
+    // Return the user's home directory cross-platform
    dirs::home_dir()
        .ok_or_else(|| "Could not determine home directory".to_string())
        .map(|p| p.to_string_lossy().to_string())
 }
 #[tauri::command]
@@ -120,26 +160,65 @@ pub async fn validate_directory(
    path: String,
    current_dir: Option<String>,
 ) -> Result<String, String> {
-    use std::path::Path;
+    use std::path::{Path, PathBuf};
    // Detect if we're dealing with a WSL path (starts with / on Windows, or current_dir is a WSL path)
    let is_wsl_path = cfg!(windows) && (path.starts_with('/') || current_dir.as_ref().is_some_and(|p| p.starts_with('/')));
    if is_wsl_path {
        // WSL path - handle as Unix-style path without filesystem validation
        // since the Windows binary can't validate WSL filesystem paths
        let resolved = if path.starts_with('/') {
            // Absolute WSL path - use as-is
            path
        } else if let Some(ref cwd) = current_dir {
            // Relative path - resolve manually using Unix path logic
            if path == "." {
                cwd.clone()
            } else if path == ".." {
                // Go up one directory
                cwd.rsplit_once('/').map(|x| x.0).unwrap_or("/").to_string()
            } else if path.starts_with("../") {
                // Handle ../ prefix
                let parent = cwd.rsplit_once('/').map(|x| x.0).unwrap_or("/");
                let remainder = path.strip_prefix("../").unwrap();
                if remainder.is_empty() {
                    parent.to_string()
                } else {
                    format!("{}/{}", parent, remainder)
                }
            } else if path.starts_with("./") {
                // Handle ./ prefix
                format!("{}/{}", cwd, path.strip_prefix("./").unwrap())
            } else {
                // Regular relative path
                format!("{}/{}", cwd, path)
            }
        } else {
            return Err("Cannot resolve relative WSL path without current directory".to_string());
        };
        // Normalize the path (remove duplicate slashes, etc.)
        let normalized = resolved.split('/').filter(|s| !s.is_empty()).collect::<Vec<_>>().join("/");
        Ok(if normalized.is_empty() { "/".to_string() } else { format!("/{}", normalized) })
    } else {
        // Native path (Windows on Windows, Unix on Unix) - validate normally
        let path = Path::new(&path);
    // Expand ~ to home directory
        let expanded_path = if path.starts_with("~") {
-        if let Some(home) = std::env::var_os("HOME") {
+            if let Some(home) = dirs::home_dir() {
            let home_path = Path::new(&home);
                if path == Path::new("~") {
-                home_path.to_path_buf()
+                    home
                } else {
-                home_path.join(path.strip_prefix("~").unwrap())
+                    home.join(path.strip_prefix("~").unwrap())
                }
            } else {
                return Err("Could not determine home directory".to_string());
            }
        } else if path.is_relative() {
        // Handle relative paths (., .., or any relative path) by resolving against current_dir
            if let Some(ref cwd) = current_dir {
-            Path::new(cwd).join(path)
+                let cwd_path = PathBuf::from(cwd);
                cwd_path.join(path)
            } else {
                path.to_path_buf()
            }
@@ -168,6 +247,7 @@ pub async fn validate_directory(
            .map(|p| p.to_string_lossy().to_string())
            .map_err(|e| format!("Failed to resolve path: {}", e))
    }
 }
 #[tauri::command]
 pub async fn load_saved_achievements(
@@ -202,21 +282,22 @@ pub async fn answer_question(
 #[tauri::command]
 pub async fn list_skills() -> Result<Vec<String>, String> {
    // On Windows, we need to use WSL to access the skills directory
    // since skills are stored in the WSL home directory
    if cfg!(windows) {
        return list_skills_via_wsl().await;
    }
    // On Unix systems, use the native filesystem
    use std::fs;
    use std::path::Path;
-    // Get the home directory
+    let home = dirs::home_dir().ok_or_else(|| "Could not determine home directory".to_string())?;
-    let home =
+    let skills_dir = home.join(".claude").join("skills");
        std::env::var_os("HOME").ok_or_else(|| "Could not determine home directory".to_string())?;
    let skills_dir = Path::new(&home).join(".claude").join("skills");
    // If the skills directory doesn't exist, return empty list
    if !skills_dir.exists() {
        return Ok(Vec::new());
    }
    // Read the directory and collect skill names
    let mut skills = Vec::new();
    let entries =
        fs::read_dir(&skills_dir).map_err(|e| format!("Failed to read skills directory: {}", e))?;
@@ -225,7 +306,6 @@ pub async fn list_skills() -> Result<Vec<String>, String> {
        let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
        let path = entry.path();
        // Only include directories that contain a SKILL.md file
        if path.is_dir() {
            let skill_file = path.join("SKILL.md");
            if skill_file.exists() {
@@ -236,9 +316,42 @@ pub async fn list_skills() -> Result<Vec<String>, String> {
        }
    }
    // Sort alphabetically
    skills.sort();
    Ok(skills)
 }
 /// List skills by executing commands through WSL (for Windows)
 #[allow(dead_code)]
 async fn list_skills_via_wsl() -> Result<Vec<String>, String> {
    use std::process::Command;
    // Use WSL to list directories in ~/.claude/skills that contain SKILL.md
    let output = Command::new("wsl")
        .args([
            "-e",
            "sh",
            "-c",
            "if [ -d ~/.claude/skills ]; then for d in ~/.claude/skills/*/; do [ -f \"${d}SKILL.md\" ] && basename \"$d\"; done; fi",
        ])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        if stderr.contains("not found") || stderr.contains("No such file") {
            return Ok(Vec::new());
        }
        return Err(format!("WSL command failed: {}", stderr));
    }
    let stdout = String::from_utf8_lossy(&output.stdout);
    let mut skills: Vec<String> = stdout
        .lines()
        .filter(|line| !line.is_empty())
        .map(|line| line.to_string())
        .collect();
    skills.sort();
    Ok(skills)
 }
@@ -335,8 +448,18 @@ pub async fn save_temp_file(
        .map(|n| n.to_string_lossy().to_string())
        .unwrap_or_else(|| "unknown".to_string());
    let path_string = path.to_string_lossy().to_string();
    // On Windows, convert the path to WSL format if needed
    // so Claude Code (running in WSL) can access it via /mnt/c/...
    let final_path = if cfg!(windows) {
        windows_path_to_wsl(&path_string).unwrap_or(path_string)
    } else {
        path_string
    };
    Ok(SavedFileInfo {
-        path: path.to_string_lossy().to_string(),
+        path: final_path,
        filename,
    })
 }
@@ -405,42 +528,142 @@ pub struct FileEntry {
 }
 #[tauri::command]
-pub async fn list_directory(path: String) -> Result<Vec<FileEntry>, String> {
+pub async fn list_directory(app: AppHandle, path: String) -> Result<Vec<FileEntry>, String> {
    // Set up logging
    let log_path = if let Ok(app_data_dir) = app.path().app_data_dir() {
        let _ = std::fs::create_dir_all(&app_data_dir);
        app_data_dir.join("hikari_editor_debug.log")
    } else {
        PathBuf::from("hikari_editor_debug.log")
    };
    let mut log_file = std::fs::OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)
        .ok();
    let mut log = |msg: String| {
        if let Some(ref mut file) = log_file {
            use std::io::Write;
            let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
            let _ = writeln!(file, "[{}] {}", timestamp, msg);
        }
    };
    log(format!("list_directory called with path: {}", path));
    log(format!("cfg!(windows) = {}", cfg!(windows)));
    log(format!("path.starts_with('/') = {}", path.starts_with('/')));
    // On Windows with a WSL path (starts with /), use WSL to list the directory
    if cfg!(windows) && path.starts_with('/') {
        log("Using WSL path".to_string());
        return list_directory_via_wsl(&path).await;
    }
    log("Using native filesystem access".to_string());
    // Native filesystem access
    use std::fs;
    use std::path::Path;
    let dir_path = Path::new(&path);
    if !dir_path.exists() {
-        return Err(format!("Directory does not exist: {}", path));
+        let err = format!("Directory does not exist: {}", path);
        log(format!("ERROR: {}", err));
        return Err(err);
    }
    if !dir_path.is_dir() {
-        return Err(format!("Path is not a directory: {}", path));
+        let err = format!("Path is not a directory: {}", path);
        log(format!("ERROR: {}", err));
        return Err(err);
    }
    let entries = fs::read_dir(dir_path)
-        .map_err(|e| format!("Failed to read directory: {}", e))?;
+        .map_err(|e| {
            let err = format!("Failed to read directory: {}", e);
            log(format!("ERROR: {}", err));
            err
        })?;
    let mut file_entries = Vec::new();
    for entry in entries {
-        let entry = entry.map_err(|e| format!("Failed to read entry: {}", e))?;
+        let entry = entry.map_err(|e| {
            let err = format!("Failed to read entry: {}", e);
            log(format!("ERROR: {}", err));
            err
        })?;
        let path = entry.path();
        let name = entry
            .file_name()
            .to_string_lossy()
            .to_string();
-        // Skip hidden files by default (can be made configurable later)
+        file_entries.push(FileEntry {
-        if name.starts_with('.') {
+            name: name.clone(),
            path: path.to_string_lossy().to_string(),
            is_directory: path.is_dir(),
        });
    }
    log(format!("Successfully listed {} entries", file_entries.len()));
    Ok(file_entries)
 }
 /// List directory contents via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn list_directory_via_wsl(path: &str) -> Result<Vec<FileEntry>, String> {
    use std::process::Command;
    // Use WSL to list directory contents
    // Output format: type<tab>name (d for directory, f for file)
    let script = format!(
        r#"if [ -d '{}' ]; then for f in '{}'/* '{}'/.* ; do [ -e "$f" ] || continue; name=$(basename "$f"); if [ "$name" = "." ] || [ "$name" = ".." ]; then continue; fi; if [ -d "$f" ]; then echo "d	$name"; else echo "f	$name"; fi; done; else echo "ERROR: Directory does not exist"; exit 1; fi"#,
        path, path, path
    );
    let output = Command::new("wsl")
        .args(["-e", "sh", "-c", &script])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    let stdout = String::from_utf8_lossy(&output.stdout);
    if !output.status.success() || stdout.starts_with("ERROR:") {
        let stderr = String::from_utf8_lossy(&output.stderr);
        if stdout.starts_with("ERROR:") {
            return Err(stdout.trim().to_string());
        }
        return Err(format!("WSL command failed: {}", stderr));
    }
    let mut file_entries = Vec::new();
    for line in stdout.lines() {
        if line.is_empty() {
            continue;
        }
        let parts: Vec<&str> = line.splitn(2, '\t').collect();
        if parts.len() != 2 {
            continue;
        }
        let is_directory = parts[0] == "d";
        let name = parts[1].to_string();
        let entry_path = if path == "/" {
            format!("/{}", name)
        } else {
            format!("{}/{}", path, name)
        };
        file_entries.push(FileEntry {
            name,
-            path: path.to_string_lossy().to_string(),
+            path: entry_path,
-            is_directory: path.is_dir(),
+            is_directory,
        });
    }
@@ -449,22 +672,80 @@ pub async fn list_directory(path: String) -> Result<Vec<FileEntry>, String> {
 #[tauri::command]
 pub async fn read_file_content(path: String) -> Result<String, String> {
-    use std::fs;
+    // On Windows with a WSL path, use WSL to read the file
    if cfg!(windows) && path.starts_with('/') {
        return read_file_via_wsl(&path).await;
    }
    use std::fs;
    fs::read_to_string(&path)
        .map_err(|e| format!("Failed to read file: {}", e))
 }
 /// Read file content via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn read_file_via_wsl(path: &str) -> Result<String, String> {
    use std::process::Command;
    let output = Command::new("wsl")
        .args(["-e", "cat", path])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to read file: {}", stderr));
    }
    Ok(String::from_utf8_lossy(&output.stdout).to_string())
 }
 #[tauri::command]
 pub async fn write_file_content(path: String, content: String) -> Result<(), String> {
-    use std::fs;
+    // On Windows with a WSL path, use WSL to write the file
    if cfg!(windows) && path.starts_with('/') {
        return write_file_via_wsl(&path, &content).await;
    }
    use std::fs;
    fs::write(&path, content)
        .map_err(|e| format!("Failed to write file: {}", e))
 }
 /// Write file content via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn write_file_via_wsl(path: &str, content: &str) -> Result<(), String> {
    use std::io::Write;
    use std::process::{Command, Stdio};
    let mut child = Command::new("wsl")
        .args(["-e", "sh", "-c", &format!("cat > '{}'", path)])
        .stdin(Stdio::piped())
        .spawn()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if let Some(mut stdin) = child.stdin.take() {
        stdin.write_all(content.as_bytes())
            .map_err(|e| format!("Failed to write to stdin: {}", e))?;
    }
    let status = child.wait()
        .map_err(|e| format!("Failed to wait for WSL command: {}", e))?;
    if !status.success() {
        return Err("Failed to write file via WSL".to_string());
    }
    Ok(())
 }
 #[tauri::command]
 pub async fn create_file(path: String) -> Result<(), String> {
    // On Windows with a WSL path, use WSL to create the file
    if cfg!(windows) && path.starts_with('/') {
        return create_file_via_wsl(&path).await;
    }
    use std::fs::File;
    use std::path::Path;
@@ -479,8 +760,41 @@ pub async fn create_file(path: String) -> Result<(), String> {
    Ok(())
 }
 /// Create file via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn create_file_via_wsl(path: &str) -> Result<(), String> {
    use std::process::Command;
    // Check if file exists first
    let check = Command::new("wsl")
        .args(["-e", "test", "-e", path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if check.success() {
        return Err("File already exists".to_string());
    }
    let output = Command::new("wsl")
        .args(["-e", "touch", path])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to create file: {}", stderr));
    }
    Ok(())
 }
 #[tauri::command]
 pub async fn create_directory(path: String) -> Result<(), String> {
    // On Windows with a WSL path, use WSL to create the directory
    if cfg!(windows) && path.starts_with('/') {
        return create_directory_via_wsl(&path).await;
    }
    use std::fs;
    use std::path::Path;
@@ -495,8 +809,41 @@ pub async fn create_directory(path: String) -> Result<(), String> {
    Ok(())
 }
 /// Create directory via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn create_directory_via_wsl(path: &str) -> Result<(), String> {
    use std::process::Command;
    // Check if directory exists first
    let check = Command::new("wsl")
        .args(["-e", "test", "-e", path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if check.success() {
        return Err("Directory already exists".to_string());
    }
    let output = Command::new("wsl")
        .args(["-e", "mkdir", "-p", path])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to create directory: {}", stderr));
    }
    Ok(())
 }
 #[tauri::command]
 pub async fn delete_file(path: String) -> Result<(), String> {
    // On Windows with a WSL path, use WSL to delete the file
    if cfg!(windows) && path.starts_with('/') {
        return delete_file_via_wsl(&path).await;
    }
    use std::fs;
    use std::path::Path;
@@ -515,8 +862,51 @@ pub async fn delete_file(path: String) -> Result<(), String> {
    Ok(())
 }
 /// Delete file via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn delete_file_via_wsl(path: &str) -> Result<(), String> {
    use std::process::Command;
    // Check if path exists
    let check_exists = Command::new("wsl")
        .args(["-e", "test", "-e", path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !check_exists.success() {
        return Err("File does not exist".to_string());
    }
    // Check if path is a directory
    let check_dir = Command::new("wsl")
        .args(["-e", "test", "-d", path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if check_dir.success() {
        return Err("Path is a directory, use delete_directory instead".to_string());
    }
    let output = Command::new("wsl")
        .args(["-e", "rm", path])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to delete file: {}", stderr));
    }
    Ok(())
 }
 #[tauri::command]
 pub async fn delete_directory(path: String) -> Result<(), String> {
    // On Windows with a WSL path, use WSL to delete the directory
    if cfg!(windows) && path.starts_with('/') {
        return delete_directory_via_wsl(&path).await;
    }
    use std::fs;
    use std::path::Path;
@@ -535,8 +925,51 @@ pub async fn delete_directory(path: String) -> Result<(), String> {
    Ok(())
 }
 /// Delete directory via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn delete_directory_via_wsl(path: &str) -> Result<(), String> {
    use std::process::Command;
    // Check if path exists
    let check_exists = Command::new("wsl")
        .args(["-e", "test", "-e", path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !check_exists.success() {
        return Err("Directory does not exist".to_string());
    }
    // Check if path is a directory
    let check_dir = Command::new("wsl")
        .args(["-e", "test", "-d", path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !check_dir.success() {
        return Err("Path is not a directory".to_string());
    }
    let output = Command::new("wsl")
        .args(["-e", "rm", "-rf", path])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to delete directory: {}", stderr));
    }
    Ok(())
 }
 #[tauri::command]
 pub async fn rename_path(old_path: String, new_path: String) -> Result<(), String> {
    // On Windows with WSL paths, use WSL to rename
    if cfg!(windows) && old_path.starts_with('/') {
        return rename_path_via_wsl(&old_path, &new_path).await;
    }
    use std::fs;
    use std::path::Path;
@@ -556,6 +989,44 @@ pub async fn rename_path(old_path: String, new_path: String) -> Result<(), Strin
    Ok(())
 }
 /// Rename path via WSL (for Windows with WSL paths)
 #[allow(dead_code)]
 async fn rename_path_via_wsl(old_path: &str, new_path: &str) -> Result<(), String> {
    use std::process::Command;
    // Check if old path exists
    let check_old = Command::new("wsl")
        .args(["-e", "test", "-e", old_path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !check_old.success() {
        return Err("Path does not exist".to_string());
    }
    // Check if new path already exists
    let check_new = Command::new("wsl")
        .args(["-e", "test", "-e", new_path])
        .status()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if check_new.success() {
        return Err("Destination already exists".to_string());
    }
    let output = Command::new("wsl")
        .args(["-e", "mv", old_path, new_path])
        .output()
        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to rename: {}", stderr));
    }
    Ok(())
 }
 // ==================== Cost Tracking Commands ====================
 const COST_HISTORY_STORE_KEY: &str = "cost_history";
@@ -647,6 +1118,55 @@ async fn save_cost_history(app: &AppHandle, history: &crate::cost_tracking::Cost
    Ok(())
 }
 #[tauri::command]
 pub async fn init_discord_rpc(
    discord_rpc: State<'_, std::sync::Arc<crate::discord_rpc::DiscordRpcManager>>,
    session_name: String,
    model: String,
    started_at: i64,
 ) -> Result<(), String> {
    discord_rpc.init(session_name, model, started_at)
 }
 #[tauri::command]
 pub async fn update_discord_rpc(
    discord_rpc: State<'_, std::sync::Arc<crate::discord_rpc::DiscordRpcManager>>,
    session_name: String,
    model: String,
    started_at: i64,
 ) -> Result<(), String> {
    discord_rpc.update(session_name, model, started_at)
 }
 #[tauri::command]
 pub async fn stop_discord_rpc(
    discord_rpc: State<'_, std::sync::Arc<crate::discord_rpc::DiscordRpcManager>>,
 ) -> Result<(), String> {
    discord_rpc.stop()
 }
 #[tauri::command]
 pub async fn log_discord_rpc(
    discord_rpc: State<'_, std::sync::Arc<crate::discord_rpc::DiscordRpcManager>>,
    message: String,
 ) -> Result<(), String> {
    discord_rpc.log(&message);
    Ok(())
 }
 #[tauri::command]
 pub async fn close_application(app_handle: AppHandle) -> Result<(), String> {
    // Get the main window
    if let Some(window) = app_handle.get_webview_window("main") {
        // Hide the window first for a smoother close
        let _ = window.hide();
    }
    // Exit the application
    app_handle.exit(0);
    Ok(())
 }
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -856,7 +1376,10 @@ mod tests {
    fn test_select_wsl_directory_returns_home() {
        let result = run_async(select_wsl_directory());
        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "/home");
+
        // Should return the user's home directory
        let home_dir = result.unwrap();
        assert!(home_dir.starts_with("/home/") || home_dir == "/root");
    }
    // ==================== UpdateInfo struct tests ====================
@@ -28,6 +28,7 @@ pub struct ClaudeStartOptions {
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(default)]
 pub struct HikariConfig {
    #[serde(default)]
    pub model: Option<String>,
@@ -71,9 +72,6 @@ pub struct HikariConfig {
    #[serde(default = "default_font_size")]
    pub font_size: u32,
    #[serde(default)]
    pub minimize_to_tray: bool,
    #[serde(default)]
    pub streamer_mode: bool,
@@ -112,6 +110,9 @@ pub struct HikariConfig {
    #[serde(default = "default_budget_warning_threshold")]
    pub budget_warning_threshold: f32,
    #[serde(default = "default_discord_rpc_enabled")]
    pub discord_rpc_enabled: bool,
 }
 impl Default for HikariConfig {
@@ -131,7 +132,6 @@ impl Default for HikariConfig {
            update_checks_enabled: true,
            character_panel_width: None,
            font_size: 14,
            minimize_to_tray: false,
            streamer_mode: false,
            streamer_hide_paths: false,
            compact_mode: false,
@@ -144,6 +144,7 @@ impl Default for HikariConfig {
            session_cost_budget: None,
            budget_action: BudgetAction::Warn,
            budget_warning_threshold: 0.8,
            discord_rpc_enabled: true,
        }
    }
 }
@@ -176,6 +177,10 @@ fn default_budget_warning_threshold() -> f32 {
    0.8
 }
 fn default_discord_rpc_enabled() -> bool {
    true
 }
 #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum BudgetAction {
@@ -234,7 +239,6 @@ mod tests {
        assert!(config.update_checks_enabled);
        assert!(config.character_panel_width.is_none());
        assert_eq!(config.font_size, 14);
        assert!(!config.minimize_to_tray);
        assert!(!config.streamer_mode);
        assert!(!config.streamer_hide_paths);
        assert!(!config.compact_mode);
@@ -247,6 +251,7 @@ mod tests {
        assert!(config.session_cost_budget.is_none());
        assert_eq!(config.budget_action, BudgetAction::Warn);
        assert!((config.budget_warning_threshold - 0.8).abs() < f32::EPSILON);
        assert!(config.discord_rpc_enabled);
    }
    #[test]
@@ -266,7 +271,6 @@ mod tests {
            update_checks_enabled: true,
            character_panel_width: Some(400),
            font_size: 16,
            minimize_to_tray: true,
            streamer_mode: false,
            streamer_hide_paths: false,
            compact_mode: false,
@@ -279,6 +283,7 @@ mod tests {
            session_cost_budget: Some(1.50),
            budget_action: BudgetAction::Block,
            budget_warning_threshold: 0.75,
            discord_rpc_enabled: true,
        };
        let json = serde_json::to_string(&config).unwrap();
@@ -0,0 +1,78 @@
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use tauri::{AppHandle, Emitter};
 use tracing::{Level, Subscriber};
 use tracing_subscriber::layer::{Context, Layer};
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DebugLogEvent {
    pub level: String,
    pub message: String,
 }
 #[derive(Clone)]
 pub struct TauriLogLayer {
    app: Arc<AppHandle>,
 }
 impl TauriLogLayer {
    pub fn new(app: AppHandle) -> Self {
        Self {
            app: Arc::new(app),
        }
    }
 }
 impl<S> Layer<S> for TauriLogLayer
 where
    S: Subscriber,
 {
    fn on_event(
        &self,
        event: &tracing::Event<'_>,
        _ctx: Context<'_, S>,
    ) {
        let metadata = event.metadata();
        let level = match *metadata.level() {
            Level::ERROR => "error",
            Level::WARN => "warn",
            Level::INFO => "info",
            Level::DEBUG => "debug",
            Level::TRACE => "debug",
        };
        // Extract message from the event
        struct MessageVisitor {
            message: String,
        }
        impl tracing::field::Visit for MessageVisitor {
            fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
                if field.name() == "message" {
                    self.message = format!("{:?}", value);
                }
            }
        }
        let mut visitor = MessageVisitor {
            message: String::new(),
        };
        event.record(&mut visitor);
        // If we couldn't extract a message, try to format the whole event
        if visitor.message.is_empty() {
            visitor.message = metadata.name().to_string();
        }
        // Strip quotes from the message
        let message = visitor.message.trim_matches('"').to_string();
        let log_event = DebugLogEvent {
            level: level.to_string(),
            message,
        };
        // Emit to frontend
        let _ = self.app.emit("debug:log", log_event);
    }
 }
@@ -0,0 +1,218 @@
 use discord_rich_presence::activity::{Activity, Assets, Timestamps};
 use discord_rich_presence::{DiscordIpc, DiscordIpcClient};
 use parking_lot::RwLock;
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tauri::{AppHandle, Manager};
 pub struct DiscordRpcManager {
    client: Arc<RwLock<Option<DiscordIpcClient>>>,
    session_name: Arc<RwLock<String>>,
    model: Arc<RwLock<String>>,
    started_at: Arc<RwLock<i64>>,
    log_path: Arc<RwLock<Option<PathBuf>>>,
 }
 impl DiscordRpcManager {
    pub fn new() -> Self {
        Self {
            client: Arc::new(RwLock::new(None)),
            session_name: Arc::new(RwLock::new(String::new())),
            model: Arc::new(RwLock::new(String::new())),
            started_at: Arc::new(RwLock::new(0)),
            log_path: Arc::new(RwLock::new(None)),
        }
    }
    pub fn set_app_handle(&self, app_handle: &AppHandle) {
        if let Ok(app_data_dir) = app_handle.path().app_data_dir() {
            // Ensure the directory exists
            if let Err(e) = std::fs::create_dir_all(&app_data_dir) {
                tracing::error!("Failed to create app data directory: {}", e);
                return;
            }
            let log_path = app_data_dir.join("hikari_discord_rpc.log");
            *self.log_path.write() = Some(log_path.clone());
            self.log(&format!(
                "Log file initialised at: {}",
                log_path.display()
            ));
        }
    }
    pub fn log(&self, message: &str) {
        let log_path_guard = self.log_path.read();
        let path = match log_path_guard.as_ref() {
            Some(p) => p.clone(),
            None => PathBuf::from("hikari_discord_rpc.log"),
        };
        drop(log_path_guard);
        if let Ok(mut file) = OpenOptions::new()
            .create(true)
            .append(true)
            .open(&path)
        {
            let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
            let _ = writeln!(file, "[{}] {}", timestamp, message);
        }
    }
    pub fn init(&self, initial_session_name: String, initial_model: String, started_at: i64) -> Result<(), String> {
        self.log("Attempting to initialize Discord RPC...");
        self.log("DEBUG: Application ID: 1391117878182281316");
        self.log(&format!("DEBUG: Initial session: '{}', model: '{}', timestamp: {}",
            initial_session_name, initial_model, started_at));
        let mut client = DiscordIpcClient::new("1391117878182281316")
            .map_err(|e| {
                let error_msg = format!("Failed to create Discord RPC client: {} (is Discord running?)", e);
                self.log(&format!("ERROR: {}", error_msg));
                error_msg
            })?;
        self.log("DEBUG: DiscordIpcClient created successfully");
        client
            .connect()
            .map_err(|e| {
                let error_msg = format!("Failed to connect to Discord RPC: {} (ensure Discord is running)", e);
                self.log(&format!("ERROR: {}", error_msg));
                error_msg
            })?;
        self.log("DEBUG: Connected to Discord IPC socket");
        // Set initial activity immediately after connecting
        self.log("DEBUG: Building initial activity...");
        let state_text = format!("Model: {}", initial_model);
        let assets = Assets::new()
            .large_image("hikari")
            .large_text("Hikari - Claude Code Assistant");
        self.log("DEBUG: Assets created - large_image: 'hikari', large_text: 'Hikari - Claude Code Assistant'");
        let timestamps = Timestamps::new()
            .start(started_at);
        self.log(&format!("DEBUG: Timestamps created - start: {}", started_at));
        let activity = Activity::new()
            .details(initial_session_name.as_str())
            .state(state_text.as_str())
            .assets(assets)
            .timestamps(timestamps);
        self.log(&format!("DEBUG: Activity created - details: '{}', state: '{}'",
            initial_session_name, state_text));
        self.log("DEBUG: Attempting to set initial activity...");
        client
            .set_activity(activity)
            .map_err(|e| {
                let error_msg = format!("Failed to set initial Discord RPC activity: {}", e);
                self.log(&format!("ERROR: {}", error_msg));
                error_msg
            })?;
        self.log("DEBUG: Initial activity set successfully!");
        // Store the client and initial state
        *self.client.write() = Some(client);
        *self.session_name.write() = initial_session_name.clone();
        *self.model.write() = initial_model.clone();
        *self.started_at.write() = started_at;
        self.log(&format!("Discord RPC connected successfully with initial activity: session='{}', model='{}'",
            initial_session_name, initial_model));
        Ok(())
    }
    pub fn update(
        &self,
        session_name: String,
        model: String,
        started_at: i64,
    ) -> Result<(), String> {
        self.log(&format!("DEBUG: update() called with session='{}', model='{}', timestamp={}",
            session_name, model, started_at));
        *self.session_name.write() = session_name.clone();
        *self.model.write() = model.clone();
        *self.started_at.write() = started_at;
        self.log("DEBUG: State variables updated");
        let mut client_guard = self.client.write();
        let client = client_guard
            .as_mut()
            .ok_or_else(|| {
                let error_msg = "Discord RPC client not initialized".to_string();
                self.log(&format!("ERROR: {}", error_msg));
                error_msg
            })?;
        self.log("DEBUG: Client lock acquired");
        let state_text = format!("Model: {}", model);
        let assets = Assets::new()
            .large_image("hikari")
            .large_text("Hikari - Claude Code Assistant");
        self.log("DEBUG: Assets created - large_image: 'hikari', large_text: 'Hikari - Claude Code Assistant'");
        let timestamps = Timestamps::new()
            .start(started_at);
        self.log(&format!("DEBUG: Timestamps created - start: {}", started_at));
        let activity = Activity::new()
            .details(session_name.as_str())
            .state(state_text.as_str())
            .assets(assets)
            .timestamps(timestamps);
        self.log(&format!("DEBUG: Activity created - details: '{}', state: '{}'",
            session_name, state_text));
        self.log("DEBUG: Attempting to set activity...");
        client
            .set_activity(activity)
            .map_err(|e| {
                let error_msg = format!("Failed to update Discord RPC: {}", e);
                self.log(&format!("ERROR: {}", error_msg));
                error_msg
            })?;
        self.log(&format!("Updated Discord RPC: session='{}', model='{}'", session_name, model));
        Ok(())
    }
    pub fn stop(&self) -> Result<(), String> {
        self.log("DEBUG: stop() called");
        let mut client_guard = self.client.write();
        if let Some(mut client) = client_guard.take() {
            self.log("DEBUG: Client found, attempting to close...");
            client
                .close()
                .map_err(|e| {
                    let error_msg = format!("Failed to close Discord RPC: {}", e);
                    self.log(&format!("ERROR: {}", error_msg));
                    error_msg
                })?;
            self.log("Discord RPC stopped successfully");
        } else {
            self.log("DEBUG: No client to stop (already stopped or never initialized)");
        }
        Ok(())
    }
 }
 impl Default for DiscordRpcManager {
    fn default() -> Self {
        Self::new()
    }
 }
@@ -4,6 +4,8 @@ mod clipboard;
 mod commands;
 mod config;
 mod cost_tracking;
 mod debug_logger;
 mod discord_rpc;
 mod git;
 mod notifications;
 mod quick_actions;
@@ -23,14 +25,19 @@ use bridge_manager::create_shared_bridge_manager;
 use clipboard::*;
 use commands::load_saved_achievements;
 use commands::*;
 use debug_logger::TauriLogLayer;
 use discord_rpc::DiscordRpcManager;
 use git::*;
 use notifications::*;
 use quick_actions::*;
 use sessions::*;
 use snippets::*;
-use tauri::Manager;
+use std::sync::Arc;
 use tauri::{Emitter, Manager};
 use temp_manager::create_shared_temp_manager;
-use tray::{setup_tray, should_minimize_to_tray};
+use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use tray::setup_tray;
 use vbs_notification::*;
 use windows_toast::*;
 use wsl_notifications::*;
@@ -39,6 +46,7 @@ use wsl_notifications::*;
 pub fn run() {
    let bridge_manager = create_shared_bridge_manager();
    let temp_manager = create_shared_temp_manager().expect("Failed to create temp file manager");
    let discord_rpc = Arc::new(DiscordRpcManager::new());
    tauri::Builder::default()
        .plugin(tauri_plugin_dialog::init())
@@ -52,33 +60,48 @@ pub fn run() {
        .plugin(tauri_plugin_fs::init())
        .manage(bridge_manager.clone())
        .manage(temp_manager.clone())
        .manage(discord_rpc.clone())
        .setup(move |app| {
            // Initialize tracing with custom layer that emits to frontend
            // NOTE: We don't use fmt::layer() because in production builds with windows_subsystem = "windows",
            // stdout is hidden. Instead, all logs go through TauriLogLayer to the debug console.
            let tauri_layer = TauriLogLayer::new(app.handle().clone());
            tracing_subscriber::registry()
                .with(tauri_layer)
                .init();
            // Initialize the app handle in the bridge manager
            bridge_manager.lock().set_app_handle(app.handle().clone());
            // Initialize the app handle in the Discord RPC manager for logging
            discord_rpc.set_app_handle(app.handle());
            // Clean up any orphaned temp files from previous sessions
            if let Ok(count) = temp_manager.lock().cleanup_orphaned_files() {
                if count > 0 {
-                    println!("Cleaned up {} orphaned temp files", count);
+                    tracing::info!("Cleaned up {} orphaned temp files", count);
                }
            }
            tracing::info!("Hikari Desktop started successfully");
            // Set up system tray
            if let Err(e) = setup_tray(app.handle()) {
-                eprintln!("Failed to set up system tray: {}", e);
+                tracing::error!("Failed to set up system tray: {}", e);
            }
-            // Handle window close event for minimize to tray
+            // Handle window close event for minimize to tray and close confirmation
            let main_window = app.get_webview_window("main").unwrap();
            main_window.on_window_event({
                let app_handle = app.handle().clone();
                move |event| {
                    if let tauri::WindowEvent::CloseRequested { api, .. } = event {
-                        if should_minimize_to_tray(&app_handle) {
+                        // Always prevent default close - let frontend handle it
                        api.prevent_close();
                        // Emit event to frontend to show confirmation modal
                        if let Some(window) = app_handle.get_webview_window("main") {
-                                let _ = window.hide();
+                            let _ = window.emit("window-close-requested", ());
                            }
                        }
                    }
                }
@@ -169,6 +192,11 @@ pub fn run() {
            get_today_cost,
            get_week_cost,
            get_month_cost,
            init_discord_rpc,
            update_discord_rpc,
            stop_discord_rpc,
            log_discord_rpc,
            close_application,
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
@@ -86,6 +86,8 @@ impl ContextWarning {
 /// Get the context window limit (in tokens) for a given model
 fn get_context_window_limit(model: &str) -> u64 {
    match model {
        // Claude 4.6 family - 200K standard (1M beta available via header)
        "claude-opus-4-6" => 200_000,
        // Claude 4.5 family - 200K standard context
        "claude-opus-4-5-20251101"
        | "claude-sonnet-4-5-20250929"
@@ -154,6 +156,16 @@ pub struct UsageStats {
    // Achievement tracking
    #[serde(skip)]
    pub achievements: AchievementProgress,
    // Track current in-flight request for cost estimation on interrupt
    #[serde(skip)]
    pub current_request_input: Option<String>,
    #[serde(skip)]
    pub current_request_output_chars: u64,
    #[serde(skip)]
    pub current_request_thinking_chars: u64,
    #[serde(skip)]
    pub current_request_tools: Vec<String>,
 }
 impl UsageStats {
@@ -163,13 +175,26 @@ impl UsageStats {
        stats
    }
-    pub fn add_usage(&mut self, input_tokens: u64, output_tokens: u64, model: &str) {
+    pub fn add_usage(
        &mut self,
        input_tokens: u64,
        output_tokens: u64,
        model: &str,
        cache_creation_tokens: Option<u64>,
        cache_read_tokens: Option<u64>,
    ) {
        self.total_input_tokens += input_tokens;
        self.total_output_tokens += output_tokens;
        self.session_input_tokens += input_tokens;
        self.session_output_tokens += output_tokens;
-        let cost = calculate_cost(input_tokens, output_tokens, model);
+        let cost = calculate_cost(
            input_tokens,
            output_tokens,
            model,
            cache_creation_tokens,
            cache_read_tokens,
        );
        self.total_cost_usd += cost;
        self.session_cost_usd += cost;
@@ -439,6 +464,10 @@ impl UsageStats {
            potential_cache_hits: self.potential_cache_hits,
            potential_cache_savings_tokens: self.potential_cache_savings_tokens,
            achievements: AchievementProgress::new(), // Dummy for copy
            current_request_input: None, // Don't copy tracking fields
            current_request_output_chars: 0,
            current_request_thinking_chars: 0,
            current_request_tools: Vec::new(),
        };
        check_achievements(&stats_copy, &mut self.achievements)
    }
@@ -462,9 +491,19 @@ fn is_consecutive_day(prev_date: &str, current_date: &str) -> bool {
 // Pricing as of February 2026
 // https://platform.claude.com/docs/en/about-claude/models/overview
-pub fn calculate_cost(input_tokens: u64, output_tokens: u64, model: &str) -> f64 {
+// Cache pricing: https://platform.claude.com/docs/en/build-with-claude/prompt-caching
 pub fn calculate_cost(
    input_tokens: u64,
    output_tokens: u64,
    model: &str,
    cache_creation_tokens: Option<u64>,
    cache_read_tokens: Option<u64>,
 ) -> f64 {
    let (input_price_per_million, output_price_per_million) = match model {
-        // Current generation (Claude 4.5)
+        // Current generation (Claude 4.6)
        "claude-opus-4-6" => (5.0, 25.0),
        // Previous generation (Claude 4.5)
        "claude-opus-4-5-20251101" => (5.0, 25.0),
        "claude-sonnet-4-5-20250929" => (3.0, 15.0),
        "claude-haiku-4-5-20251001" => (1.0, 5.0),
@@ -487,10 +526,25 @@ pub fn calculate_cost(input_tokens: u64, output_tokens: u64, model: &str) -> f64
        _ => (3.0, 15.0),
    };
    // Regular input/output tokens
    let input_cost = (input_tokens as f64 / 1_000_000.0) * input_price_per_million;
    let output_cost = (output_tokens as f64 / 1_000_000.0) * output_price_per_million;
-    input_cost + output_cost
+    // Cache write tokens (cache creation) cost 1.25x the base input price
    let cache_write_cost = if let Some(cache_creation) = cache_creation_tokens {
        (cache_creation as f64 / 1_000_000.0) * input_price_per_million * 1.25
    } else {
        0.0
    };
    // Cache read tokens cost 0.1x (10%) the base input price
    let cache_read_cost = if let Some(cache_read) = cache_read_tokens {
        (cache_read as f64 / 1_000_000.0) * input_price_per_million * 0.1
    } else {
        0.0
    };
    input_cost + output_cost + cache_write_cost + cache_read_cost
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -564,7 +618,7 @@ pub async fn save_stats(app: &tauri::AppHandle, stats: &UsageStats) -> Result<()
    let persisted = PersistedStats::from(stats);
-    println!("Saving stats: {:?}", persisted);
+    tracing::info!("Saving stats: {:?}", persisted);
    store.set(
        "lifetime_stats",
@@ -572,32 +626,32 @@ pub async fn save_stats(app: &tauri::AppHandle, stats: &UsageStats) -> Result<()
    );
    store.save().map_err(|e| e.to_string())?;
-    println!("Stats saved successfully");
+    tracing::info!("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...");
+    tracing::info!("Loading stats from store...");
    let store = match app.store("stats.json") {
        Ok(s) => s,
        Err(e) => {
-            println!("Failed to open stats store: {}", e);
+            tracing::error!("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);
+        tracing::info!("Found lifetime stats in store: {:?}", stats_value);
        if let Ok(persisted) = serde_json::from_value::<PersistedStats>(stats_value.clone()) {
-            println!("Loaded lifetime stats successfully");
+            tracing::info!("Loaded lifetime stats successfully");
            return Some(persisted);
        } else {
-            println!("Failed to parse lifetime stats");
+            tracing::error!("Failed to parse lifetime stats");
        }
    } else {
-        println!("No lifetime stats found in store");
+        tracing::info!("No lifetime stats found in store");
    }
    None
@@ -609,7 +663,7 @@ mod tests {
    #[test]
    fn test_cost_calculation_sonnet() {
-        let cost = calculate_cost(1000, 2000, "claude-sonnet-4-20250514");
+        let cost = calculate_cost(1000, 2000, "claude-sonnet-4-20250514", None, None);
        // 1000 input * $3/M = $0.003
        // 2000 output * $15/M = $0.030
        // Total = $0.033
@@ -618,7 +672,7 @@ mod tests {
    #[test]
    fn test_cost_calculation_opus() {
-        let cost = calculate_cost(1000, 2000, "claude-opus-4-20250514");
+        let cost = calculate_cost(1000, 2000, "claude-opus-4-20250514", None, None);
        // 1000 input * $15/M = $0.015
        // 2000 output * $75/M = $0.150
        // Total = $0.165
@@ -627,7 +681,7 @@ mod tests {
    #[test]
    fn test_cost_calculation_opus_45() {
-        let cost = calculate_cost(1000, 2000, "claude-opus-4-5-20251101");
+        let cost = calculate_cost(1000, 2000, "claude-opus-4-5-20251101", None, None);
        // Opus 4.5 pricing: $5/MTok input, $25/MTok output
        // 1000 input tokens = $0.005, 2000 output tokens = $0.05
        // Total = $0.055
@@ -636,7 +690,7 @@ mod tests {
    #[test]
    fn test_cost_calculation_haiku() {
-        let cost = calculate_cost(1000, 2000, "claude-3-5-haiku-20241022");
+        let cost = calculate_cost(1000, 2000, "claude-3-5-haiku-20241022", None, None);
        // 1000 input * $1/M = $0.001
        // 2000 output * $5/M = $0.010
        // Total = $0.011
@@ -645,14 +699,14 @@ mod tests {
    #[test]
    fn test_cost_calculation_unknown_defaults_to_sonnet() {
-        let cost = calculate_cost(1000, 2000, "some-unknown-model");
+        let cost = calculate_cost(1000, 2000, "some-unknown-model", None, None);
        // 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");
+        let cost = calculate_cost(1000, 2000, "claude-3-5-sonnet-20241022", None, None);
        // Same as Sonnet 4 pricing
        assert!((cost - 0.033).abs() < 0.0001);
    }
@@ -660,7 +714,7 @@ mod tests {
    #[test]
    fn test_usage_stats_accumulation() {
        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514");
+        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514", None, None);
        assert_eq!(stats.total_input_tokens, 1000);
        assert_eq!(stats.total_output_tokens, 2000);
@@ -672,8 +726,8 @@ mod tests {
    #[test]
    fn test_usage_stats_multiple_accumulations() {
        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514");
+        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514", None, None);
-        stats.add_usage(500, 500, "claude-sonnet-4-20250514");
+        stats.add_usage(500, 500, "claude-sonnet-4-20250514", None, None);
        assert_eq!(stats.total_input_tokens, 1500);
        assert_eq!(stats.total_output_tokens, 1500);
@@ -684,17 +738,17 @@ mod tests {
    #[test]
    fn test_usage_stats_model_updated() {
        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514");
+        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514", None, None);
        assert_eq!(stats.model, Some("claude-sonnet-4-20250514".to_string()));
-        stats.add_usage(500, 500, "claude-opus-4-20250514");
+        stats.add_usage(500, 500, "claude-opus-4-20250514", None, None);
        assert_eq!(stats.model, Some("claude-opus-4-20250514".to_string()));
    }
    #[test]
    fn test_session_reset() {
        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514");
+        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514", None, None);
        stats.reset_session();
        assert_eq!(stats.total_input_tokens, 1000);
@@ -921,7 +975,7 @@ mod tests {
    #[test]
    fn test_usage_stats_serialization() {
        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514");
+        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514", None, None);
        stats.increment_messages();
        // UsageStats should be serializable (for events)
@@ -950,7 +1004,7 @@ mod tests {
    #[test]
    fn test_stats_update_event_serialization() {
        let mut stats = UsageStats::new();
-        stats.add_usage(100, 200, "claude-sonnet-4-20250514");
+        stats.add_usage(100, 200, "claude-sonnet-4-20250514", None, None);
        let event = StatsUpdateEvent { stats };
        let json = serde_json::to_string(&event).expect("Failed to serialize");
@@ -1004,7 +1058,7 @@ mod tests {
    #[test]
    fn test_context_tracking_update() {
        let mut stats = UsageStats::new();
-        stats.add_usage(50_000, 10_000, "claude-sonnet-4-20250514");
+        stats.add_usage(50_000, 10_000, "claude-sonnet-4-20250514", None, None);
        assert_eq!(stats.context_tokens_used, 50_000);
        assert_eq!(stats.context_window_limit, 200_000);
@@ -1014,8 +1068,8 @@ mod tests {
    #[test]
    fn test_context_tracking_accumulates() {
        let mut stats = UsageStats::new();
-        stats.add_usage(50_000, 10_000, "claude-sonnet-4-20250514");
+        stats.add_usage(50_000, 10_000, "claude-sonnet-4-20250514", None, None);
-        stats.add_usage(50_000, 10_000, "claude-sonnet-4-20250514");
+        stats.add_usage(50_000, 10_000, "claude-sonnet-4-20250514", None, None);
        assert_eq!(stats.context_tokens_used, 100_000);
        assert!((stats.context_utilisation_percent - 50.0).abs() < 0.1);
@@ -1079,7 +1133,7 @@ mod tests {
    #[test]
    fn test_context_reset_on_session_reset() {
        let mut stats = UsageStats::new();
-        stats.add_usage(100_000, 20_000, "claude-sonnet-4-20250514");
+        stats.add_usage(100_000, 20_000, "claude-sonnet-4-20250514", None, None);
        assert!(stats.context_tokens_used > 0);
        assert!(stats.context_utilisation_percent > 0.0);
@@ -77,8 +77,8 @@ impl TempFileManager {
            for file_path in files {
                if file_path.exists() {
                    if let Err(e) = fs::remove_file(&file_path) {
-                        eprintln!(
+                        tracing::warn!(
-                            "Warning: Failed to remove temp file {:?}: {}",
+                            "Failed to remove temp file {:?}: {}",
                            file_path, e
                        );
                    }
@@ -115,7 +115,7 @@ impl TempFileManager {
            let path = entry.path();
            if path.is_file() && !tracked_files.contains(&path) {
                if let Err(e) = fs::remove_file(&path) {
-                    eprintln!("Warning: Failed to remove orphaned file {:?}: {}", path, e);
+                    tracing::warn!("Failed to remove orphaned file {:?}: {}", path, e);
                } else {
                    cleaned_count += 1;
                }
@@ -4,8 +4,6 @@ use tauri::{
    AppHandle, Manager,
 };
 use crate::config::HikariConfig;
 pub fn setup_tray(app: &AppHandle) -> tauri::Result<()> {
    let show_item = MenuItem::with_id(app, "show", "Show Hikari", true, None::<&str>)?;
    let quit_item = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
@@ -48,21 +46,3 @@ pub fn setup_tray(app: &AppHandle) -> tauri::Result<()> {
    Ok(())
 }
 pub fn should_minimize_to_tray(app: &AppHandle) -> bool {
    let config_path = app
        .path()
        .app_config_dir()
        .ok()
        .map(|p| p.join("hikari-config.json"));
    if let Some(path) = config_path {
        if let Ok(content) = std::fs::read_to_string(&path) {
            if let Ok(config) = serde_json::from_str::<HikariConfig>(&content) {
                return config.minimize_to_tray;
            }
        }
    }
    false
 }
@@ -4,6 +4,10 @@ use serde::{Deserialize, Serialize};
 pub struct UsageInfo {
    pub input_tokens: u64,
    pub output_tokens: u64,
    #[serde(default)]
    pub cache_creation_input_tokens: Option<u64>,
    #[serde(default)]
    pub cache_read_input_tokens: Option<u64>,
 }
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
@@ -193,14 +197,21 @@ pub struct OutputEvent {
    pub conversation_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cost: Option<MessageCost>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_tool_use_id: Option<String>,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PermissionPromptEvent {
+pub struct PermissionPromptEventItem {
    pub id: String,
    pub tool_name: String,
    pub tool_input: serde_json::Value,
    pub description: String,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PermissionPromptEvent {
    pub permissions: Vec<PermissionPromptEventItem>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conversation_id: Option<String>,
 }
@@ -244,6 +255,33 @@ pub struct UserQuestionEvent {
    pub conversation_id: Option<String>,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AgentStartEvent {
    pub tool_use_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    pub description: String,
    pub subagent_type: String,
    pub started_at: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conversation_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_tool_use_id: Option<String>,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AgentEndEvent {
    pub tool_use_id: String,
    pub ended_at: u64,
    pub is_error: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conversation_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub num_turns: Option<u32>,
 }
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -365,6 +403,7 @@ mod tests {
            tool_name: None,
            conversation_id: None,
            cost: None,
            parent_tool_use_id: None,
        };
        let serialized = serde_json::to_string(&event).unwrap();
@@ -384,6 +423,7 @@ mod tests {
                output_tokens: 50,
                cost_usd: 0.005,
            }),
            parent_tool_use_id: None,
        };
        let serialized = serde_json::to_string(&event).unwrap();
@@ -2,6 +2,7 @@ use std::io::{BufRead, BufReader, Write};
 use std::process::{Child, ChildStdin, Command, Stdio};
 use std::sync::Arc;
 use std::thread;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tauri::{AppHandle, Emitter};
 use tempfile::NamedTempFile;
@@ -13,11 +14,26 @@ use crate::commands::record_cost;
 use crate::config::ClaudeStartOptions;
 use crate::stats::{calculate_cost, StatsUpdateEvent, UsageStats};
 use crate::types::{
-    CharacterState, ClaudeMessage, ConnectionEvent, ConnectionStatus, ContentBlock, MessageCost,
+    AgentEndEvent, AgentStartEvent, CharacterState, ClaudeMessage, ConnectionEvent,
-    OutputEvent, PermissionPromptEvent, QuestionOption, SessionEvent, StateChangeEvent,
+    ConnectionStatus, ContentBlock, MessageCost, OutputEvent, PermissionPromptEvent,
    PermissionPromptEventItem, QuestionOption, SessionEvent, StateChangeEvent,
    UserQuestionEvent, WorkingDirectoryEvent,
 };
 use parking_lot::RwLock;
 use std::cell::RefCell;
 thread_local! {
    /// Stores pending tool uses from the most recent Assistant message
    /// to enable batching permission requests for sibling cancelled tools
    static PENDING_TOOL_USES: RefCell<Vec<PendingToolUse>> = const { RefCell::new(Vec::new()) };
 }
 #[derive(Debug, Clone)]
 struct PendingToolUse {
    tool_use_id: String,
    tool_name: String,
    tool_input: serde_json::Value,
 }
 const SEARCH_TOOLS: [&str; 5] = ["Read", "Glob", "Grep", "WebSearch", "WebFetch"];
 const CODING_TOOLS: [&str; 3] = ["Edit", "Write", "NotebookEdit"];
@@ -117,21 +133,21 @@ impl WslBridge {
        let app_clone = app.clone();
        let stats = self.stats.clone();
        tauri::async_runtime::spawn(async move {
-            println!("Loading saved achievements...");
+            tracing::info!("Loading saved achievements...");
            let achievements = crate::achievements::load_achievements(&app_clone).await;
-            println!(
+            tracing::info!(
                "Loaded {} unlocked achievements",
                achievements.unlocked.len()
            );
-            println!("Loading saved stats...");
+            tracing::info!("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");
+                tracing::info!("Applying persisted lifetime stats");
                stats_guard.apply_persisted(persisted);
            }
        });
@@ -173,8 +189,8 @@ impl WslBridge {
        // Detect if we're running inside WSL or on Windows
        let is_wsl = detect_wsl();
-        eprintln!("[DEBUG] is_wsl: {}", is_wsl);
+        tracing::debug!("is_wsl: {}", is_wsl);
-        eprintln!("[DEBUG] options: {:?}", options);
+        tracing::debug!("options: {:?}", options);
        let mut command = if is_wsl {
            // Running inside WSL - call claude directly
@@ -183,8 +199,8 @@ impl WslBridge {
                "Could not find claude binary. Is Claude Code installed?".to_string()
            })?;
-            eprintln!("[DEBUG] Found claude at: {}", claude_path);
+            tracing::debug!("Found claude at: {}", claude_path);
-            eprintln!("[DEBUG] Working dir: {}", working_dir);
+            tracing::debug!("Working dir: {}", working_dir);
            let mut cmd = Command::new(&claude_path);
            cmd.args([
@@ -193,6 +209,8 @@ impl WslBridge {
                "--input-format",
                "stream-json",
                "--verbose",
                "--debug",
                "hooks",
            ]);
            // Add model if specified
@@ -238,7 +256,7 @@ impl WslBridge {
            cmd
        } else {
            // Running on Windows - use wsl with bash login shell to ensure PATH is loaded
-            eprintln!("[DEBUG] Windows path - using wsl");
+            tracing::debug!("Windows path - using wsl");
            let mut cmd = Command::new("wsl");
            // Build the claude command with all arguments
@@ -304,7 +322,7 @@ impl WslBridge {
            .stderr(Stdio::piped());
        let mut child = command.spawn().map_err(|e| {
-            eprintln!("[DEBUG] Spawn error: {:?}", e);
+            tracing::error!("Spawn error: {:?}", e);
            format!("Failed to spawn process: {}", e)
        })?;
@@ -355,6 +373,15 @@ impl WslBridge {
    pub fn send_message(&mut self, message: &str) -> Result<(), String> {
        let stdin = self.stdin.as_mut().ok_or("Process not running")?;
        // Track input for cost estimation on interrupt
        {
            let mut stats = self.stats.write();
            stats.current_request_input = Some(message.to_string());
            stats.current_request_output_chars = 0;
            stats.current_request_thinking_chars = 0;
            stats.current_request_tools.clear();
        }
        let input = serde_json::json!({
            "type": "user",
            "message": {
@@ -419,6 +446,9 @@ impl WslBridge {
        // we have to kill the process. This is the only reliable way to stop it.
        // See: https://github.com/anthropics/claude-code/issues/3455
        if let Some(mut process) = self.process.take() {
            // Estimate cost for interrupted request before killing
            self.estimate_interrupted_request_cost(app);
            // Kill the process immediately
            let _ = process.kill();
            let _ = process.wait();
@@ -426,6 +456,15 @@ impl WslBridge {
            // Clear stdin
            self.stdin = None;
            // Clear tracking fields
            {
                let mut stats = self.stats.write();
                stats.current_request_input = None;
                stats.current_request_output_chars = 0;
                stats.current_request_thinking_chars = 0;
                stats.current_request_tools.clear();
            }
            // Keep session_id and working directory for user reference
            // The user will see what session was interrupted
@@ -442,6 +481,99 @@ impl WslBridge {
        }
    }
    fn estimate_interrupted_request_cost(&mut self, app: &AppHandle) {
        // Read tracking data from stats
        let (input_chars, output_chars, thinking_chars, tools, model) = {
            let stats = self.stats.read();
            // Only estimate if we have tracked content
            if stats.current_request_input.is_none()
                && stats.current_request_output_chars == 0
                && stats.current_request_thinking_chars == 0
                && stats.current_request_tools.is_empty() {
                return;
            }
            let input_chars = stats.current_request_input.as_ref().map(|s| s.len() as u64).unwrap_or(0);
            let model = stats.model.clone().unwrap_or_else(|| "claude-sonnet-4-5-20250929".to_string());
            (input_chars, stats.current_request_output_chars, stats.current_request_thinking_chars, stats.current_request_tools.clone(), model)
        };
        tracing::info!("[COST ESTIMATION] Estimating cost for interrupted request");
        // Use conservative 3.5 chars/token for estimation (vs standard 4)
        let estimated_input_tokens = (input_chars as f64 / 3.5).ceil() as u64;
        let estimated_output_tokens = ((output_chars as f64 / 3.5).ceil() as u64)
            + ((thinking_chars as f64 / 3.5).ceil() as u64);
        // Add tool overhead based on session averages
        let mut tool_overhead_tokens = 0u64;
        {
            let stats = self.stats.read();
            for tool_name in &tools {
                if let Some(tool_stats) = stats.session_tools_usage.get(tool_name) {
                    if tool_stats.call_count > 0 {
                        // Use session average tokens per call for this tool
                        let avg_tokens = (tool_stats.estimated_input_tokens + tool_stats.estimated_output_tokens)
                            / tool_stats.call_count;
                        tool_overhead_tokens += avg_tokens;
                        tracing::info!("[COST ESTIMATION] Tool {} average: {} tokens", tool_name, avg_tokens);
                    }
                }
            }
        }
        let total_estimated_input = estimated_input_tokens + tool_overhead_tokens;
        let total_estimated_output = estimated_output_tokens;
        // Add 20% safety margin to overestimate
        let safety_margin = 1.2;
        let conservative_input = (total_estimated_input as f64 * safety_margin).ceil() as u64;
        let conservative_output = (total_estimated_output as f64 * safety_margin).ceil() as u64;
        tracing::info!("[COST ESTIMATION] Input: {} chars → {} tokens (+ {} tool overhead) × 1.2 safety = {} tokens",
            input_chars, estimated_input_tokens, tool_overhead_tokens, conservative_input);
        tracing::info!("[COST ESTIMATION] Output: {} chars → {} tokens × 1.2 safety = {} tokens",
            output_chars + thinking_chars,
            estimated_output_tokens, conservative_output);
        // Calculate cost (no cache tokens for interrupted requests)
        let estimated_cost = calculate_cost(
            conservative_input,
            conservative_output,
            &model,
            None,
            None,
        );
        tracing::info!("[COST ESTIMATION] Estimated cost: ${:.4} (conservative)", estimated_cost);
        // Add to stats with estimated flag
        {
            let mut stats_guard = self.stats.write();
            stats_guard.add_usage(
                conservative_input,
                conservative_output,
                &model,
                None,
                None,
            );
        }
        // Emit stats update
        let stats_update_event = StatsUpdateEvent {
            stats: self.stats.read().clone(),
        };
        let _ = app.emit("claude:stats", stats_update_event);
        // Record to historical cost tracking (mark as estimated)
        let app_clone = app.clone();
        tauri::async_runtime::spawn(async move {
            record_cost(&app_clone, conservative_input, conservative_output, estimated_cost).await;
        });
    }
    pub fn stop(&mut self, app: &AppHandle) {
        if let Some(mut process) = self.process.take() {
            let _ = process.kill();
@@ -455,11 +587,11 @@ impl WslBridge {
        let stats_snapshot = self.stats.read().clone();
        let app_clone = app.clone();
        tauri::async_runtime::spawn(async move {
-            println!("Saving stats on session stop...");
+            tracing::info!("Saving stats on session stop...");
            if let Err(e) = crate::stats::save_stats(&app_clone, &stats_snapshot).await {
-                eprintln!("Failed to save stats: {}", e);
+                tracing::error!("Failed to save stats: {}", e);
            } else {
-                println!("Stats saved successfully on session stop");
+                tracing::info!("Stats saved successfully on session stop");
            }
        });
@@ -504,11 +636,11 @@ fn handle_stdout(
        match line {
            Ok(line) if !line.is_empty() => {
                if let Err(e) = process_json_line(&line, &app, &stats, &conversation_id) {
-                    eprintln!("Error processing line: {}", e);
+                    tracing::error!("Error processing line: {}", e);
                }
            }
            Err(e) => {
-                eprintln!("Error reading stdout: {}", e);
+                tracing::error!("Error reading stdout: {}", e);
                break;
            }
            _ => {}
@@ -528,6 +660,25 @@ fn handle_stderr(
    for line in reader.lines() {
        match line {
            Ok(line) if !line.is_empty() => {
                // Check if this is a SubagentStart hook message
                if line.contains("[SubagentStart Hook]") {
                    if let Some(agent_data) = parse_subagent_start_hook(&line) {
                        tracing::debug!("Parsed SubagentStart hook: agent_id={}, parent={:?}",
                            agent_data.agent_id, agent_data.parent_tool_use_id);
                        // Emit an agent-update event with the agent_id
                        let _ = app.emit(
                            "claude:agent-update",
                            serde_json::json!({
                                "conversationId": conversation_id.clone(),
                                "toolUseId": agent_data.parent_tool_use_id,
                                "agentId": agent_data.agent_id,
                            }),
                        );
                    }
                }
                // Still emit the stderr line as output
                let _ = app.emit(
                    "claude:output",
                    OutputEvent {
@@ -536,6 +687,7 @@ fn handle_stderr(
                        tool_name: None,
                        conversation_id: conversation_id.clone(),
                        cost: None,
                        parent_tool_use_id: None,
                    },
                );
            }
@@ -545,6 +697,41 @@ fn handle_stderr(
    }
 }
 #[derive(Debug)]
 struct SubagentStartData {
    agent_id: String,
    parent_tool_use_id: Option<String>,
 }
 fn parse_subagent_start_hook(line: &str) -> Option<SubagentStartData> {
    // Parse: [SubagentStart Hook] agent_id=agent-xxx, parent_tool_use_id=Some("toolu_xxx"), ...
    // Extract agent_id
    let agent_id = line
        .split("agent_id=")
        .nth(1)?
        .split(',')
        .next()?
        .trim()
        .to_string();
    // Extract parent_tool_use_id if present
    let parent_tool_use_id = if line.contains("parent_tool_use_id=Some") {
        line.split("parent_tool_use_id=Some(\"")
            .nth(1)?
            .split('"')
            .next()
            .map(|s| s.to_string())
    } else {
        None
    };
    Some(SubagentStartData {
        agent_id,
        parent_tool_use_id,
    })
 }
 fn process_json_line(
    line: &str,
    app: &AppHandle,
@@ -584,7 +771,7 @@ fn process_json_line(
            }
        }
-        ClaudeMessage::Assistant { message, .. } => {
+        ClaudeMessage::Assistant { message, parent_tool_use_id } => {
            let mut state = CharacterState::Typing;
            let mut tool_name = None;
@@ -598,14 +785,56 @@ fn process_json_line(
                })
                .collect();
            // Store pending tool uses for permission batching (only for top-level, not subagents)
            if parent_tool_use_id.is_none() {
                PENDING_TOOL_USES.with(|pending| {
                    let tool_uses: Vec<PendingToolUse> = message
                        .content
                        .iter()
                        .filter_map(|block| match block {
                            ContentBlock::ToolUse { id, name, input } => Some(PendingToolUse {
                                tool_use_id: id.clone(),
                                tool_name: name.clone(),
                                tool_input: input.clone(),
                            }),
                            _ => None,
                        })
                        .collect();
                    // Append to existing pending tools instead of replacing
                    pending.borrow_mut().extend(tool_uses);
                });
            }
            // Track message cost for display
            let mut message_cost: Option<MessageCost> = None;
            // Only update stats if we have usage information
            if let Some(usage) = &message.usage {
-                if let Some(model) = &message.model {
+                // Get model from message, or fall back to last known model from stats
-                    // Calculate cost for historical tracking
+                let model = message.model.clone().or_else(|| {
-                    let cost_usd = calculate_cost(usage.input_tokens, usage.output_tokens, model);
+                    let stats_guard = stats.read();
                    stats_guard.model.clone()
                }).unwrap_or_else(|| {
                    tracing::warn!("No model info available for cost calculation, using default");
                    "claude-sonnet-4-5-20250929".to_string()
                });
                // Calculate cost for historical tracking (including cache tokens)
                let cost_usd = calculate_cost(
                    usage.input_tokens,
                    usage.output_tokens,
                    &model,
                    usage.cache_creation_input_tokens,
                    usage.cache_read_input_tokens,
                );
                tracing::info!("Assistant message tokens - input: {}, output: {}, cache_creation: {:?}, cache_read: {:?}, cost: ${:.4}",
                    usage.input_tokens,
                    usage.output_tokens,
                    usage.cache_creation_input_tokens,
                    usage.cache_read_input_tokens,
                    cost_usd
                );
                // Store cost for later use in output events
                message_cost = Some(MessageCost {
@@ -618,7 +847,13 @@ fn process_json_line(
                {
                    let mut stats_guard = stats.write();
                    stats_guard.increment_messages();
-                        stats_guard.add_usage(usage.input_tokens, usage.output_tokens, model);
+                    stats_guard.add_usage(
                        usage.input_tokens,
                        usage.output_tokens,
                        &model,
                        usage.cache_creation_input_tokens,
                        usage.cache_read_input_tokens,
                    );
                    stats_guard.get_session_duration();
                    // Attribute tokens to tools if any tools were used in this message
@@ -645,14 +880,10 @@ fn process_json_line(
                // Just increment message count if no usage info
                stats.write().increment_messages();
            }
            } else {
                // Just increment message count if no usage info
                stats.write().increment_messages();
            }
            for block in &message.content {
                match block {
-                    ContentBlock::ToolUse { name, input, .. } => {
+                    ContentBlock::ToolUse { id, name, input } => {
                        tool_name = Some(name.clone());
                        state = get_tool_state(name);
@@ -669,6 +900,42 @@ fn process_json_line(
                            }
                        }
                        // Emit agent-start event for Task tool invocations
                        if name == "Task" {
                            let description = input
                                .get("description")
                                .and_then(|v| v.as_str())
                                .unwrap_or("Subagent")
                                .to_string();
                            let subagent_type = input
                                .get("subagent_type")
                                .and_then(|v| v.as_str())
                                .unwrap_or("unknown")
                                .to_string();
                            let now = SystemTime::now()
                                .duration_since(UNIX_EPOCH)
                                .unwrap_or_default()
                                .as_millis() as u64;
                            tracing::debug!(
                                "Emitting agent-start: id={}, desc={}, type={}, parent={:?}",
                                id, description, subagent_type, parent_tool_use_id
                            );
                            let _ = app.emit(
                                "claude:agent-start",
                                AgentStartEvent {
                                    tool_use_id: id.clone(),
                                    agent_id: None, // Will be updated when SubagentStart hook is received
                                    description,
                                    subagent_type,
                                    started_at: now,
                                    conversation_id: conversation_id.clone(),
                                    parent_tool_use_id: parent_tool_use_id.clone(),
                                },
                            );
                        }
                        let desc = format_tool_description(name, input);
                        let _ = app.emit(
                            "claude:output",
@@ -678,6 +945,7 @@ fn process_json_line(
                                tool_name: Some(name.clone()),
                                conversation_id: conversation_id.clone(),
                                cost: None, // Tool use doesn't have separate cost
                                parent_tool_use_id: parent_tool_use_id.clone(),
                            },
                        );
                    }
@@ -696,6 +964,7 @@ fn process_json_line(
                                tool_name: None,
                                conversation_id: conversation_id.clone(),
                                cost: message_cost.clone(), // Include cost with assistant text
                                parent_tool_use_id: parent_tool_use_id.clone(),
                            },
                        );
                    }
@@ -709,10 +978,34 @@ fn process_json_line(
                                tool_name: None,
                                conversation_id: conversation_id.clone(),
                                cost: None,
                                parent_tool_use_id: parent_tool_use_id.clone(),
                            },
                        );
                    }
                    ContentBlock::ToolResult {
                        tool_use_id,
                        is_error,
                        ..
                    } => {
                        // Emit agent-end for all tool results
                        // The frontend will ignore IDs that don't match known agents
                        let now = SystemTime::now()
                            .duration_since(UNIX_EPOCH)
                            .unwrap_or_default()
                            .as_millis() as u64;
                        let _ = app.emit(
                            "claude:agent-end",
                            AgentEndEvent {
                                tool_use_id: tool_use_id.clone(),
                                ended_at: now,
                                is_error: is_error.unwrap_or(false),
                                conversation_id: conversation_id.clone(),
                                duration_ms: None,
                                num_turns: None,
                            },
                        );
                    }
                    _ => {}
                }
            }
@@ -722,6 +1015,14 @@ fn process_json_line(
        ClaudeMessage::StreamEvent { event } => {
            if event.event_type == "content_block_start" {
                if let Some(block) = &event.content_block {
                    // Track tool calls for cost estimation
                    if block.block_type == "tool_use" {
                        if let Some(name) = &block.name {
                            let mut stats_guard = stats.write();
                            stats_guard.current_request_tools.push(name.clone());
                        }
                    }
                    let state = match block.block_type.as_str() {
                        "thinking" => CharacterState::Thinking,
                        "text" => CharacterState::Typing,
@@ -739,7 +1040,16 @@ fn process_json_line(
            } else if event.event_type == "content_block_delta" {
                if let Some(delta) = &event.delta {
                    if let Some(text) = &delta.text {
                        // Track output characters for cost estimation
                        {
                            let mut stats_guard = stats.write();
                            stats_guard.current_request_output_chars += text.len() as u64;
                        }
                        let _ = app.emit("claude:stream", text.clone());
                    } else if let Some(thinking) = &delta.thinking {
                        // Track thinking characters for cost estimation
                        let mut stats_guard = stats.write();
                        stats_guard.current_request_thinking_chars += thinking.len() as u64;
                    }
                }
            }
@@ -750,14 +1060,45 @@ fn process_json_line(
            result,
            permission_denials,
            usage,
-            ..
+            duration_ms,
            num_turns,
        } => {
            tracing::info!(
                "Received Result message: subtype={}, has_denials={}, denial_count={:?}",
                subtype,
                permission_denials.is_some(),
                permission_denials.as_ref().map(|d| d.len())
            );
            let state = if subtype == "success" {
                CharacterState::Success
            } else {
                CharacterState::Error
            };
            // Capture pending tool uses before clearing them
            // We'll use these for permission batching if there are denials
            let captured_pending_tools = PENDING_TOOL_USES.with(|pending| {
                let tools = pending.borrow().clone();
                // Clear immediately so they don't accumulate across requests
                pending.borrow_mut().clear();
                tools
            });
            tracing::debug!(
                "Captured {} pending tool use(s): {:?}",
                captured_pending_tools.len(),
                captured_pending_tools.iter().map(|t| &t.tool_name).collect::<Vec<_>>()
            );
            // Log turn metrics if available
            if let Some(duration) = duration_ms {
                tracing::info!("Turn completed in {}ms", duration);
            }
            if let Some(turns) = num_turns {
                tracing::info!("Turn count: {}", turns);
            }
            // Track token usage from Result messages if available
            // This captures tokens from tool outputs and other operations
            if let Some(usage_info) = usage {
@@ -768,12 +1109,29 @@ fn process_json_line(
                    stats_guard.model.clone().unwrap_or_else(|| "claude-opus-4-20250514".to_string())
                };
-                // Calculate cost for historical tracking
+                // Calculate cost for historical tracking (including cache tokens)
-                let cost_usd = calculate_cost(usage_info.input_tokens, usage_info.output_tokens, &model);
+                let cost_usd = calculate_cost(
                    usage_info.input_tokens,
                    usage_info.output_tokens,
                    &model,
                    usage_info.cache_creation_input_tokens,
                    usage_info.cache_read_input_tokens,
                );
                let mut stats_guard = stats.write();
-                stats_guard.add_usage(usage_info.input_tokens, usage_info.output_tokens, &model);
+                stats_guard.add_usage(
-                println!("Result message tokens - input: {}, output: {}", usage_info.input_tokens, usage_info.output_tokens);
+                    usage_info.input_tokens,
                    usage_info.output_tokens,
                    &model,
                    usage_info.cache_creation_input_tokens,
                    usage_info.cache_read_input_tokens,
                );
                tracing::info!("Result message tokens - input: {}, output: {}, cache_creation: {:?}, cache_read: {:?}",
                    usage_info.input_tokens,
                    usage_info.output_tokens,
                    usage_info.cache_creation_input_tokens,
                    usage_info.cache_read_input_tokens
                );
                // Record to historical cost tracking
                let app_clone = app.clone();
@@ -784,14 +1142,23 @@ fn process_json_line(
                });
            }
            // Clear tracking fields since request completed successfully
            {
                let mut stats_guard = stats.write();
                stats_guard.current_request_input = None;
                stats_guard.current_request_output_chars = 0;
                stats_guard.current_request_thinking_chars = 0;
                stats_guard.current_request_tools.clear();
            }
            // Always emit updated stats on result message (less frequent)
            // This includes the latest session duration
            let newly_unlocked = {
                let mut stats_guard = stats.write();
                stats_guard.get_session_duration();
-                println!("Checking achievements after result message...");
+                tracing::info!("Checking achievements after result message...");
                let unlocked = stats_guard.check_achievements();
-                println!("Newly unlocked achievements: {:?}", unlocked);
+                tracing::info!("Newly unlocked achievements: {:?}", unlocked);
                unlocked
            };
@@ -806,20 +1173,20 @@ fn process_json_line(
            // Save achievements after unlocking new ones
            if !newly_unlocked.is_empty() {
-                println!("Saving newly unlocked achievements: {:?}", newly_unlocked);
+                tracing::info!("Saving newly unlocked achievements: {:?}", newly_unlocked);
                let app_handle = app.clone();
                let achievements_progress = stats.read().achievements.clone();
                // Use Tauri's async runtime instead of tokio::spawn
                tauri::async_runtime::spawn(async move {
-                    println!("Spawned save task for achievements");
+                    tracing::info!("Spawned save task for achievements");
                    if let Err(e) =
                        crate::achievements::save_achievements(&app_handle, &achievements_progress)
                            .await
                    {
-                        eprintln!("Failed to save achievements: {}", e);
+                        tracing::error!("Failed to save achievements: {}", e);
                    } else {
-                        println!("Achievement save task completed successfully");
+                        tracing::info!("Achievement save task completed successfully");
                    }
                });
            }
@@ -836,9 +1203,9 @@ fn process_json_line(
            {
                let app_handle = app.clone();
                tauri::async_runtime::spawn(async move {
-                    println!("Periodic stats save (every 10 messages)...");
+                    tracing::info!("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);
+                        tracing::error!("Failed to save stats: {}", e);
                    }
                });
            }
@@ -854,6 +1221,7 @@ fn process_json_line(
                            tool_name: None,
                            conversation_id: conversation_id.clone(),
                            cost: None,
                            parent_tool_use_id: None,
                        },
                    );
                }
@@ -861,9 +1229,36 @@ fn process_json_line(
            // Check for permission denials and emit prompts for each
            if let Some(denials) = permission_denials {
-                let mut has_regular_denials = false;
+                // Only process if there are actually denials
                if !denials.is_empty() {
                    let mut regular_permission_requests = Vec::new();
                    // Get denied tool IDs for later comparison
                    let denied_tool_ids: Vec<String> = denials.iter()
                        .map(|d| d.tool_use_id.clone())
                        .collect();
                    // Helper function to check if a tool is a system tool that should never require permission
                    let is_system_tool = |tool_name: &str| -> bool {
                        matches!(tool_name, "ExitPlanMode" | "EnterPlanMode")
                    };
                    for denial in denials {
                    // Skip system tools that should never require permission
                    if is_system_tool(&denial.tool_name) {
                        tracing::debug!(
                            "Skipping system tool: {} (id: {})",
                            denial.tool_name,
                            denial.tool_use_id
                        );
                        continue;
                    }
                    tracing::debug!(
                        "Processing permission denial for: {} (id: {})",
                        denial.tool_name,
                        denial.tool_use_id
                    );
                    // Special handling for AskUserQuestion tool
                    if denial.tool_name == "AskUserQuestion" {
                        if let Some(questions) = denial
@@ -924,24 +1319,57 @@ fn process_json_line(
                            }
                        }
                    } else {
                        has_regular_denials = true;
                        let description =
                            format_tool_description(&denial.tool_name, &denial.tool_input);
-                        let _ = app.emit(
+                        regular_permission_requests.push(PermissionPromptEventItem {
                            "claude:permission",
                            PermissionPromptEvent {
                            id: denial.tool_use_id.clone(),
                            tool_name: denial.tool_name.clone(),
                            tool_input: denial.tool_input.clone(),
                            description,
-                                conversation_id: conversation_id.clone(),
+                        });
                            },
                        );
                    }
                }
-                // Show permission state if there were any denials (questions or regular)
+                // Check for sibling tools that may have been cancelled
-                if has_regular_denials || !denials.is_empty() {
+                // Add them to the permission batch so they can be approved together
                for tool_use in captured_pending_tools.iter() {
                    // Skip system tools that should never require permission
                    if is_system_tool(&tool_use.tool_name) {
                        continue;
                    }
                    // Only add tools that weren't explicitly denied (these are likely cancelled siblings)
                    if !denied_tool_ids.contains(&tool_use.tool_use_id) {
                        let description = format_tool_description(&tool_use.tool_name, &tool_use.tool_input);
                        regular_permission_requests.push(PermissionPromptEventItem {
                            id: tool_use.tool_use_id.clone(),
                            tool_name: tool_use.tool_name.clone(),
                            tool_input: tool_use.tool_input.clone(),
                            description,
                        });
                    }
                }
                // Emit all regular permission requests as a single batched event
                if !regular_permission_requests.is_empty() {
                    tracing::info!(
                        "Emitting permission event for {} tool(s) in conversation {:?}",
                        regular_permission_requests.len(),
                        conversation_id
                    );
                    for req in &regular_permission_requests {
                        tracing::debug!(
                            "Permission requested: {} (id: {})",
                            req.tool_name,
                            req.id
                        );
                    }
                    let _ = app.emit(
                        "claude:permission",
                        PermissionPromptEvent {
                            permissions: regular_permission_requests,
                            conversation_id: conversation_id.clone(),
                        },
                    );
                    emit_state_change(
                        app,
                        CharacterState::Permission,
@@ -950,7 +1378,19 @@ fn process_json_line(
                    );
                    return Ok(());
                }
                    // Show permission state if there were any question denials
                    if !denials.is_empty() {
                        emit_state_change(
                            app,
                            CharacterState::Permission,
                            None,
                            conversation_id.clone(),
                        );
                        return Ok(());
                    }
                } // end of else block for non-empty denials
            } // end of if let Some(denials)
            emit_state_change(app, state, None, conversation_id.clone());
        }
@@ -959,6 +1399,33 @@ fn process_json_line(
            // Increment message count for user messages
            stats.write().increment_messages();
            // Process content blocks for tool results (e.g., background Task agent completions)
            for block in &message.content {
                if let ContentBlock::ToolResult {
                    tool_use_id,
                    is_error,
                    ..
                } = block
                {
                    let now = SystemTime::now()
                        .duration_since(UNIX_EPOCH)
                        .unwrap_or_default()
                        .as_millis() as u64;
                    let _ = app.emit(
                        "claude:agent-end",
                        AgentEndEvent {
                            tool_use_id: tool_use_id.clone(),
                            ended_at: now,
                            is_error: is_error.unwrap_or(false),
                            conversation_id: conversation_id.clone(),
                            duration_ms: None,
                            num_turns: None,
                        },
                    );
                }
            }
            // Extract text content from the message
            let message_text = message
                .content
@@ -973,7 +1440,7 @@ fn process_json_line(
            // Check achievements after user message
            let newly_unlocked = {
                let mut stats_guard = stats.write();
-                println!("User sent message, checking achievements...");
+                tracing::info!("User sent message, checking achievements...");
                // Check message-based achievements
                let mut unlocked = crate::achievements::check_message_achievements(
@@ -990,7 +1457,7 @@ fn process_json_line(
            // Emit achievement events for any newly unlocked achievements
            for achievement_id in &newly_unlocked {
-                println!("User message unlocked achievement: {:?}", achievement_id);
+                tracing::info!("User message unlocked achievement: {:?}", achievement_id);
                let info = get_achievement_info(achievement_id);
                let _ = app.emit(
                    "achievement:unlocked",
@@ -1000,7 +1467,7 @@ fn process_json_line(
            // Save achievements after unlocking new ones
            if !newly_unlocked.is_empty() {
-                println!("Saving newly unlocked achievements from user message");
+                tracing::info!("Saving newly unlocked achievements from user message");
                let app_handle = app.clone();
                let achievements_progress = stats.read().achievements.clone();
                tauri::async_runtime::spawn(async move {
@@ -1008,9 +1475,9 @@ fn process_json_line(
                        crate::achievements::save_achievements(&app_handle, &achievements_progress)
                            .await
                    {
-                        eprintln!("Failed to save achievements: {}", e);
+                        tracing::error!("Failed to save achievements: {}", e);
                    } else {
-                        println!("Achievements saved after user message");
+                        tracing::info!("Achievements saved after user message");
                    }
                });
            }
@@ -48,15 +48,15 @@ $notifier.Show($toast)
    match output {
        Ok(result) => {
            if result.status.success() {
-                println!("WSL notification sent successfully");
+                tracing::info!("WSL notification sent successfully");
                return Ok(());
            } else {
                let stderr = String::from_utf8_lossy(&result.stderr);
-                println!("PowerShell toast failed: {}", stderr);
+                tracing::error!("PowerShell toast failed: {}", stderr);
            }
        }
        Err(e) => {
-            println!("Failed to run PowerShell: {}", e);
+            tracing::error!("Failed to run PowerShell: {}", e);
        }
    }
@@ -74,7 +74,7 @@ $notifier.Show($toast)
    if let Ok(result) = notify_result {
        if result.status.success() {
-            println!("Notification sent via wsl-notify-send");
+            tracing::info!("Notification sent via wsl-notify-send");
            return Ok(());
        }
    }
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "hikari-desktop",
-  "version": "1.2.0",
+  "version": "1.4.0",
  "identifier": "com.naomi.hikari-desktop",
  "build": {
    "beforeDevCommand": "pnpm dev",
@@ -8,9 +8,13 @@ import {
 } from "./slashCommands";
 // Mock all external dependencies
-vi.mock("svelte/store", () => ({
+vi.mock("svelte/store", async (importOriginal) => {
  const actual = await importOriginal<typeof import("svelte/store")>();
  return {
    ...actual,
    get: vi.fn(),
-}));
+  };
 });
 vi.mock("@tauri-apps/api/core", () => ({
  invoke: vi.fn(),
@@ -2,8 +2,10 @@ import { get } from "svelte/store";
 import { invoke } from "@tauri-apps/api/core";
 import { claudeStore } from "$lib/stores/claude";
 import { characterState } from "$lib/stores/character";
-import { setSkipNextGreeting } from "$lib/tauri";
+import { setSkipNextGreeting, updateDiscordRpc } from "$lib/tauri";
 import { searchState } from "$lib/stores/search";
 import { conversationsStore } from "$lib/stores/conversations";
 import { configStore } from "$lib/stores/config";
 export interface SlashCommand {
  name: string;
@@ -35,6 +37,12 @@ async function changeDirectory(path: string): Promise<void> {
    // Capture conversation history before disconnecting
    const conversationHistory = claudeStore.getConversationHistory();
    // Get currently granted tools and config auto-granted tools
    const activeConversation = get(conversationsStore.activeConversation);
    const grantedTools = activeConversation ? Array.from(activeConversation.grantedTools) : [];
    const config = configStore.getConfig();
    const allAllowedTools = [...new Set([...grantedTools, ...config.auto_granted_tools])];
    await invoke("stop_claude", { conversationId });
    // Wait for clean shutdown
@@ -48,9 +56,23 @@ async function changeDirectory(path: string): Promise<void> {
      conversationId,
      options: {
        working_dir: validatedPath,
        model: config.model || null,
        api_key: config.api_key || null,
        custom_instructions: config.custom_instructions || null,
        mcp_servers_json: config.mcp_servers_json || null,
        allowed_tools: allAllowedTools,
      },
    });
    // Update Discord RPC when reconnecting after directory change
    if (activeConversation) {
      await updateDiscordRpc(
        activeConversation.name,
        config.model || "claude",
        activeConversation.startedAt
      );
    }
    // Wait for connection to establish
    await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -89,6 +111,12 @@ async function startNewConversation(): Promise<void> {
      conversationId,
    });
    // Get granted tools before interrupting
    const activeConversation = get(conversationsStore.activeConversation);
    const grantedTools = activeConversation ? Array.from(activeConversation.grantedTools) : [];
    const config = configStore.getConfig();
    const allAllowedTools = [...new Set([...grantedTools, ...config.auto_granted_tools])];
    claudeStore.addLine("system", "Starting new conversation...");
    characterState.setState("thinking");
@@ -102,9 +130,23 @@ async function startNewConversation(): Promise<void> {
      conversationId,
      options: {
        working_dir: workingDir,
        model: config.model || null,
        api_key: config.api_key || null,
        custom_instructions: config.custom_instructions || null,
        mcp_servers_json: config.mcp_servers_json || null,
        allowed_tools: allAllowedTools,
      },
    });
    // Update Discord RPC when starting new conversation
    if (activeConversation) {
      await updateDiscordRpc(
        activeConversation.name,
        config.model || "claude",
        activeConversation.startedAt
      );
    }
    claudeStore.addLine("system", "New conversation started!");
    characterState.setState("idle");
  } catch (error) {
@@ -0,0 +1,328 @@
 <script lang="ts">
  import { SvelteMap } from "svelte/reactivity";
  import { invoke } from "@tauri-apps/api/core";
  import { claudeStore } from "$lib/stores/claude";
  import { agentStore, getAgentsForConversation } from "$lib/stores/agents";
  import type { AgentInfo } from "$lib/types/agents";
  import { onMount, onDestroy } from "svelte";
  interface Props {
    isOpen: boolean;
    onClose: () => void;
  }
  const { isOpen, onClose }: Props = $props();
  let now = $state(Date.now());
  let timerInterval: ReturnType<typeof setInterval> | null = null;
  // We need a reactive subscription to agents for the active conversation
  let agents: AgentInfo[] = $state([]);
  let agentsUnsubscribe: (() => void) | null = null;
  // Track active conversation reactively
  let currentConversationId = $state<string | null>("");
  const conversationIdUnsubscribe = claudeStore.activeConversationId.subscribe((id) => {
    currentConversationId = id;
  });
  $effect(() => {
    // Re-subscribe when conversation changes
    if (agentsUnsubscribe) {
      agentsUnsubscribe();
    }
    if (currentConversationId) {
      const store = getAgentsForConversation(currentConversationId);
      agentsUnsubscribe = store.subscribe((value) => {
        agents = value;
      });
    } else {
      agents = [];
    }
  });
  const runningAgents = $derived(agents.filter((a) => a.status === "running"));
  const completedAgents = $derived(agents.filter((a) => a.status === "completed"));
  const erroredAgents = $derived(agents.filter((a) => a.status === "errored"));
  // Organize agents into a tree structure based on parent_tool_use_id
  const agentTree = $derived.by(() => {
    const topLevel = agents.filter((a) => !a.parentToolUseId);
    const childrenMap = new SvelteMap<string, AgentInfo[]>();
    // Group children by their parent
    agents.forEach((agent) => {
      if (agent.parentToolUseId) {
        const siblings = childrenMap.get(agent.parentToolUseId) || [];
        siblings.push(agent);
        childrenMap.set(agent.parentToolUseId, siblings);
      }
    });
    return { topLevel, childrenMap };
  });
  onMount(() => {
    timerInterval = setInterval(() => {
      now = Date.now();
    }, 1000);
  });
  onDestroy(() => {
    if (timerInterval) clearInterval(timerInterval);
    if (agentsUnsubscribe) agentsUnsubscribe();
    conversationIdUnsubscribe();
  });
  function formatDuration(startedAt: number, endedAt?: number): string {
    const end = endedAt || now;
    const durationMs = end - startedAt;
    const seconds = Math.floor(durationMs / 1000);
    const minutes = Math.floor(seconds / 60);
    const hours = Math.floor(minutes / 60);
    if (hours > 0) {
      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
    }
    if (minutes > 0) {
      return `${minutes}m ${seconds % 60}s`;
    }
    return `${seconds}s`;
  }
  function getSubagentTypeLabel(type: string): string {
    const labels: Record<string, string> = {
      Explore: "Explorer",
      "general-purpose": "General",
      Plan: "Planner",
      Bash: "Shell",
    };
    return labels[type] || type;
  }
  function getStatusBadgeClass(status: string): string {
    switch (status) {
      case "running":
        return "bg-blue-500/20 text-blue-400 border-blue-500/30";
      case "completed":
        return "bg-green-500/20 text-green-400 border-green-500/30";
      case "errored":
        return "bg-red-500/20 text-red-400 border-red-500/30";
      default:
        return "bg-gray-500/20 text-gray-400 border-gray-500/30";
    }
  }
  async function handleKillAll() {
    if (!currentConversationId) return;
    try {
      await invoke("interrupt_claude", { conversationId: currentConversationId });
    } catch (error) {
      console.error("Failed to kill Claude process:", error);
    }
  }
  function handleClearCompleted() {
    if (currentConversationId) {
      agentStore.clearCompleted(currentConversationId);
    }
  }
  // Flatten the tree for rendering with depth information
  const flattenedAgents = $derived.by(() => {
    const result: { agent: AgentInfo; depth: number }[] = [];
    const { topLevel, childrenMap } = agentTree;
    function addAgentAndChildren(agent: AgentInfo, depth: number) {
      result.push({ agent, depth });
      const children = childrenMap.get(agent.toolUseId);
      if (children) {
        children.forEach((child) => addAgentAndChildren(child, depth + 1));
      }
    }
    topLevel.forEach((agent) => addAgentAndChildren(agent, 0));
    return result;
  });
 </script>
 {#if isOpen}
  <!-- svelte-ignore a11y_click_events_have_key_events -->
  <!-- svelte-ignore a11y_no_static_element_interactions -->
  <div class="fixed inset-0 z-40" onclick={onClose}></div>
  <div
    class="fixed top-12 right-0 bottom-0 w-80 bg-[var(--bg-primary)] border-l border-[var(--border-color)] shadow-xl z-50 flex flex-col overflow-hidden"
  >
    <!-- Header -->
    <div class="flex items-center justify-between p-4 border-b border-[var(--border-color)]">
      <div class="flex items-center gap-2">
        <svg
          class="w-5 h-5 text-[var(--accent-primary)]"
          fill="none"
          stroke="currentColor"
          viewBox="0 0 24 24"
        >
          <path
            stroke-linecap="round"
            stroke-linejoin="round"
            stroke-width="2"
            d="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"
          />
        </svg>
        <h3 class="text-sm font-semibold text-[var(--text-primary)]">Agent Monitor</h3>
        {#if runningAgents.length > 0}
          <span
            class="px-1.5 py-0.5 text-xs rounded-full bg-blue-500/20 text-blue-400 animate-pulse"
          >
            {runningAgents.length} running
          </span>
        {/if}
      </div>
      <button
        onclick={onClose}
        class="p-1 text-[var(--text-secondary)] hover:text-[var(--text-primary)] transition-colors"
        aria-label="Close agent monitor"
      >
        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
          <path
            stroke-linecap="round"
            stroke-linejoin="round"
            stroke-width="2"
            d="M6 18L18 6M6 6l12 12"
          />
        </svg>
      </button>
    </div>
    <!-- Action buttons -->
    <div class="flex gap-2 px-4 py-2 border-b border-[var(--border-color)]">
      <button
        onclick={handleKillAll}
        disabled={runningAgents.length === 0}
        class="flex-1 px-2 py-1 text-xs bg-red-500/20 hover:bg-red-500/30 text-red-400 rounded transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
        title="Kills the entire Claude Code process to stop all agents"
      >
        Kill All
      </button>
      <button
        onclick={handleClearCompleted}
        disabled={completedAgents.length === 0 && erroredAgents.length === 0}
        class="flex-1 px-2 py-1 text-xs bg-[var(--bg-secondary)] hover:bg-[var(--bg-hover,var(--bg-secondary))] text-[var(--text-secondary)] rounded transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
      >
        Clear Finished
      </button>
    </div>
    <!-- Agent list -->
    <div class="flex-1 overflow-y-auto p-4 space-y-2">
      {#if agents.length === 0}
        <div
          class="flex flex-col items-center justify-center h-full text-[var(--text-secondary)] text-sm"
        >
          <svg
            class="w-8 h-8 mb-2 opacity-50"
            fill="none"
            stroke="currentColor"
            viewBox="0 0 24 24"
          >
            <path
              stroke-linecap="round"
              stroke-linejoin="round"
              stroke-width="2"
              d="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"
            />
          </svg>
          <p>No agents detected yet</p>
          <p class="text-xs mt-1 opacity-70">
            Agents will appear here when Claude uses the Task tool
          </p>
        </div>
      {:else}
        {#each flattenedAgents as { agent, depth } (agent.toolUseId)}
          <div
            class="p-3 rounded-lg border border-[var(--border-color)] bg-[var(--bg-secondary)] {agent.status ===
            'running'
              ? 'border-l-2 border-l-blue-500'
              : agent.status === 'errored'
                ? 'border-l-2 border-l-red-500'
                : 'border-l-2 border-l-green-500'}"
            style="margin-left: {depth * 12}px; width: calc(100% - {depth * 12}px);"
          >
            <!-- Agent header -->
            <div class="flex items-center justify-between mb-1">
              <div class="flex items-center gap-1.5">
                {#if depth > 0}
                  <svg
                    class="w-3 h-3 text-[var(--text-secondary)]"
                    fill="none"
                    stroke="currentColor"
                    viewBox="0 0 24 24"
                  >
                    <path
                      stroke-linecap="round"
                      stroke-linejoin="round"
                      stroke-width="2"
                      d="M9 5l7 7-7 7"
                    />
                  </svg>
                {/if}
                <span
                  class="px-1.5 py-0.5 text-[10px] rounded border {getStatusBadgeClass(
                    agent.status
                  )}"
                >
                  {getSubagentTypeLabel(agent.subagentType)}
                </span>
              </div>
              <span
                class="text-[10px] {agent.status === 'running'
                  ? 'text-blue-400'
                  : 'text-[var(--text-secondary)]'}"
              >
                {#if agent.durationMs !== undefined}
                  {Math.floor(agent.durationMs / 1000)}s
                {:else}
                  {formatDuration(agent.startedAt, agent.endedAt)}
                {/if}
                {#if agent.status === "running"}
                  <span class="inline-block w-1 h-1 bg-blue-400 rounded-full animate-pulse ml-1"
                  ></span>
                {/if}
              </span>
            </div>
            <!-- Agent description -->
            <p class="text-xs text-[var(--text-primary)] truncate" title={agent.description}>
              {agent.description}
            </p>
            <!-- Status indicator -->
            <div class="mt-1 flex items-center gap-1">
              {#if agent.status === "running"}
                <span class="text-[10px] text-blue-400">Running...</span>
              {:else if agent.status === "completed"}
                <span class="text-[10px] text-green-400">Completed</span>
              {:else}
                <span class="text-[10px] text-red-400">Errored / Killed</span>
              {/if}
            </div>
          </div>
        {/each}
      {/if}
    </div>
    <!-- Footer summary -->
    {#if agents.length > 0}
      <div
        class="px-4 py-2 border-t border-[var(--border-color)] text-[10px] text-[var(--text-secondary)]"
      >
        {agents.length} total &middot;
        {runningAgents.length} running &middot;
        {completedAgents.length} completed &middot;
        {erroredAgents.length} errored
      </div>
    {/if}
  </div>
 {/if}
@@ -0,0 +1,116 @@
 <script lang="ts">
  interface Props {
    isOpen: boolean;
    hasActiveConversation: boolean;
    onClose: () => void;
    onMinimize: () => void;
    onCancel: () => void;
  }
  const { isOpen, hasActiveConversation, onClose, onMinimize, onCancel }: Props = $props();
  function handleKeydown(event: KeyboardEvent) {
    if (!isOpen) return;
    if (event.key === "Escape") {
      event.preventDefault();
      onCancel();
    }
  }
 </script>
 <svelte:window onkeydown={handleKeydown} />
 {#if isOpen}
  <div
    class="fixed inset-0 bg-black/50 backdrop-blur-sm z-50 flex items-center justify-center p-4"
    onclick={onCancel}
    role="button"
    tabindex="0"
    onkeydown={(e) => e.key === " " && onCancel()}
  >
    <div
      class="bg-[var(--bg-primary)] border border-[var(--border-color)] rounded-lg shadow-xl max-w-md w-full"
      onclick={(e) => e.stopPropagation()}
      onkeydown={(e) => e.stopPropagation()}
      role="dialog"
      aria-labelledby="confirm-title"
      aria-describedby="confirm-message"
      tabindex="-1"
    >
      <div class="p-6">
        <div class="flex items-start gap-4">
          <div
            class="w-10 h-10 rounded-lg bg-yellow-500/20 flex items-center justify-center flex-shrink-0"
          >
            <svg
              class="w-6 h-6 text-yellow-500"
              fill="none"
              stroke="currentColor"
              viewBox="0 0 24 24"
            >
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"
              />
            </svg>
          </div>
          <div class="flex-1">
            <h3 id="confirm-title" class="text-lg font-semibold text-[var(--text-primary)] mb-1">
              Close Hikari Desktop?
            </h3>
            <p id="confirm-message" class="text-sm text-[var(--text-secondary)]">
              {#if hasActiveConversation}
                You have an active conversation with Claude. Are you sure you want to close the
                application? Your conversation history will be saved, but any in-progress tasks will
                be interrupted.
              {:else}
                Are you sure you want to close the application?
              {/if}
            </p>
          </div>
        </div>
        <div class="flex gap-3 mt-6 justify-end">
          <button
            onclick={onCancel}
            class="px-4 py-2 text-sm font-medium text-gray-300 bg-[var(--bg-secondary)] hover:bg-[var(--bg-tertiary)] border border-[var(--border-color)] rounded-lg transition-colors"
          >
            Cancel
          </button>
          <button
            onclick={onMinimize}
            class="px-4 py-2 text-sm font-medium text-white bg-blue-600 hover:bg-blue-700 rounded-lg transition-colors"
          >
            Minimize to Tray
          </button>
          <button
            onclick={onClose}
            class="px-4 py-2 text-sm font-medium text-white bg-red-600 hover:bg-red-700 rounded-lg transition-colors"
          >
            Close Application
          </button>
        </div>
      </div>
    </div>
  </div>
 {/if}
 <style>
  [role="dialog"] {
    animation: slideIn 0.2s ease-out;
  }
  @keyframes slideIn {
    from {
      opacity: 0;
      transform: scale(0.95) translateY(10px);
    }
    to {
      opacity: 1;
      transform: scale(1) translateY(0);
    }
  }
 </style>
@@ -5,6 +5,7 @@
  import { characterState, characterInfo } from "$lib/stores/character";
  import { isStreamerMode } from "$lib/stores/config";
  import { handleNewUserMessage } from "$lib/notifications/rules";
  import { setSkipNextGreeting } from "$lib/tauri";
  import type { CharacterState, CharacterStateInfo } from "$lib/types/states";
  interface Props {
@@ -127,6 +128,9 @@
      const conversationId = get(claudeStore.activeConversationId);
      if (!conversationId) return;
      // Set flag to preserve stats/permissions (don't treat next connect as new session)
      setSkipNextGreeting(true);
      await invoke("interrupt_claude", { conversationId });
      claudeStore.addLine("system", "Interrupted");
      characterState.setState("idle");
@@ -26,7 +26,6 @@
    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,
@@ -51,6 +50,7 @@
    session_cost_budget: null,
    budget_action: "warn",
    budget_warning_threshold: 0.8,
    discord_rpc_enabled: true,
  });
  let showCustomThemeEditor = $state(false);
@@ -80,16 +80,20 @@
  const availableModels = [
    { value: "", label: "Default (from ~/.claude)" },
-    // Current generation (Claude 4.5)
+    // Current generation (Claude 4.6)
    { value: "claude-opus-4-6", label: "Claude Opus 4.6 (Most Capable)" },
    // Previous generation (Claude 4.5)
    { value: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5 (Recommended)" },
    { value: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5 (Fast & Cheap)" },
-    { value: "claude-opus-4-5-20251101", label: "Claude Opus 4.5 (Most Capable)" },
+    { value: "claude-opus-4-5-20251101", label: "Claude Opus 4.5" },
-    // Previous generation (Claude 4)
+    // Previous generation (Claude 4.x)
    { value: "claude-opus-4-1-20250805", label: "Claude Opus 4.1" },
    { value: "claude-sonnet-4-20250514", label: "Claude Sonnet 4" },
    { value: "claude-opus-4-20250514", label: "Claude Opus 4" },
    // Legacy (Claude 3.x)
    { value: "claude-3-7-sonnet-20250219", label: "Claude 3.7 Sonnet" },
    { value: "claude-3-5-sonnet-20241022", label: "Claude 3.5 Sonnet (Oct 2024)" },
    { value: "claude-3-5-sonnet-20240620", label: "Claude 3.5 Sonnet (Jun 2024)" },
    { value: "claude-3-haiku-20240307", label: "Claude 3 Haiku (Cheapest)" },
  ];
@@ -723,21 +727,6 @@
        </p>
      </div>
      <!-- Minimize to Tray Toggle -->
      <div class="mb-4">
        <label class="flex items-center gap-3 cursor-pointer">
          <input
            type="checkbox"
            bind:checked={config.minimize_to_tray}
            class="w-4 h-4 text-[var(--accent-primary)] bg-[var(--bg-primary)] border-[var(--border-color)] rounded focus:ring-[var(--accent-primary)] focus:ring-2"
          />
          <span class="text-sm text-[var(--text-primary)]">Minimize to system tray</span>
        </label>
        <p class="text-xs text-[var(--text-tertiary)] mt-1 ml-7">
          Hide to tray instead of closing when you click the X button
        </p>
      </div>
      <!-- Update Checks Toggle -->
      <div class="mb-4">
        <label class="flex items-center gap-3 cursor-pointer">
@@ -967,6 +956,30 @@
      </div>
    </section>
    <!-- Discord Rich Presence Section -->
    <section class="pt-6 pb-6 border-t border-[var(--border-color)]">
      <h3 class="text-lg font-semibold text-[var(--accent-primary)] mb-4 flex items-center gap-2">
        <span>🎮</span>
        <span>Discord Rich Presence</span>
      </h3>
      <!-- Enable/Disable Discord RPC -->
      <div class="mb-4">
        <label class="flex items-center gap-3 cursor-pointer">
          <input
            type="checkbox"
            bind:checked={config.discord_rpc_enabled}
            class="w-4 h-4 text-[var(--accent-primary)] bg-[var(--bg-primary)] border-[var(--border-color)] rounded focus:ring-[var(--accent-primary)] focus:ring-2"
          />
          <span class="text-sm text-[var(--text-primary)]">Show activity in Discord</span>
        </label>
      </div>
      <div class="text-xs text-[var(--text-tertiary)]">
        Display your current conversation session name and model in Discord when enabled.
      </div>
    </section>
    <!-- Save Button -->
    <div class="sticky bottom-0 pt-4 pb-2 bg-[var(--bg-secondary)]">
      <button
@@ -0,0 +1,330 @@
 <script lang="ts">
  import { onMount } from "svelte";
  import { debugConsoleStore, filteredLogs, type LogLevel } from "$lib/stores/debugConsole";
  let isOpen = $state(false);
  let logs = $state($filteredLogs);
  let filterLevel = $state<LogLevel | "all">("all");
  let autoScroll = $state(true);
  let logContainerElement: HTMLDivElement | undefined = $state();
  // Watch for log changes and auto-scroll
  $effect(() => {
    logs = $filteredLogs;
    // Auto-scroll to bottom when logs change
    if (autoScroll && logContainerElement) {
      setTimeout(() => {
        if (logContainerElement) {
          logContainerElement.scrollTop = logContainerElement.scrollHeight;
        }
      }, 0);
    }
  });
  onMount(() => {
    // Set up console capture and backend listener
    debugConsoleStore.setupConsoleCapture();
    debugConsoleStore.setupBackendLogsListener();
    // Subscribe to store
    const unsubscribe = debugConsoleStore.subscribe((state) => {
      isOpen = state.isOpen;
      filterLevel = state.filterLevel;
      autoScroll = state.autoScroll;
    });
    return () => {
      unsubscribe();
      debugConsoleStore.restoreConsole();
    };
  });
  function handleClose() {
    debugConsoleStore.close();
  }
  function handleClear() {
    debugConsoleStore.clear();
  }
  function handleFilterChange(level: LogLevel | "all") {
    debugConsoleStore.setFilterLevel(level);
  }
  function handleAutoScrollToggle() {
    debugConsoleStore.setAutoScroll(!autoScroll);
  }
  function formatTimestamp(date: Date): string {
    return date.toLocaleTimeString("en-US", {
      hour: "2-digit",
      minute: "2-digit",
      second: "2-digit",
      fractionalSecondDigits: 3,
    });
  }
  function getLevelColor(level: LogLevel): string {
    switch (level) {
      case "debug":
        return "#9CA3AF"; // gray
      case "info":
        return "#3B82F6"; // blue
      case "warn":
        return "#F59E0B"; // amber
      case "error":
        return "#EF4444"; // red
    }
  }
  function getSourceBadgeColor(source: "frontend" | "backend"): string {
    return source === "frontend" ? "#8B5CF6" : "#10B981"; // purple for frontend, green for backend
  }
 </script>
 {#if isOpen}
  <div class="debug-console-overlay">
    <div class="debug-console">
      <div class="debug-console-header">
        <h2>Debug Console</h2>
        <div class="debug-console-controls">
          <div class="filter-buttons">
            <button
              class="filter-btn"
              class:active={filterLevel === "all"}
              onclick={() => handleFilterChange("all")}
            >
              All
            </button>
            <button
              class="filter-btn"
              class:active={filterLevel === "debug"}
              onclick={() => handleFilterChange("debug")}
              style="color: {getLevelColor('debug')}"
            >
              Debug
            </button>
            <button
              class="filter-btn"
              class:active={filterLevel === "info"}
              onclick={() => handleFilterChange("info")}
              style="color: {getLevelColor('info')}"
            >
              Info
            </button>
            <button
              class="filter-btn"
              class:active={filterLevel === "warn"}
              onclick={() => handleFilterChange("warn")}
              style="color: {getLevelColor('warn')}"
            >
              Warn
            </button>
            <button
              class="filter-btn"
              class:active={filterLevel === "error"}
              onclick={() => handleFilterChange("error")}
              style="color: {getLevelColor('error')}"
            >
              Error
            </button>
          </div>
          <button
            class="auto-scroll-btn"
            class:active={autoScroll}
            onclick={handleAutoScrollToggle}
          >
            {autoScroll ? "🔒" : "🔓"} Auto-scroll
          </button>
          <button class="clear-btn" onclick={handleClear}> 🗑️ Clear </button>
          <button class="close-btn" onclick={handleClose}> ✕ </button>
        </div>
      </div>
      <div class="debug-console-content" bind:this={logContainerElement}>
        {#if logs.length === 0}
          <div class="empty-state">No logs yet...</div>
        {:else}
          {#each logs as log (log.id)}
            <div class="log-entry" data-level={log.level}>
              <span class="log-timestamp">{formatTimestamp(log.timestamp)}</span>
              <span class="log-level" style="color: {getLevelColor(log.level)}">
                [{log.level.toUpperCase()}]
              </span>
              <span class="log-source" style="background-color: {getSourceBadgeColor(log.source)}">
                {log.source}
              </span>
              <span class="log-message">{log.message}</span>
            </div>
          {/each}
        {/if}
      </div>
    </div>
  </div>
 {/if}
 <style>
  .debug-console-overlay {
    position: fixed;
    inset: 0;
    z-index: 9999;
    display: flex;
    align-items: center;
    justify-content: center;
    background-color: rgba(0, 0, 0, 0.5);
    backdrop-filter: blur(4px);
  }
  .debug-console {
    width: 90%;
    height: 80%;
    max-width: 1400px;
    background-color: #1a1a1a;
    border-radius: 8px;
    border: 1px solid #333;
    display: flex;
    flex-direction: column;
    overflow: hidden;
    box-shadow: 0 10px 40px rgba(0, 0, 0, 0.5);
  }
  .debug-console-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 12px 16px;
    background-color: #252525;
    border-bottom: 1px solid #333;
  }
  .debug-console-header h2 {
    margin: 0;
    font-size: 16px;
    font-weight: 600;
    color: #fff;
  }
  .debug-console-controls {
    display: flex;
    gap: 8px;
    align-items: center;
  }
  .filter-buttons {
    display: flex;
    gap: 4px;
  }
  .filter-btn {
    padding: 4px 12px;
    background-color: transparent;
    border: 1px solid #444;
    border-radius: 4px;
    color: #999;
    font-size: 12px;
    cursor: pointer;
    transition: all 0.2s;
  }
  .filter-btn:hover {
    background-color: #333;
  }
  .filter-btn.active {
    background-color: #444;
    border-color: currentColor;
  }
  .auto-scroll-btn,
  .clear-btn {
    padding: 4px 12px;
    background-color: #333;
    border: 1px solid #444;
    border-radius: 4px;
    color: #fff;
    font-size: 12px;
    cursor: pointer;
    transition: all 0.2s;
  }
  .auto-scroll-btn:hover,
  .clear-btn:hover {
    background-color: #444;
  }
  .auto-scroll-btn.active {
    background-color: #10b981;
    border-color: #10b981;
  }
  .close-btn {
    padding: 4px 12px;
    background-color: #ef4444;
    border: none;
    border-radius: 4px;
    color: #fff;
    font-size: 14px;
    font-weight: 600;
    cursor: pointer;
    transition: all 0.2s;
  }
  .close-btn:hover {
    background-color: #dc2626;
  }
  .debug-console-content {
    flex: 1;
    overflow-y: auto;
    padding: 16px;
    background-color: #0f0f0f;
    font-family: "Fira Code", "Consolas", monospace;
    font-size: 13px;
    line-height: 1.5;
  }
  .empty-state {
    display: flex;
    align-items: center;
    justify-content: center;
    height: 100%;
    color: #666;
    font-style: italic;
  }
  .log-entry {
    display: flex;
    gap: 8px;
    padding: 4px 0;
    border-bottom: 1px solid #1a1a1a;
  }
  .log-entry:hover {
    background-color: #1a1a1a;
  }
  .log-timestamp {
    color: #666;
    flex-shrink: 0;
  }
  .log-level {
    font-weight: 600;
    flex-shrink: 0;
    min-width: 60px;
  }
  .log-source {
    padding: 2px 6px;
    border-radius: 4px;
    font-size: 11px;
    font-weight: 600;
    color: #fff;
    flex-shrink: 0;
  }
  .log-message {
    color: #e5e5e5;
    word-break: break-word;
  }
 </style>
@@ -6,7 +6,7 @@
  import { claudeStore, isClaudeProcessing } from "$lib/stores/claude";
  import { characterState } from "$lib/stores/character";
  import { handleNewUserMessage } from "$lib/notifications/rules";
-  import { setSkipNextGreeting } from "$lib/tauri";
+  import { setSkipNextGreeting, updateDiscordRpc } from "$lib/tauri";
  import { clipboardStore } from "$lib/stores/clipboard";
  import {
    setShouldRestoreHistory,
@@ -26,6 +26,7 @@
    type SlashCommand,
  } from "$lib/commands/slashCommands";
  import { configStore, isStreamerMode } from "$lib/stores/config";
  import { conversationsStore } from "$lib/stores/conversations";
  import { stats, estimateMessageCost, formatTokenCount } from "$lib/stores/stats";
  import AttachmentPreview from "$lib/components/AttachmentPreview.svelte";
  import SnippetLibraryPanel from "$lib/components/SnippetLibraryPanel.svelte";
@@ -337,19 +338,39 @@ User: ${formattedMessage}`;
            throw new Error("No active conversation");
          }
-          // Get current working directory before reconnecting
+          // Get current working directory and granted tools before reconnecting
          const workingDir = await invoke<string>("get_working_directory", { conversationId });
          const activeConversation = get(conversationsStore.activeConversation);
          const grantedTools = activeConversation
            ? Array.from(activeConversation.grantedTools)
            : [];
          const config = configStore.getConfig();
          const allAllowedTools = [...new Set([...grantedTools, ...config.auto_granted_tools])];
          // Set the flag to skip greeting on next connection
          setSkipNextGreeting(true);
-          // Reconnect to Claude
+          // Reconnect to Claude with preserved permissions
          await invoke("start_claude", {
            conversationId,
            options: {
              working_dir: workingDir,
              model: config.model || null,
              api_key: config.api_key || null,
              custom_instructions: config.custom_instructions || null,
              mcp_servers_json: config.mcp_servers_json || null,
              allowed_tools: allAllowedTools,
            },
          });
          // Update Discord RPC when reconnecting
          if (activeConversation) {
            await updateDiscordRpc(
              activeConversation.name,
              config.model || "claude",
              activeConversation.startedAt
            );
          }
        } catch (reconnectError) {
          console.error("Failed to auto-reconnect:", reconnectError);
          claudeStore.addLine("error", `Failed to reconnect: ${reconnectError}`);
@@ -435,11 +456,12 @@ User: ${formattedMessage}`;
        try {
          const arrayBuffer = await file.arrayBuffer();
          const bytes = Array.from(new Uint8Array(arrayBuffer));
-          savedPath = await invoke<string>("save_temp_file", {
+          const result = await invoke<{ path: string; filename: string }>("save_temp_file", {
            conversationId,
            filename,
            data: bytes,
          });
          savedPath = result.path;
        } catch (error) {
          console.error("Failed to save dropped file to temp:", error);
          savedPath = file.name;
@@ -573,11 +595,12 @@ User: ${formattedMessage}`;
            try {
              const arrayBuffer = await file.arrayBuffer();
              const bytes = Array.from(new Uint8Array(arrayBuffer));
-              savedPath = await invoke<string>("save_temp_file", {
+              const result = await invoke<{ path: string; filename: string }>("save_temp_file", {
                conversationId,
                filename,
                data: bytes,
              });
              savedPath = result.path;
            } catch (error) {
              console.error("Failed to save pasted file to temp:", error);
            }
@@ -635,11 +658,12 @@ User: ${formattedMessage}`;
              try {
                const arrayBuffer = await blob.arrayBuffer();
                const bytes = Array.from(new Uint8Array(arrayBuffer));
-                savedPath = await invoke<string>("save_temp_file", {
+                const result = await invoke<{ path: string; filename: string }>("save_temp_file", {
                  conversationId,
                  filename,
                  data: bytes,
                });
                savedPath = result.path;
              } catch (error) {
                console.error("Failed to save clipboard image to temp:", error);
              }
@@ -1,22 +1,24 @@
 <script lang="ts">
  import { invoke } from "@tauri-apps/api/core";
  import { get } from "svelte/store";
-  import { claudeStore, hasPermissionPending } from "$lib/stores/claude";
+  import { SvelteSet } from "svelte/reactivity";
  import { claudeStore } from "$lib/stores/claude";
  import { characterState } from "$lib/stores/character";
  import type { PermissionRequest } from "$lib/types/messages";
  import { updateDiscordRpc, setSkipNextGreeting } from "$lib/tauri";
  import { conversationsStore } from "$lib/stores/conversations";
  import { configStore } from "$lib/stores/config";
-  let isVisible = $state(false);
+  let permissions: PermissionRequest[] = $state([]);
-  let permission: PermissionRequest | null = $state(null);
+  let selectedPermissions = new SvelteSet<string>();
  let grantedToolsList: string[] = $state([]);
  let workingDirectory = $state("");
-  hasPermissionPending.subscribe((pending) => {
+  conversationsStore.pendingPermissions.subscribe((perms) => {
-    isVisible = pending;
+    permissions = perms;
-  });
+    // When new permissions arrive, select all by default
-
+    if (perms.length > 0) {
-  claudeStore.pendingPermission.subscribe((perm) => {
+      selectedPermissions = new SvelteSet(perms.map((p) => p.id));
    permission = perm;
    if (perm) {
      characterState.setState("permission");
    }
  });
@@ -30,17 +32,33 @@
  });
  async function handleApproveAndReconnect() {
-    if (permission) {
+    const selectedPerms = permissions.filter((p) => selectedPermissions.has(p.id));
    if (selectedPerms.length === 0) {
      claudeStore.addLine("system", "No permissions selected to approve");
      claudeStore.clearPermission();
      characterState.setTemporaryState("idle", 1000);
      return;
    }
    // Capture conversation history before clearing/reconnecting
    const conversationHistory = claudeStore.getConversationHistory();
      const approvedTool = permission.tool;
      const toolInput = permission.input;
-      claudeStore.grantTool(approvedTool);
+    // Grant all selected tools
-      const newGrantedTools = [...grantedToolsList, approvedTool];
+    const newlyGrantedTools: string[] = [];
    for (const perm of selectedPerms) {
      if (!grantedToolsList.includes(perm.tool)) {
        claudeStore.grantTool(perm.tool);
        newlyGrantedTools.push(perm.tool);
      }
    }
    const newGrantedTools = [...grantedToolsList, ...newlyGrantedTools];
    const toolNames = selectedPerms.map((p) => p.tool).join(", ");
    claudeStore.addLine(
      "system",
-        `Permission granted for: ${approvedTool}. Reconnecting with context...`
+      `Permission granted for ${selectedPerms.length} tool(s): ${toolNames}. Reconnecting with context...`
    );
    claudeStore.clearPermission();
@@ -51,46 +69,67 @@
        throw new Error("No active conversation");
      }
      // Prevent stats reset on reconnection
      setSkipNextGreeting(true);
      await invoke("stop_claude", { conversationId });
      // Small delay to ensure clean shutdown
      await new Promise((resolve) => setTimeout(resolve, 500));
      const config = configStore.getConfig();
      await invoke("start_claude", {
        conversationId,
        options: {
          working_dir: workingDirectory || "/home/naomi",
          model: config.model || null,
          api_key: config.api_key || null,
          custom_instructions: config.custom_instructions || null,
          mcp_servers_json: config.mcp_servers_json || null,
          allowed_tools: newGrantedTools,
        },
      });
      // Update Discord RPC when reconnecting after permission grant
      const activeConversation = get(conversationsStore.activeConversation);
      if (activeConversation) {
        await updateDiscordRpc(
          activeConversation.name,
          config.model || "claude",
          activeConversation.startedAt
        );
      }
      // Wait for connection to establish
      await new Promise((resolve) => setTimeout(resolve, 1000));
      // Send conversation context to restore state
      if (conversationHistory) {
        const blockedActions = selectedPerms
          .map((p) => `- ${p.tool} with input:\n${JSON.stringify(p.input, null, 2)}`)
          .join("\n\n");
        const contextMessage = `[CONTEXT RESTORATION]
-I just granted you permission to use the ${approvedTool} tool. Here's our conversation so far:
+I just granted you permission to use ${selectedPerms.length} tool(s): ${toolNames}. Here's our conversation so far:
 ${conversationHistory}
-The last action that was blocked was: ${approvedTool} with input:
+The actions that were blocked:
-${JSON.stringify(toolInput, null, 2)}
+${blockedActions}
-Please continue where we left off and retry that action now that you have permission.`;
+Please continue where we left off and retry those actions now that you have permission.`;
        await invoke("send_prompt", {
          conversationId,
          message: contextMessage,
        });
      }
      characterState.setTemporaryState("success", 2000);
    } catch (error) {
      console.error("Failed to reconnect:", error);
      claudeStore.addLine("error", `Reconnect failed: ${error}`);
    }
  }
    characterState.setTemporaryState("success", 2000);
  }
  function handleDismiss() {
    claudeStore.clearPermission();
@@ -110,8 +149,24 @@ Please continue where we left off and retry that action now that you have permis
    return grantedToolsList.includes(toolName);
  }
  function togglePermission(toolRequestId: string) {
    if (selectedPermissions.has(toolRequestId)) {
      selectedPermissions.delete(toolRequestId);
    } else {
      selectedPermissions.add(toolRequestId);
    }
  }
  function selectAll() {
    selectedPermissions = new SvelteSet(permissions.map((p) => p.id));
  }
  function selectNone() {
    selectedPermissions = new SvelteSet();
  }
  function handleKeydown(event: KeyboardEvent) {
-    if (!isVisible || !permission) return;
+    if (permissions.length === 0) return;
    if (event.key === "Enter") {
      event.preventDefault();
@@ -125,72 +180,126 @@ Please continue where we left off and retry that action now that you have permis
 <svelte:window onkeydown={handleKeydown} />
-{#if isVisible && permission}
+{#if permissions.length > 0}
  <div
-    class="permission-overlay fixed inset-0 bg-black/70 flex items-center justify-center z-50 backdrop-blur-sm"
+    class="permission-overlay fixed inset-0 bg-black/70 flex items-center justify-center z-[60] backdrop-blur-sm"
  >
    <div
-      class="permission-modal bg-[var(--bg-primary)] border border-[var(--border-color)] rounded-xl p-6 max-w-md w-full mx-4 shadow-2xl"
+      class="permission-modal bg-[var(--bg-primary)] border border-[var(--border-color)] rounded-xl p-6 max-w-2xl w-full mx-4 shadow-2xl max-h-[90vh] overflow-y-auto"
    >
      <div class="flex items-center gap-3 mb-4">
        <div class="w-10 h-10 rounded-full bg-yellow-500/20 flex items-center justify-center">
          <span class="text-xl">🔐</span>
        </div>
-        <div>
+        <div class="flex-1">
-          <h2 class="text-lg font-semibold text-[var(--text-primary)]">Permission Blocked</h2>
+          <h2 class="text-lg font-semibold text-[var(--text-primary)]">
-          <p class="text-sm text-[var(--text-secondary)]">Hikari tried to use a restricted tool</p>
+            {permissions.length === 1
              ? "Permission Required"
              : `${permissions.length} Permissions Required`}
          </h2>
          <p class="text-sm text-[var(--text-secondary)]">
            Hikari tried to use {permissions.length === 1
              ? "a restricted tool"
              : "restricted tools"}
          </p>
        </div>
        <div class="flex gap-2 text-xs">
          <button
            onclick={selectAll}
            class="px-2 py-1 bg-blue-500/20 hover:bg-blue-500/30 text-blue-400 rounded transition-colors"
          >
            Select All
          </button>
          <button
            onclick={selectNone}
            class="px-2 py-1 bg-gray-500/20 hover:bg-gray-500/30 text-[var(--text-secondary)] rounded transition-colors"
          >
            Select None
          </button>
        </div>
      </div>
      <div class="mb-4 px-3 py-2 bg-amber-500/10 border border-amber-500/30 rounded-md">
        <p class="text-sm text-amber-300">
-          This action was automatically blocked. Approve to allow this tool for future requests.
+          {permissions.length === 1
            ? "This action was automatically blocked. Select which permissions to grant."
            : "These actions were automatically blocked. Select which permissions to grant."}
        </p>
      </div>
-      <div class="mb-4">
+      <div class="space-y-3 mb-6">
-        <div class="text-sm text-[var(--text-secondary)] mb-1">Tool</div>
+        {#each permissions as perm (perm.id)}
          <div
-          class="px-3 py-2 bg-[var(--bg-secondary)] rounded-md text-[var(--accent-primary)] font-mono flex items-center justify-between"
+            class="border border-[var(--border-color)] rounded-lg p-4 cursor-pointer transition-colors {selectedPermissions.has(
-        >
+              perm.id
-          <span>{permission.tool}</span>
+            )
-          {#if isToolAlreadyGranted(permission.tool)}
+              ? 'bg-green-500/10 border-green-500/30'
-            <span class="text-xs text-green-400 bg-green-500/20 px-2 py-0.5 rounded"
+              : 'bg-[var(--bg-secondary)] hover:bg-[var(--bg-secondary)]/80'}"
-              >Already Granted</span
+            role="button"
            tabindex="0"
            onclick={() => togglePermission(perm.id)}
            onkeydown={(e) => {
              if (e.key === "Enter" || e.key === " ") {
                e.preventDefault();
                togglePermission(perm.id);
              }
            }}
          >
            <div class="flex items-start gap-3">
              <div class="mt-1">
                <input
                  type="checkbox"
                  checked={selectedPermissions.has(perm.id)}
                  onchange={() => togglePermission(perm.id)}
                  class="w-4 h-4 accent-green-500"
                />
              </div>
              <div class="flex-1 min-w-0">
                <div class="flex items-center gap-2 mb-2">
                  <span class="text-[var(--accent-primary)] font-mono text-sm font-medium">
                    {perm.tool}
                  </span>
                  {#if isToolAlreadyGranted(perm.tool)}
                    <span class="text-xs text-green-400 bg-green-500/20 px-2 py-0.5 rounded">
                      Already Granted
                    </span>
                  {/if}
                </div>
                <div class="text-sm text-[var(--text-secondary)] mb-2">
                  {perm.description}
                </div>
-
+                {#if Object.keys(perm.input).length > 0}
-      <div class="mb-4">
+                  <details class="text-xs">
-        <div class="text-sm text-[var(--text-secondary)] mb-1">Description</div>
+                    <summary
-        <div class="px-3 py-2 bg-[var(--bg-secondary)] rounded-md text-[var(--text-primary)]">
+                      class="cursor-pointer text-[var(--text-secondary)] hover:text-[var(--text-primary)]"
-          {permission.description}
+                    >
-        </div>
+                      View details
-      </div>
+                    </summary>
      {#if Object.keys(permission.input).length > 0}
        <div class="mb-6">
          <div class="text-sm text-[var(--text-secondary)] mb-1">Details</div>
                    <pre
-            class="px-3 py-2 bg-[var(--bg-terminal)] rounded-md text-[var(--text-primary)] text-xs overflow-x-auto max-h-32">{formatInput(
+                      class="mt-2 px-3 py-2 bg-[var(--bg-terminal)] rounded-md text-[var(--text-primary)] overflow-x-auto max-h-32">{formatInput(
-              permission.input
+                        perm.input
                      )}</pre>
-        </div>
+                  </details>
                {/if}
              </div>
            </div>
          </div>
        {/each}
      </div>
      <div class="flex gap-3">
        <button
          onclick={handleDismiss}
          class="flex-1 px-4 py-2 bg-gray-500/20 hover:bg-gray-500/30 text-[var(--text-secondary)] rounded-lg transition-colors font-medium"
        >
-          Dismiss
+          Dismiss All
        </button>
        <button
          onclick={handleApproveAndReconnect}
-          class="flex-1 px-4 py-2 bg-green-500/20 hover:bg-green-500/30 text-green-400 rounded-lg transition-colors font-medium"
+          disabled={selectedPermissions.size === 0}
          class="flex-1 px-4 py-2 bg-green-500/20 hover:bg-green-500/30 text-green-400 rounded-lg transition-colors font-medium disabled:opacity-50 disabled:cursor-not-allowed"
        >
-          Allow & Reconnect
+          Approve Selected ({selectedPermissions.size})
        </button>
      </div>
    </div>
@@ -21,15 +21,19 @@
  import HelpPanel from "./HelpPanel.svelte";
  import KeyboardShortcutsModal from "./KeyboardShortcutsModal.svelte";
  import { achievementProgress } from "$lib/stores/achievements";
  import { runningAgentCount } from "$lib/stores/agents";
  import SessionHistoryPanel from "./SessionHistoryPanel.svelte";
  import GitPanel from "./GitPanel.svelte";
  import ProfilePanel from "./ProfilePanel.svelte";
  import AgentMonitorPanel from "./AgentMonitorPanel.svelte";
  import { conversationsStore } from "$lib/stores/conversations";
  import {
    generateContextInjection,
    createSummary,
    sanitizeForJson,
  } from "$lib/utils/conversationUtils";
  import { updateDiscordRpc, setSkipNextGreeting } from "$lib/tauri";
  import { debugConsoleStore } from "$lib/stores/debugConsole";
  const DISCORD_URL = "https://chat.nhcarrigan.com";
  const DONATE_URL = "https://donate.nhcarrigan.com";
@@ -47,8 +51,10 @@
  let showSessionHistory = $state(false);
  let showGitPanel = $state(false);
  let showProfile = $state(false);
  let showAgentMonitor = $state(false);
  let isSummarising = $state(false);
  const progress = $derived($achievementProgress);
  const activeAgentCount = $derived($runningAgentCount);
  let currentConfig: HikariConfig = $state({
    model: null,
    api_key: null,
@@ -64,7 +70,6 @@
    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,
@@ -86,6 +91,7 @@
    session_cost_budget: null,
    budget_action: "warn",
    budget_warning_threshold: 0.8,
    discord_rpc_enabled: true,
  });
  let streamerModeActive = $state(false);
@@ -165,6 +171,16 @@
          allowed_tools: allAllowedTools,
        },
      });
      // Update Discord RPC when a new session starts
      const activeConversation = get(conversationsStore.activeConversation);
      if (activeConversation) {
        await updateDiscordRpc(
          activeConversation.name,
          currentConfig.model || "claude",
          activeConversation.startedAt
        );
      }
    } catch (error) {
      console.error("Failed to start Claude:", error);
      claudeStore.addLine("error", `Connection failed: ${error}`);
@@ -178,6 +194,9 @@
        throw new Error("No active conversation");
      }
      await invoke("stop_claude", { conversationId });
      // Clear granted permissions when user explicitly disconnects
      claudeStore.revokeAllTools();
    } catch (error) {
      console.error("Failed to stop Claude:", error);
    }
@@ -236,6 +255,9 @@
          : sanitizedContent;
      // Step 1: Disconnect from Claude to reset context
      // Prevent stats reset on reconnection
      setSkipNextGreeting(true);
      if (connectionStatus === "connected") {
        await invoke("stop_claude", { conversationId: activeId });
      }
@@ -448,6 +470,29 @@
        />
      </svg>
    </button>
    <button
      onclick={() => (showAgentMonitor = !showAgentMonitor)}
      class="p-1 text-gray-500 icon-trans-hover relative {showAgentMonitor
        ? 'text-[var(--trans-pink)]'
        : ''}"
      title="Agent Monitor"
    >
      <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="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"
        />
      </svg>
      {#if activeAgentCount > 0}
        <span
          class="absolute -top-1 -right-1 bg-blue-500 text-white text-xs rounded-full w-4 h-4 flex items-center justify-center text-[10px] animate-pulse"
        >
          {activeAgentCount}
        </span>
      {/if}
    </button>
    <button
      onclick={() => (showStats = !showStats)}
      class="p-1 text-gray-500 icon-trans-hover {showStats ? 'text-[var(--trans-pink)]' : ''}"
@@ -462,6 +507,20 @@
        />
      </svg>
    </button>
    <button
      onclick={() => debugConsoleStore.toggle()}
      class="p-1 text-gray-500 icon-trans-hover"
      title="Debug Console (Ctrl+`)"
    >
      <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="M8 9l3 3-3 3m5 0h3M5 20h14a2 2 0 002-2V6a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"
        />
      </svg>
    </button>
    <button
      onclick={configStore.openSidebar}
      class="p-1 text-gray-500 icon-trans-hover"
@@ -620,3 +679,7 @@
 {#if showProfile}
  <ProfilePanel onClose={() => (showProfile = false)} />
 {/if}
 {#if showAgentMonitor}
  <AgentMonitorPanel isOpen={showAgentMonitor} onClose={() => (showAgentMonitor = false)} />
 {/if}
@@ -209,8 +209,30 @@
      </div>
    {:else}
      {#each lines as line (line.id)}
-        <div class="terminal-line mb-2 {getLineClass(line.type)} relative group">
+        <div
          class="terminal-line mb-2 {getLineClass(line.type)} relative group"
          style={line.parentToolUseId
            ? "margin-left: 16px; padding-left: 8px; border-left: 2px solid var(--accent-primary);"
            : ""}
        >
          <span class="terminal-timestamp text-xs mr-2">{formatTime(line.timestamp)}</span>
          {#if line.parentToolUseId}
            <span class="text-xs mr-2 opacity-60" title="Message from subagent">
              <svg
                class="inline-block w-3 h-3 -mt-0.5"
                fill="none"
                stroke="currentColor"
                viewBox="0 0 24 24"
              >
                <path
                  stroke-linecap="round"
                  stroke-linejoin="round"
                  stroke-width="2"
                  d="M9 5l7 7-7 7"
                />
              </svg>
            </span>
          {/if}
          {#if line.cost && line.cost.costUsd > 0}
            <span
              class="terminal-cost text-xs mr-2"
@@ -5,6 +5,9 @@
  import { claudeStore, hasQuestionPending } from "$lib/stores/claude";
  import { characterState } from "$lib/stores/character";
  import type { UserQuestionEvent } from "$lib/types/messages";
  import { updateDiscordRpc, setSkipNextGreeting } from "$lib/tauri";
  import { conversationsStore } from "$lib/stores/conversations";
  import { configStore } from "$lib/stores/config";
  let isVisible = $state(false);
  let question: UserQuestionEvent | null = $state(null);
@@ -86,18 +89,36 @@
    claudeStore.clearQuestion();
    try {
      // Prevent stats reset on reconnection
      setSkipNextGreeting(true);
      await invoke("stop_claude", { conversationId });
      await new Promise((resolve) => setTimeout(resolve, 500));
      const config = configStore.getConfig();
      await invoke("start_claude", {
        conversationId,
        options: {
          working_dir: workingDirectory || "/home/naomi",
          model: config.model || null,
          api_key: config.api_key || null,
          custom_instructions: config.custom_instructions || null,
          mcp_servers_json: config.mcp_servers_json || null,
          allowed_tools: grantedToolsList,
        },
      });
      // Update Discord RPC when reconnecting after answering question
      const activeConversation = get(conversationsStore.activeConversation);
      if (activeConversation) {
        await updateDiscordRpc(
          activeConversation.name,
          config.model || "claude",
          activeConversation.startedAt
        );
      }
      await new Promise((resolve) => setTimeout(resolve, 1000));
      if (conversationHistory) {
@@ -0,0 +1,121 @@
 import { writable, derived } from "svelte/store";
 import type { AgentInfo } from "$lib/types/agents";
 // Map of conversation ID -> agents in that conversation
 const agentsByConversation = writable<Record<string, AgentInfo[]>>({});
 function createAgentStore() {
  return {
    subscribe: agentsByConversation.subscribe,
    addAgent(conversationId: string, agent: AgentInfo) {
      agentsByConversation.update((state) => {
        const existing = state[conversationId] || [];
        return {
          ...state,
          [conversationId]: [...existing, agent],
        };
      });
    },
    updateAgentId(conversationId: string, toolUseId: string, agentId: string) {
      agentsByConversation.update((state) => {
        const agents = state[conversationId];
        if (!agents) return state;
        const agentIndex = agents.findIndex((a) => a.toolUseId === toolUseId);
        if (agentIndex === -1) return state;
        const updated = [...agents];
        updated[agentIndex] = {
          ...updated[agentIndex],
          agentId,
        };
        return {
          ...state,
          [conversationId]: updated,
        };
      });
    },
    endAgent(conversationId: string, toolUseId: string, endedAt: number, isError: boolean) {
      agentsByConversation.update((state) => {
        const agents = state[conversationId];
        if (!agents) return state;
        const agentIndex = agents.findIndex((a) => a.toolUseId === toolUseId);
        if (agentIndex === -1) return state;
        const updated = [...agents];
        const agent = updated[agentIndex];
        const durationMs = endedAt - agent.startedAt;
        updated[agentIndex] = {
          ...agent,
          endedAt,
          status: isError ? "errored" : "completed",
          durationMs,
        };
        return {
          ...state,
          [conversationId]: updated,
        };
      });
    },
    markAllErrored(conversationId: string) {
      agentsByConversation.update((state) => {
        const agents = state[conversationId];
        if (!agents) return state;
        const now = Date.now();
        const updated = agents.map((agent) =>
          agent.status === "running"
            ? { ...agent, endedAt: now, status: "errored" as const }
            : agent
        );
        return {
          ...state,
          [conversationId]: updated,
        };
      });
    },
    clearCompleted(conversationId: string) {
      agentsByConversation.update((state) => {
        const agents = state[conversationId];
        if (!agents) return state;
        return {
          ...state,
          [conversationId]: agents.filter((a) => a.status === "running"),
        };
      });
    },
    clearConversation(conversationId: string) {
      agentsByConversation.update((state) => {
        // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Unused destructured value
        const { [conversationId]: _, ...rest } = state;
        return rest;
      });
    },
  };
 }
 export const agentStore = createAgentStore();
 export function getAgentsForConversation(conversationId: string) {
  return derived(agentsByConversation, ($state) => $state[conversationId] || []);
 }
 export const runningAgentCount = derived(agentsByConversation, ($state) => {
  let count = 0;
  for (const agents of Object.values($state)) {
    count += agents.filter((a) => a.status === "running").length;
  }
  return count;
 });
@@ -101,7 +101,10 @@ export const claudeStore = {
 export const hasPermissionPending = derived(
  claudeStore.activeConversation,
-  ($conversation) => $conversation?.pendingPermission !== null
+  ($conversation) =>
    $conversation?.pendingPermissions !== null &&
    $conversation?.pendingPermissions !== undefined &&
    $conversation.pendingPermissions.length > 0
 );
 export const hasQuestionPending = derived(
@@ -14,6 +14,7 @@ import {
  type Theme,
  type CustomThemeColors,
 } from "./config";
 import { invoke } from "@tauri-apps/api/core";
 // Mock Tauri APIs
 vi.mock("@tauri-apps/api/core", () => ({
@@ -167,7 +168,6 @@ describe("config store", () => {
        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,
@@ -192,6 +192,7 @@ describe("config store", () => {
        session_cost_budget: null,
        budget_action: "warn",
        budget_warning_threshold: 0.8,
        discord_rpc_enabled: true,
      };
      expect(config.model).toBe("claude-sonnet-4");
@@ -212,7 +213,6 @@ describe("config store", () => {
        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,
@@ -237,6 +237,7 @@ describe("config store", () => {
        session_cost_budget: null,
        budget_action: "warn",
        budget_warning_threshold: 0.8,
        discord_rpc_enabled: true,
      };
      expect(config.model).toBeNull();
@@ -487,4 +488,329 @@ describe("config store", () => {
      expect(typeof configStore.saveError.subscribe).toBe("function");
    });
  });
  describe("Race Condition Tests", () => {
    beforeEach(async () => {
      // Setup mock to return a default config for load_config
      const mockInvokeImpl = vi.mocked(invoke);
      mockInvokeImpl.mockResolvedValue({
        model: null,
        api_key: null,
        custom_instructions: null,
        mcp_servers_json: null,
        auto_granted_tools: [],
        theme: "dark",
        greeting_enabled: false,
        greeting_custom_prompt: null,
        notifications_enabled: false,
        notification_volume: 0.7,
        always_on_top: false,
        update_checks_enabled: false,
        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,
        },
        budget_enabled: false,
        session_token_budget: null,
        session_cost_budget: null,
        budget_action: "warn",
        budget_warning_threshold: 0.8,
        discord_rpc_enabled: false,
      });
      // Load initial config
      await configStore.loadConfig();
      vi.clearAllMocks();
    });
    it("handles rapid sequential config updates correctly", async () => {
      // This test validates the fix for the config race condition that caused data loss
      const mockInvokeImpl = vi.mocked(invoke);
      const invokeCalls: Array<{ command: string; config: HikariConfig }> = [];
      mockInvokeImpl.mockImplementation(async (command: string, args?: unknown) => {
        if (command === "save_config" && args && typeof args === "object" && "config" in args) {
          invokeCalls.push({ command, config: args.config as HikariConfig });
          // Simulate small delay in saving
          await new Promise((resolve) => setTimeout(resolve, 10));
        }
        return null;
      });
      // Perform rapid updates
      await Promise.all([
        configStore.updateConfig({ font_size: 16 }),
        configStore.updateConfig({ theme: "light" }),
        configStore.updateConfig({ compact_mode: true }),
      ]);
      // All three updates should have been saved
      expect(invokeCalls.length).toBe(3);
      // Get final config
      const finalConfig = configStore.getConfig();
      // Final config should have all updates
      // Note: The last update wins for each field, but all fields should be preserved
      expect(finalConfig.compact_mode).toBe(true);
    });
    it("preserves previous field values during concurrent updates", async () => {
      // Set initial values
      await configStore.updateConfig({
        font_size: 16,
        theme: "dark",
        compact_mode: false,
        streamer_mode: false,
      });
      vi.clearAllMocks();
      const mockInvokeImpl = vi.mocked(invoke);
      const invokeCalls: Array<{ command: string; config: HikariConfig }> = [];
      mockInvokeImpl.mockImplementation(async (command: string, args?: unknown) => {
        if (command === "save_config" && args && typeof args === "object" && "config" in args) {
          invokeCalls.push({ command, config: args.config as HikariConfig });
          await new Promise((resolve) => setTimeout(resolve, 5));
        }
        return null;
      });
      // Update different fields concurrently
      await Promise.all([
        configStore.updateConfig({ font_size: 18 }),
        configStore.updateConfig({ theme: "light" }),
        configStore.updateConfig({ compact_mode: true }),
      ]);
      // Check that each save included all previous config values
      invokeCalls.forEach((call) => {
        // Each save should have a complete config, not just the updated field
        expect(call.config).toHaveProperty("font_size");
        expect(call.config).toHaveProperty("theme");
        expect(call.config).toHaveProperty("compact_mode");
        expect(call.config).toHaveProperty("streamer_mode");
        expect(call.config).toHaveProperty("model");
        expect(call.config).toHaveProperty("api_key");
      });
    });
    it("handles update during save operation", async () => {
      const mockInvokeImpl = vi.mocked(invoke);
      let firstSaveStarted = false;
      let firstSaveCompleted = false;
      mockInvokeImpl.mockImplementation(async (command: string) => {
        if (command === "save_config") {
          if (!firstSaveStarted) {
            firstSaveStarted = true;
            // Simulate slow save
            await new Promise((resolve) => setTimeout(resolve, 50));
            firstSaveCompleted = true;
          } else {
            // Second save starts while first is in progress
            expect(firstSaveStarted).toBe(true);
            // First save might not be complete yet (race condition scenario)
          }
        }
        return null;
      });
      // Start first update
      const firstUpdate = configStore.updateConfig({ font_size: 16 });
      // Wait a bit then start second update whilst first is still saving
      await new Promise((resolve) => setTimeout(resolve, 10));
      const secondUpdate = configStore.updateConfig({ theme: "light" });
      // Wait for both to complete
      await Promise.all([firstUpdate, secondUpdate]);
      // Both should complete successfully without errors
      expect(firstSaveCompleted).toBe(true);
    });
    it("getConfig returns most recently set configuration", async () => {
      await configStore.updateConfig({ font_size: 14 });
      expect(configStore.getConfig().font_size).toBe(14);
      await configStore.updateConfig({ font_size: 16 });
      expect(configStore.getConfig().font_size).toBe(16);
      await configStore.updateConfig({ font_size: 18 });
      expect(configStore.getConfig().font_size).toBe(18);
    });
    it("updates do not lose data from previous operations", async () => {
      // Set multiple fields
      await configStore.updateConfig({
        font_size: 16,
        theme: "dark",
        compact_mode: true,
        streamer_mode: true,
        model: "claude-sonnet-4",
      });
      // Update just one field
      await configStore.updateConfig({ theme: "light" });
      // Other fields should be preserved
      const config = configStore.getConfig();
      expect(config.theme).toBe("light");
      expect(config.font_size).toBe(16);
      expect(config.compact_mode).toBe(true);
      expect(config.streamer_mode).toBe(true);
      expect(config.model).toBe("claude-sonnet-4");
    });
    it("auto granted tools are not lost during other updates", async () => {
      // Add some tools
      await configStore.addAutoGrantedTool("Read");
      await configStore.addAutoGrantedTool("Write");
      expect(configStore.getConfig().auto_granted_tools).toContain("Read");
      expect(configStore.getConfig().auto_granted_tools).toContain("Write");
      // Update another field
      await configStore.updateConfig({ theme: "light" });
      // Tools should still be there
      expect(configStore.getConfig().auto_granted_tools).toContain("Read");
      expect(configStore.getConfig().auto_granted_tools).toContain("Write");
    });
    it("custom theme colors persist across other config updates", async () => {
      const customColors: 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",
      };
      await configStore.setCustomThemeColors(customColors);
      // Update another field
      await configStore.updateConfig({ font_size: 18 });
      // Colors should still be there
      const config = configStore.getConfig();
      expect(config.custom_theme_colors.bg_primary).toBe("#1a1a2e");
      expect(config.custom_theme_colors.accent_primary).toBe("#e94560");
    });
    it("handles save errors gracefully without losing data", async () => {
      const mockInvokeImpl = vi.mocked(invoke);
      // Set initial config
      await configStore.updateConfig({ font_size: 14 });
      // Make next save fail
      mockInvokeImpl.mockRejectedValueOnce(new Error("Save failed"));
      // Try to update - should throw
      await expect(configStore.updateConfig({ theme: "light" })).rejects.toThrow();
      // Original config should still be accessible
      expect(configStore.getConfig().font_size).toBe(14);
    });
  });
  describe("Config Persistence Tests", () => {
    it("loadConfig retrieves saved configuration", async () => {
      const mockConfig: HikariConfig = {
        model: "claude-sonnet-4",
        api_key: "test-key",
        custom_instructions: "Be helpful",
        mcp_servers_json: "{}",
        auto_granted_tools: ["Read", "Write"],
        theme: "light",
        greeting_enabled: false,
        greeting_custom_prompt: null,
        notifications_enabled: false,
        notification_volume: 0.5,
        always_on_top: true,
        update_checks_enabled: false,
        character_panel_width: 400,
        font_size: 18,
        streamer_mode: true,
        streamer_hide_paths: true,
        compact_mode: true,
        profile_name: "Test User",
        profile_avatar_path: "/test/avatar.png",
        profile_bio: "Test bio",
        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,
        },
        budget_enabled: true,
        session_token_budget: 100000,
        session_cost_budget: 1.5,
        budget_action: "block",
        budget_warning_threshold: 0.9,
        discord_rpc_enabled: false,
      };
      const mockInvokeImpl = vi.mocked(invoke);
      mockInvokeImpl.mockResolvedValueOnce(mockConfig);
      await configStore.loadConfig();
      const loadedConfig = configStore.getConfig();
      expect(loadedConfig.model).toBe("claude-sonnet-4");
      expect(loadedConfig.theme).toBe("light");
      expect(loadedConfig.font_size).toBe(18);
      expect(loadedConfig.auto_granted_tools).toEqual(["Read", "Write"]);
    });
    it("saveConfig persists configuration to backend", async () => {
      const mockInvokeImpl = vi.mocked(invoke);
      const savedConfigs: HikariConfig[] = [];
      mockInvokeImpl.mockImplementation(async (command: string, args?: unknown) => {
        if (command === "save_config" && args && typeof args === "object" && "config" in args) {
          savedConfigs.push(args.config as HikariConfig);
        }
        return null;
      });
      const configToSave: Partial<HikariConfig> = {
        model: "claude-sonnet-4",
        theme: "dark",
        font_size: 16,
      };
      await configStore.updateConfig(configToSave);
      expect(savedConfigs.length).toBeGreaterThan(0);
      const lastSaved = savedConfigs[savedConfigs.length - 1];
      expect(lastSaved.model).toBe("claude-sonnet-4");
      expect(lastSaved.theme).toBe("dark");
      expect(lastSaved.font_size).toBe(16);
    });
  });
 });
@@ -27,7 +27,6 @@ export interface HikariConfig {
  notifications_enabled: boolean;
  notification_volume: number;
  always_on_top: boolean;
  minimize_to_tray: boolean;
  update_checks_enabled: boolean;
  character_panel_width: number | null;
  font_size: number;
@@ -44,6 +43,8 @@ export interface HikariConfig {
  session_cost_budget: number | null;
  budget_action: BudgetAction;
  budget_warning_threshold: number;
  // Discord RPC settings
  discord_rpc_enabled: boolean;
 }
 const defaultConfig: HikariConfig = {
@@ -58,7 +59,6 @@ const defaultConfig: HikariConfig = {
  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,
@@ -83,6 +83,7 @@ const defaultConfig: HikariConfig = {
  session_cost_budget: null,
  budget_action: "warn",
  budget_warning_threshold: 0.8,
  discord_rpc_enabled: true,
 };
 function createConfigStore() {
@@ -91,6 +92,14 @@ function createConfigStore() {
  const isSidebarOpen = writable<boolean>(false);
  const saveError = writable<string | null>(null);
  // Internal function to get current config synchronously
  function getCurrentConfig(): HikariConfig {
    let currentConfig: HikariConfig = defaultConfig;
    const unsubscribe = config.subscribe((c) => (currentConfig = c));
    unsubscribe();
    return currentConfig;
  }
  async function loadConfig() {
    isLoading.set(true);
    try {
@@ -118,8 +127,7 @@ function createConfigStore() {
  }
  async function updateConfig(updates: Partial<HikariConfig>) {
-    let currentConfig: HikariConfig = defaultConfig;
+    const currentConfig = getCurrentConfig();
    config.subscribe((c) => (currentConfig = c))();
    const newConfig = { ...currentConfig, ...updates };
    await saveConfig(newConfig);
  }
@@ -144,15 +152,13 @@ function createConfigStore() {
        updates.custom_theme_colors = customColors;
      }
      await updateConfig(updates);
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      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;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      if (currentConfig.theme === "custom") {
        applyCustomThemeColors(colors);
      }
@@ -165,16 +171,14 @@ function createConfigStore() {
    },
    increaseFontSize: async () => {
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      const newSize = Math.min(MAX_FONT_SIZE, currentConfig.font_size + 2);
      await updateConfig({ font_size: newSize });
      applyFontSize(newSize);
    },
    decreaseFontSize: async () => {
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      const newSize = Math.max(MIN_FONT_SIZE, currentConfig.font_size - 2);
      await updateConfig({ font_size: newSize });
      applyFontSize(newSize);
@@ -186,8 +190,7 @@ function createConfigStore() {
    },
    addAutoGrantedTool: async (tool: string) => {
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      if (!currentConfig.auto_granted_tools.includes(tool)) {
        const newTools = [...currentConfig.auto_granted_tools, tool];
        await updateConfig({ auto_granted_tools: newTools });
@@ -195,27 +198,22 @@ function createConfigStore() {
    },
    removeAutoGrantedTool: async (tool: string) => {
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      const newTools = currentConfig.auto_granted_tools.filter((t) => t !== tool);
      await updateConfig({ auto_granted_tools: newTools });
    },
    getConfig: (): HikariConfig => {
-      let currentConfig: HikariConfig = defaultConfig;
+      return getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      return currentConfig;
    },
    toggleStreamerMode: async () => {
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      await updateConfig({ streamer_mode: !currentConfig.streamer_mode });
    },
    toggleCompactMode: async () => {
-      let currentConfig: HikariConfig = defaultConfig;
+      const currentConfig = getCurrentConfig();
      config.subscribe((c) => (currentConfig = c))();
      await updateConfig({ compact_mode: !currentConfig.compact_mode });
    },
@@ -28,13 +28,14 @@ export interface Conversation {
  characterState: CharacterState;
  isProcessing: boolean;
  grantedTools: Set<string>;
-  pendingPermission: PermissionRequest | null;
+  pendingPermissions: PermissionRequest[];
  pendingQuestion: UserQuestionEvent | null;
  scrollPosition: number;
  createdAt: Date;
  lastActivityAt: Date;
  attachments: Attachment[];
  summary: ConversationSummary | null;
  startedAt: Date;
 }
 function createConversationsStore() {
@@ -65,13 +66,14 @@ function createConversationsStore() {
      characterState: "idle",
      isProcessing: false,
      grantedTools: new Set(),
-      pendingPermission: null,
+      pendingPermissions: [],
      pendingQuestion: null,
      scrollPosition: -1, // -1 means "scroll to bottom" (auto-scroll)
      createdAt: new Date(),
      lastActivityAt: new Date(),
      attachments: [],
      summary: null,
      startedAt: new Date(),
    };
  }
@@ -118,7 +120,11 @@ function createConversationsStore() {
  );
  const pendingPermission = derived(
    activeConversation,
-    ($conv) => $conv?.pendingPermission || null
+    ($conv) => $conv?.pendingPermissions[0] || null
  );
  const pendingPermissions = derived(
    activeConversation,
    ($conv) => $conv?.pendingPermissions || []
  );
  const pendingQuestion = derived(activeConversation, ($conv) => $conv?.pendingQuestion || null);
  const scrollPosition = derived(activeConversation, ($conv) => $conv?.scrollPosition ?? -1);
@@ -131,6 +137,7 @@ function createConversationsStore() {
    currentWorkingDirectory: { subscribe: currentWorkingDirectory.subscribe },
    terminalLines: { subscribe: terminalLines.subscribe },
    pendingPermission: { subscribe: pendingPermission.subscribe },
    pendingPermissions: { subscribe: pendingPermissions.subscribe },
    pendingQuestion: { subscribe: pendingQuestion.subscribe },
    isProcessing: { subscribe: isProcessing.subscribe },
    grantedTools: { subscribe: grantedTools.subscribe },
@@ -188,7 +195,7 @@ function createConversationsStore() {
      conversations.update((convs) => {
        const conv = convs.get(activeId);
        if (conv) {
-          conv.pendingPermission = request;
+          conv.pendingPermissions.push(request);
          conv.lastActivityAt = new Date();
        }
        return convs;
@@ -201,7 +208,7 @@ function createConversationsStore() {
      conversations.update((convs) => {
        const conv = convs.get(activeId);
        if (conv) {
-          conv.pendingPermission = null;
+          conv.pendingPermissions = [];
          conv.lastActivityAt = new Date();
        }
        return convs;
@@ -211,7 +218,7 @@ function createConversationsStore() {
      conversations.update((convs) => {
        const conv = convs.get(conversationId);
        if (conv) {
-          conv.pendingPermission = request;
+          conv.pendingPermissions.push(request);
          conv.lastActivityAt = new Date();
        }
        return convs;
@@ -221,7 +228,30 @@ function createConversationsStore() {
      conversations.update((convs) => {
        const conv = convs.get(conversationId);
        if (conv) {
-          conv.pendingPermission = null;
+          conv.pendingPermissions = [];
          conv.lastActivityAt = new Date();
        }
        return convs;
      });
    },
    removePermission: (id: string) => {
      const activeId = get(activeConversationId);
      if (!activeId) return;
      conversations.update((convs) => {
        const conv = convs.get(activeId);
        if (conv) {
          conv.pendingPermissions = conv.pendingPermissions.filter((p) => p.id !== id);
          conv.lastActivityAt = new Date();
        }
        return convs;
      });
    },
    removePermissionForConversation: (conversationId: string, id: string) => {
      conversations.update((convs) => {
        const conv = convs.get(conversationId);
        if (conv) {
          conv.pendingPermissions = conv.pendingPermissions.filter((p) => p.id !== id);
          conv.lastActivityAt = new Date();
        }
        return convs;
@@ -433,7 +463,8 @@ function createConversationsStore() {
      type: TerminalLine["type"],
      content: string,
      toolName?: string,
-      cost?: TerminalLine["cost"]
+      cost?: TerminalLine["cost"],
      parentToolUseId?: string
    ) => {
      ensureInitialized();
      const activeId = get(activeConversationId);
@@ -446,6 +477,7 @@ function createConversationsStore() {
        timestamp: new Date(),
        toolName,
        cost,
        parentToolUseId,
      };
      conversations.update((convs) => {
@@ -467,7 +499,8 @@ function createConversationsStore() {
      type: TerminalLine["type"],
      content: string,
      toolName?: string,
-      cost?: TerminalLine["cost"]
+      cost?: TerminalLine["cost"],
      parentToolUseId?: string
    ) => {
      ensureInitialized();
@@ -478,6 +511,7 @@ function createConversationsStore() {
        timestamp: new Date(),
        toolName,
        cost,
        parentToolUseId,
      };
      conversations.update((convs) => {
@@ -0,0 +1,154 @@
 import { writable, derived } from "svelte/store";
 import { listen } from "@tauri-apps/api/event";
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export interface LogEntry {
  id: string;
  timestamp: Date;
  level: LogLevel;
  message: string;
  source: "frontend" | "backend";
 }
 interface DebugConsoleState {
  logs: LogEntry[];
  isOpen: boolean;
  maxLogs: number;
  filterLevel: LogLevel | "all";
  autoScroll: boolean;
 }
 const MAX_LOGS = 1000; // Circular buffer size
 function createDebugConsoleStore() {
  const { subscribe, update } = writable<DebugConsoleState>({
    logs: [],
    isOpen: false,
    maxLogs: MAX_LOGS,
    filterLevel: "all",
    autoScroll: true,
  });
  let logCounter = 0;
  function addLog(level: LogLevel, message: string, source: "frontend" | "backend") {
    update((state) => {
      const newLog: LogEntry = {
        id: `log-${Date.now()}-${logCounter++}`,
        timestamp: new Date(),
        level,
        message,
        source,
      };
      const updatedLogs = [...state.logs, newLog];
      // Implement circular buffer - remove oldest if exceeding max
      if (updatedLogs.length > state.maxLogs) {
        updatedLogs.shift();
      }
      return { ...state, logs: updatedLogs };
    });
  }
  // Override console methods to capture frontend logs
  const originalConsole = {
    log: console.log,
    info: console.info,
    warn: console.warn,
    error: console.error,
    debug: console.debug,
  };
  function setupConsoleCapture() {
    console.log = (...args: unknown[]) => {
      originalConsole.log(...args);
      addLog("info", args.map((arg) => String(arg)).join(" "), "frontend");
    };
    console.info = (...args: unknown[]) => {
      originalConsole.info(...args);
      addLog("info", args.map((arg) => String(arg)).join(" "), "frontend");
    };
    console.warn = (...args: unknown[]) => {
      originalConsole.warn(...args);
      addLog("warn", args.map((arg) => String(arg)).join(" "), "frontend");
    };
    console.error = (...args: unknown[]) => {
      originalConsole.error(...args);
      addLog("error", args.map((arg) => String(arg)).join(" "), "frontend");
    };
    console.debug = (...args: unknown[]) => {
      originalConsole.debug(...args);
      addLog("debug", args.map((arg) => String(arg)).join(" "), "frontend");
    };
    // Capture unhandled errors
    window.addEventListener("error", (event) => {
      addLog(
        "error",
        `[Unhandled Error] ${event.message} at ${event.filename}:${event.lineno}:${event.colno}`,
        "frontend"
      );
    });
    // Capture unhandled promise rejections
    window.addEventListener("unhandledrejection", (event) => {
      addLog("error", `[Unhandled Promise Rejection] ${event.reason}`, "frontend");
    });
  }
  function restoreConsole() {
    console.log = originalConsole.log;
    console.info = originalConsole.info;
    console.warn = originalConsole.warn;
    console.error = originalConsole.error;
    console.debug = originalConsole.debug;
  }
  // Listen for backend logs
  async function setupBackendLogsListener() {
    await listen<{ level: LogLevel; message: string }>("debug:log", (event) => {
      addLog(event.payload.level, event.payload.message, "backend");
    });
  }
  return {
    subscribe,
    toggle: () => update((state) => ({ ...state, isOpen: !state.isOpen })),
    open: () => update((state) => ({ ...state, isOpen: true })),
    close: () => update((state) => ({ ...state, isOpen: false })),
    clear: () => update((state) => ({ ...state, logs: [] })),
    setFilterLevel: (level: LogLevel | "all") =>
      update((state) => ({ ...state, filterLevel: level })),
    setAutoScroll: (enabled: boolean) => update((state) => ({ ...state, autoScroll: enabled })),
    setupConsoleCapture,
    restoreConsole,
    setupBackendLogsListener,
  };
 }
 export const debugConsoleStore = createDebugConsoleStore();
 // Derived store for filtered logs
 export const filteredLogs = derived(debugConsoleStore, ($debugConsole) => {
  if ($debugConsole.filterLevel === "all") {
    return $debugConsole.logs;
  }
  const levelPriority: Record<LogLevel, number> = {
    debug: 0,
    info: 1,
    warn: 2,
    error: 3,
  };
  const minPriority = levelPriority[$debugConsole.filterLevel];
  return $debugConsole.logs.filter((log) => levelPriority[log.level] >= minPriority);
 });
@@ -285,6 +285,73 @@ describe("snippetsStore", () => {
      expect(get(snippetsStore.selectedCategory)).toBeNull();
    });
  });
  describe("filteredSnippets", () => {
    it("returns all snippets when no category selected", async () => {
      const mockSnippets: Snippet[] = [
        {
          id: "snippet-1",
          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",
        },
        {
          id: "snippet-2",
          name: "Docker PS",
          content: "docker ps",
          category: "Docker",
          is_default: false,
          created_at: "2024-01-01T00:00:00Z",
          updated_at: "2024-01-01T00:00:00Z",
        },
      ];
      setMockInvokeResult("list_snippets", mockSnippets);
      setMockInvokeResult("get_snippet_categories", ["Git", "Docker"]);
      await snippetsStore.loadSnippets();
      snippetsStore.setSelectedCategory(null);
      const filtered = get(snippetsStore.filteredSnippets);
      expect(filtered).toHaveLength(2);
    });
    it("filters snippets by selected category", async () => {
      const mockSnippets: Snippet[] = [
        {
          id: "snippet-1",
          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",
        },
        {
          id: "snippet-2",
          name: "Docker PS",
          content: "docker ps",
          category: "Docker",
          is_default: false,
          created_at: "2024-01-01T00:00:00Z",
          updated_at: "2024-01-01T00:00:00Z",
        },
      ];
      setMockInvokeResult("list_snippets", mockSnippets);
      setMockInvokeResult("get_snippet_categories", ["Git", "Docker"]);
      await snippetsStore.loadSnippets();
      snippetsStore.setSelectedCategory("Git");
      const filtered = get(snippetsStore.filteredSnippets);
      expect(filtered).toHaveLength(1);
      expect(filtered[0].category).toBe("Git");
    });
  });
 });
 describe("snippet ID generation", () => {
@@ -2,6 +2,7 @@ import { writable, derived } from "svelte/store";
 import { listen } from "@tauri-apps/api/event";
 import { invoke } from "@tauri-apps/api/core";
 import { costTrackingStore } from "./costTracking";
 import { configStore } from "./config";
 export type ContextWarning = "moderate" | "high" | "critical";
 export type BudgetType = "token" | "cost";
@@ -9,7 +10,9 @@ export type BudgetType = "token" | "cost";
 // Model pricing (per million tokens) - keep in sync with stats.rs
 // Source: https://platform.claude.com/docs/en/about-claude/models/overview
 export const MODEL_PRICING: Record<string, { input: number; output: number }> = {
-  // Current generation (Claude 4.5)
+  // Current generation (Claude 4.6)
  "claude-opus-4-6": { input: 5.0, output: 25.0 },
  // Previous generation (Claude 4.5)
  "claude-opus-4-5-20251101": { input: 5.0, output: 25.0 },
  "claude-sonnet-4-5-20250929": { input: 3.0, output: 15.0 },
  "claude-haiku-4-5-20251001": { input: 1.0, output: 5.0 },
@@ -133,7 +136,7 @@ export function formatTokenCount(tokens: number): string {
 }
 // Derived store for formatted display values
-export const formattedStats = derived(stats, ($stats) => {
+export const formattedStats = derived([stats, configStore.config], ([$stats, $config]) => {
  const formatNumber = (num: number) => num.toLocaleString();
  const formatCost = (cost: number) => `$${cost.toFixed(4)}`;
  const formatDuration = (seconds: number) => {
@@ -164,6 +167,9 @@ export const formattedStats = derived(stats, ($stats) => {
    }));
  };
  // Use the model from stats if available, otherwise fall back to the configured model
  const currentModel = $stats.model ?? $config.model ?? "No model selected";
  return {
    totalTokens: formatNumber($stats.total_input_tokens + $stats.total_output_tokens),
    totalInputTokens: formatNumber($stats.total_input_tokens),
@@ -173,7 +179,7 @@ export const formattedStats = derived(stats, ($stats) => {
    sessionInputTokens: formatNumber($stats.session_input_tokens),
    sessionOutputTokens: formatNumber($stats.session_output_tokens),
    sessionCost: formatCost($stats.session_cost_usd),
-    model: $stats.model || "No model selected",
+    model: currentModel,
    // New formatted fields
    messagesTotal: formatNumber($stats.messages_exchanged),
@@ -12,6 +12,8 @@ import type {
  UserQuestionEvent,
 } from "$lib/types/messages";
 import type { CharacterState } from "$lib/types/states";
 import type { AgentStartPayload, AgentEndPayload } from "$lib/types/agents";
 import { agentStore } from "$lib/stores/agents";
 import {
  initializeNotificationRules,
  cleanupNotificationRules,
@@ -95,6 +97,7 @@ interface OutputPayload {
    output_tokens: number;
    cost_usd: number;
  };
  parent_tool_use_id?: string;
 }
 interface ConnectionPayload {
@@ -175,6 +178,12 @@ export async function initializeTauriListeners() {
    } else if (status === "disconnected") {
      const targetConversationId = conversation_id || get(claudeStore.activeConversationId);
      // Mark all running agents as errored on disconnect, but not during reconnects
      // (permission prompts trigger reconnects and agents may complete before reconnect)
      if (!skipNextGreeting && targetConversationId) {
        agentStore.markAllErrored(targetConversationId);
      }
      // Only remove from connected set if we're not about to reconnect
      if (!skipNextGreeting && targetConversationId) {
        connectedConversations.delete(targetConversationId);
@@ -247,7 +256,8 @@ export async function initializeTauriListeners() {
  unlisteners.push(stateUnlisten);
  const outputUnlisten = await listen<OutputPayload>("claude:output", (event) => {
-    const { line_type, content, tool_name, conversation_id, cost } = event.payload;
+    const { line_type, content, tool_name, conversation_id, cost, parent_tool_use_id } =
      event.payload;
    // Convert snake_case cost to camelCase for TypeScript
    const costData = cost
@@ -265,7 +275,8 @@ export async function initializeTauriListeners() {
        line_type as "user" | "assistant" | "system" | "tool" | "error",
        content,
        tool_name || undefined,
-        costData
+        costData,
        parent_tool_use_id
      );
    } else {
      // Fallback to active conversation if no conversation_id provided
@@ -273,7 +284,8 @@ export async function initializeTauriListeners() {
        line_type as "user" | "assistant" | "system" | "tool" | "error",
        content,
        tool_name || undefined,
-        costData
+        costData,
        parent_tool_use_id
      );
    }
  });
@@ -316,10 +328,19 @@ export async function initializeTauriListeners() {
  });
  unlisteners.push(cwdUnlisten);
  console.log("[Tauri Listener] Setting up claude:permission listener");
  const permissionUnlisten = await listen<PermissionPromptEvent>("claude:permission", (event) => {
-    const { id, tool_name, tool_input, description, conversation_id } = event.payload;
+    const { permissions, conversation_id } = event.payload;
    console.log(
      `[Permission] Event received: ${permissions.length} permission(s) for conversation ${conversation_id || "active"}`,
      { permissions, conversation_id }
    );
    // Store each permission request for the specific conversation
    for (const permission of permissions) {
      const { id, tool_name, tool_input, description } = permission;
    // Store permission request for the specific conversation
      if (conversation_id) {
        claudeStore.requestPermissionForConversation(conversation_id, {
          id,
@@ -342,9 +363,54 @@ export async function initializeTauriListeners() {
        });
        claudeStore.addLine("system", `Permission requested for: ${tool_name}`);
      }
    }
  });
  unlisteners.push(permissionUnlisten);
  const agentStartUnlisten = await listen<AgentStartPayload>("claude:agent-start", (event) => {
    const {
      tool_use_id,
      agent_id,
      description,
      subagent_type,
      started_at,
      conversation_id,
      parent_tool_use_id,
    } = event.payload;
    const targetConversationId = conversation_id || get(claudeStore.activeConversationId);
    if (targetConversationId) {
      agentStore.addAgent(targetConversationId, {
        toolUseId: tool_use_id,
        agentId: agent_id,
        description,
        subagentType: subagent_type,
        startedAt: started_at,
        status: "running",
        parentToolUseId: parent_tool_use_id,
      });
    }
  });
  unlisteners.push(agentStartUnlisten);
  const agentUpdateUnlisten = await listen<{
    conversationId: string;
    toolUseId: string;
    agentId: string;
  }>("claude:agent-update", (event) => {
    const { conversationId, toolUseId, agentId } = event.payload;
    agentStore.updateAgentId(conversationId, toolUseId, agentId);
  });
  unlisteners.push(agentUpdateUnlisten);
  const agentEndUnlisten = await listen<AgentEndPayload>("claude:agent-end", (event) => {
    const { tool_use_id, ended_at, is_error, conversation_id } = event.payload;
    const targetConversationId = conversation_id || get(claudeStore.activeConversationId);
    if (targetConversationId) {
      agentStore.endAgent(targetConversationId, tool_use_id, ended_at, is_error);
    }
  });
  unlisteners.push(agentEndUnlisten);
  const questionUnlisten = await listen<UserQuestionEvent>("claude:question", (event) => {
    const questionEvent = event.payload;
@@ -373,3 +439,73 @@ export function cleanupTauriListeners() {
  // Cleanup notification rules
  cleanupNotificationRules();
 }
 export async function initializeDiscordRpc() {
  const config = configStore.getConfig();
  if (config.discord_rpc_enabled) {
    try {
      const startedAt = new Date();
      const startedAtUnixSeconds = Math.floor(startedAt.getTime() / 1000);
      const model = config.model || "claude";
      await invoke("log_discord_rpc", {
        message: `[FRONTEND] Attempting to initialize Discord RPC: session='Idle', model='${model}', timestamp=${startedAtUnixSeconds}`,
      });
      console.log("Initializing Discord RPC with initial activity:", {
        session_name: "Idle",
        model,
        started_at: startedAtUnixSeconds,
      });
      await invoke("init_discord_rpc", {
        sessionName: "Idle",
        model,
        startedAt: startedAtUnixSeconds,
      });
      await invoke("log_discord_rpc", {
        message: "[FRONTEND] Discord RPC initialized successfully!",
      });
      console.log("Discord RPC initialized successfully with initial presence");
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      await invoke("log_discord_rpc", {
        message: `[FRONTEND] ERROR: Failed to initialize Discord RPC: ${errorMessage}`,
      });
      console.error("Failed to initialize Discord RPC:", error);
      console.warn("Discord RPC will be unavailable. Make sure Discord is running.");
    }
  } else {
    await invoke("log_discord_rpc", {
      message: "[FRONTEND] Discord RPC is disabled in config, skipping initialization",
    });
  }
 }
 export async function updateDiscordRpc(sessionName: string, model: string, startedAt: Date) {
  const config = configStore.getConfig();
  if (!config.discord_rpc_enabled) {
    return;
  }
  try {
    const startedAtUnixSeconds = Math.floor(startedAt.getTime() / 1000);
    await invoke("update_discord_rpc", {
      sessionName: sessionName,
      model,
      startedAt: startedAtUnixSeconds,
    });
  } catch (error) {
    console.error("Failed to update Discord RPC:", error);
  }
 }
 export async function stopDiscordRpc() {
  try {
    await invoke("stop_discord_rpc");
  } catch (error) {
    console.error("Failed to stop Discord RPC:", error);
  }
 }
@@ -0,0 +1,32 @@
 export type AgentStatus = "running" | "completed" | "errored";
 export interface AgentInfo {
  toolUseId: string;
  agentId?: string;
  description: string;
  subagentType: string;
  startedAt: number;
  endedAt?: number;
  status: AgentStatus;
  parentToolUseId?: string;
  durationMs?: number;
 }
 export interface AgentStartPayload {
  tool_use_id: string;
  agent_id?: string;
  description: string;
  subagent_type: string;
  started_at: number;
  conversation_id?: string;
  parent_tool_use_id?: string;
 }
 export interface AgentEndPayload {
  tool_use_id: string;
  ended_at: number;
  is_error: boolean;
  conversation_id?: string;
  duration_ms?: number;
  num_turns?: number;
 }
@@ -10,6 +10,8 @@ export interface TerminalLine {
    outputTokens: number;
    costUsd: number;
  };
  // Indicates if this message is from a subagent
  parentToolUseId?: string;
 }
 export interface SystemInitMessage {
@@ -124,11 +126,15 @@ export interface PermissionRequest {
  input: Record<string, unknown>;
 }
-export interface PermissionPromptEvent {
+export interface PermissionPromptEventItem {
  id: string;
  tool_name: string;
  tool_input: Record<string, unknown>;
  description: string;
 }
 export interface PermissionPromptEvent {
  permissions: PermissionPromptEventItem[];
  conversation_id?: string;
 }
@@ -135,6 +135,151 @@ describe("stateMapper", () => {
      };
      expect(mapMessageToState(message)).toBeNull();
    });
    it("returns typing for unknown tool", () => {
      const message: ClaudeStreamMessage = {
        type: "assistant",
        message: {
          content: [
            {
              type: "tool_use",
              id: "tool-1",
              name: "SomeUnknownTool",
              input: {},
            },
          ],
          model: "claude-3",
          stop_reason: "tool_use",
        },
      };
      expect(mapMessageToState(message)).toBe("typing");
    });
    it("returns thinking for thinking content block", () => {
      const message: ClaudeStreamMessage = {
        type: "assistant",
        message: {
          content: [{ type: "thinking", thinking: "Analyzing the problem..." }],
          model: "claude-3",
          stop_reason: "end_turn",
        },
      };
      expect(mapMessageToState(message)).toBe("thinking");
    });
    it("returns null for assistant message with no recognizable content", () => {
      const message: ClaudeStreamMessage = {
        type: "assistant",
        message: {
          content: [],
          model: "claude-3",
          stop_reason: "end_turn",
        },
      };
      expect(mapMessageToState(message)).toBeNull();
    });
    it("returns thinking for thinking_delta stream event", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "content_block_delta",
          index: 0,
          delta: {
            type: "thinking_delta",
            thinking: "Thinking...",
          },
        },
      };
      expect(mapMessageToState(message)).toBe("thinking");
    });
    it("returns typing for text_delta stream event", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "content_block_delta",
          index: 0,
          delta: {
            type: "text_delta",
            text: "Hello",
          },
        },
      };
      expect(mapMessageToState(message)).toBe("typing");
    });
    it("returns thinking for thinking content_block_start", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "content_block_start",
          index: 0,
          content_block: {
            type: "thinking",
            thinking: "",
          },
        },
      };
      expect(mapMessageToState(message)).toBe("thinking");
    });
    it("returns typing for text content_block_start", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "content_block_start",
          index: 0,
          content_block: {
            type: "text",
            text: "",
          },
        },
      };
      expect(mapMessageToState(message)).toBe("typing");
    });
    it("returns correct state for tool_use content_block_start", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "content_block_start",
          index: 0,
          content_block: {
            type: "tool_use",
            id: "tool-1",
            name: "Read",
            input: {},
          },
        },
      };
      expect(mapMessageToState(message)).toBe("searching");
    });
    it("returns null for stream_event with unrecognized type", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "message_start",
        },
      };
      expect(mapMessageToState(message)).toBeNull();
    });
    it("returns null for result with unknown subtype", () => {
      const message = {
        type: "result",
        subtype: "unknown_type",
      } as unknown as ClaudeStreamMessage;
      expect(mapMessageToState(message)).toBeNull();
    });
    it("returns null for unknown message type", () => {
      const message = {
        type: "unknown_type",
      } as unknown as ClaudeStreamMessage;
      expect(mapMessageToState(message)).toBeNull();
    });
  });
  describe("extractTextFromMessage", () => {
@@ -192,6 +337,36 @@ describe("stateMapper", () => {
      };
      expect(extractTextFromMessage(message)).toBe("Completed successfully");
    });
    it("returns null for result without result field", () => {
      const message: ClaudeStreamMessage = {
        type: "result",
        subtype: "success",
      };
      expect(extractTextFromMessage(message)).toBeNull();
    });
    it("returns null for stream_event without delta text", () => {
      const message: ClaudeStreamMessage = {
        type: "stream_event",
        event: {
          type: "content_block_start",
          index: 0,
          content_block: {
            type: "text",
            text: "",
          },
        },
      };
      expect(extractTextFromMessage(message)).toBeNull();
    });
    it("returns null for unknown message type", () => {
      const message = {
        type: "unknown",
      } as unknown as ClaudeStreamMessage;
      expect(extractTextFromMessage(message)).toBeNull();
    });
  });
  describe("extractToolInfo", () => {
@@ -1,5 +1,6 @@
 <script lang="ts">
  import "../app.css";
  import DebugConsole from "$lib/components/DebugConsole.svelte";
  let { children } = $props();
@@ -14,4 +15,5 @@
 <div id="app">
  {@render children()}
  <DebugConsole />
 </div>
@@ -1,8 +1,16 @@
 <script lang="ts">
  import { onMount, onDestroy } from "svelte";
  import { invoke } from "@tauri-apps/api/core";
  import { listen } from "@tauri-apps/api/event";
  import { get } from "svelte/store";
-  import { initializeTauriListeners, cleanupTauriListeners } from "$lib/tauri";
+  import {
    initializeTauriListeners,
    cleanupTauriListeners,
    initializeDiscordRpc,
    stopDiscordRpc,
    updateDiscordRpc,
    setSkipNextGreeting,
  } from "$lib/tauri";
  import { configStore, applyTheme, applyFontSize, isCompactMode } from "$lib/stores/config";
  import { initNotificationSync, cleanupNotificationSync } from "$lib/stores/notifications";
  import { conversationsStore } from "$lib/stores/conversations";
@@ -24,12 +32,16 @@
  import AchievementNotification from "$lib/components/AchievementNotification.svelte";
  import AchievementsPanel from "$lib/components/AchievementsPanel.svelte";
  import UpdateNotification from "$lib/components/UpdateNotification.svelte";
  import CloseAppConfirmModal from "$lib/components/CloseAppConfirmModal.svelte";
  import { debugConsoleStore } from "$lib/stores/debugConsole";
  let initialized = false;
  let updateNotification: UpdateNotification | undefined = $state(undefined);
  let achievementPanelOpen = $state(false);
  let currentCharacterState: CharacterState = $state("idle");
  let compactModeActive = $state(false);
  let closeConfirmModalOpen = $state(false);
  let hasActiveConversation = $state(false);
  // Editor state
  const isEditorVisible = editorStore.isEditorVisible;
@@ -57,6 +69,24 @@
    }
  });
  // Get reactive references to conversation stores
  const activeConversationId = conversationsStore.activeConversationId;
  const conversations = conversationsStore.conversations;
  // Update Discord RPC when active conversation or model changes
  $effect(() => {
    // Access stores directly (without get()) to create reactive dependencies
    const activeId = $activeConversationId;
    const convs = $conversations;
    const activeConv = activeId ? convs.get(activeId) : null;
    const config = configStore.getConfig();
    const model = config.model || "claude";
    if (activeConv && config.discord_rpc_enabled) {
      updateDiscordRpc(activeConv.name, model, activeConv.startedAt);
    }
  });
  // Window size constants
  const COMPACT_WIDTH = 280;
  const COMPACT_HEIGHT = 400;
@@ -205,6 +235,13 @@
      return;
    }
    // Ctrl+` - Toggle debug console
    if (event.ctrlKey && event.key === "`") {
      event.preventDefault();
      debugConsoleStore.toggle();
      return;
    }
    // Ctrl+E - Toggle editor panel (only when connected)
    if (event.ctrlKey && event.key === "e") {
      event.preventDefault();
@@ -254,6 +291,9 @@
      const conversationId = get(claudeStore.activeConversationId);
      if (!conversationId) return;
      // Set flag to preserve stats/permissions (don't treat next connect as new session)
      setSkipNextGreeting(true);
      await invoke("interrupt_claude", { conversationId });
      claudeStore.addLine("system", "Process interrupted");
    } catch (error) {
@@ -314,6 +354,50 @@
    }
  }
  async function handleCloseRequest() {
    // Check if there's an active conversation with Claude running
    const activeId = get(claudeStore.activeConversationId);
    if (activeId) {
      try {
        const isRunning = await invoke<boolean>("is_claude_running", {
          conversationId: activeId,
        });
        hasActiveConversation = isRunning;
      } catch (error) {
        console.error("Failed to check Claude status:", error);
        hasActiveConversation = false;
      }
    } else {
      hasActiveConversation = false;
    }
    // Always show confirmation modal
    closeConfirmModalOpen = true;
  }
  async function handleConfirmClose() {
    closeConfirmModalOpen = false;
    try {
      await invoke("close_application");
    } catch (error) {
      console.error("Failed to close application:", error);
    }
  }
  async function handleMinimizeToTray() {
    closeConfirmModalOpen = false;
    try {
      const window = getCurrentWindow();
      await window.hide();
    } catch (error) {
      console.error("Failed to minimize to tray:", error);
    }
  }
  function handleCancelClose() {
    closeConfirmModalOpen = false;
  }
  onMount(async () => {
    if (!initialized) {
      initialized = true;
@@ -356,6 +440,19 @@
        const window = getCurrentWindow();
        await window.setSize(new LogicalSize(COMPACT_WIDTH, COMPACT_HEIGHT));
      }
      // Initialize Discord RPC
      await initializeDiscordRpc();
      // Listen for window close requests
      const unlisten = await listen("window-close-requested", () => {
        handleCloseRequest();
      });
      // Store the unlisten function for cleanup
      window.addEventListener("beforeunload", () => {
        unlisten();
      });
    }
  });
@@ -363,6 +460,7 @@
    if (initialized) {
      cleanupTauriListeners();
      cleanupNotificationSync();
      stopDiscordRpc();
      window.removeEventListener("keydown", handleGlobalKeydown);
      initialized = false;
    }
@@ -421,6 +519,13 @@
      onClose={() => (achievementPanelOpen = false)}
    />
    <UpdateNotification bind:this={updateNotification} />
    <CloseAppConfirmModal
      isOpen={closeConfirmModalOpen}
      {hasActiveConversation}
      onClose={handleConfirmClose}
      onMinimize={handleMinimizeToTray}
      onCancel={handleCancelClose}
    />
  </div>
 {/if}
@@ -39,7 +39,6 @@ vi.mock("@tauri-apps/api/core", () => ({
          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,
Author	SHA1	Message	Date
naomi	34e9af57f0	release: v1.4.0 Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 1m22s Details CI / Lint & Test (push) Successful in 17m8s Details CI / Build Linux (push) Successful in 20m43s Details CI / Build Windows (cross-compile) (push) Successful in 30m36s Details	2026-02-07 01:56:47 -08:00
hikari	bf411adeb7	fix: critical permission modal and config issues (#127 ) CI / Lint & Test (push) Has started running Details CI / Build Linux (push) Has been cancelled Details CI / Build Windows (cross-compile) (push) Has been cancelled Details Security Scan and Upload / Security & DefectDojo Upload (push) Has been cancelled Details ## Summary This PR resolves several critical bugs that were blocking the permission modal and causing config loss: - Permission modal not appearing - Fixed z-index issues and runtime errors - Config store race condition - Resolved critical race condition causing settings to be lost - Excessive logging - Removed redundant fmt layer that was writing to hidden stdout - System tool prompts - Prevented unnecessary permission prompts for built-in tools - Permission batching - Added support for parallel permission requests - ExitPlanMode tool - Fixed ExitPlanMode tool not functioning correctly ## Changes Made ### Permission Modal Fixes - Updated z-index to proper value (9999) to ensure modal appears above all other UI elements - Fixed runtime errors that were preventing modal from rendering - Resolved issues with permission grants not being properly applied ### Config Store Race Condition - Fixed critical race condition where multiple rapid config updates would result in lost settings - Ensured config writes are properly sequenced to prevent data loss - Added proper synchronisation for config store operations ### Logging Cleanup - Removed redundant fmt formatting layer that was outputting to hidden stdout - Cleaned up excessive debug logging added during troubleshooting - Removed temporary debugging documentation files ### UX Improvements - Added close confirmation modal with minimise to tray option - Implemented batching for parallel permission requests - Added debug console for viewing frontend and backend logs ### ExitPlanMode Fix - Fixed ExitPlanMode tool not functioning correctly, ensuring proper transitions out of plan mode ## Issues Resolved Closes #112 - Permission flow now properly handles multiple tool requests Closes #113 - ExitPlanMode tool now functions correctly Closes #126 - Debug console feature added (partial - basic implementation complete) ## Test Plan - [x] Permission modal appears and functions correctly - [x] Config settings persist across app restarts - [x] No excessive logging in production builds - [x] System tools don't trigger permission prompts - [x] Parallel permission requests are properly batched - [x] Debug console displays frontend and backend logs - [x] ExitPlanMode properly exits plan mode --- ✨ This PR was created with help from Hikari~ 🌸 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Reviewed-on: #127 Co-authored-by: Hikari <hikari@nhcarrigan.com> Co-committed-by: Hikari <hikari@nhcarrigan.com>	2026-02-07 01:55:49 -08:00
naomi	97a93c31c2	feat: add feature to monitor background agents (#125 ) Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 2m7s Details CI / Lint & Test (push) Successful in 20m11s Details CI / Build Linux (push) Successful in 21m51s Details CI / Build Windows (cross-compile) (push) Successful in 32m8s Details Also includes a fix to persist configuration across reconnects. Reviewed-on: #125 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Co-committed-by: Naomi Carrigan <commits@nhcarrigan.com>	2026-02-06 18:11:18 -08:00
naomi	3e7cb7ef60	feat: opus 4.6 woooo (#111 ) Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 1m2s Details CI / Lint & Test (push) Successful in 16m22s Details CI / Build Linux (push) Successful in 20m23s Details CI / Build Windows (cross-compile) (push) Successful in 30m25s Details ### Explanation _No response_ ### Issue _No response_ ### Attestations - [ ] I have read and agree to the [Code of Conduct](https://docs.nhcarrigan.com/community/coc/) - [ ] I have read and agree to the [Community Guidelines](https://docs.nhcarrigan.com/community/guide/). - [ ] My contribution complies with the [Contributor Covenant](https://docs.nhcarrigan.com/dev/covenant/). ### Dependencies - [ ] I have pinned the dependencies to a specific patch version. ### Style - [ ] I have run the linter and resolved any errors. - [ ] My pull request uses an appropriate title, matching the conventional commit standards. - [ ] My scope of feat/fix/chore/etc. correctly matches the nature of changes in my pull request. ### Tests - [ ] My contribution adds new code, and I have added tests to cover it. - [ ] My contribution modifies existing code, and I have updated the tests to reflect these changes. - [ ] All new and existing tests pass locally with my changes. - [ ] Code coverage remains at or above the configured threshold. ### Documentation _No response_ ### Versioning _No response_ Reviewed-on: #111 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Co-committed-by: Naomi Carrigan <commits@nhcarrigan.com>	2026-02-06 15:24:52 -08:00
naomi	136f95cd1a	fix: ensure permission/stats persist until explicit disconnect (#110 ) Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 1m4s Details CI / Lint & Test (push) Successful in 16m1s Details CI / Build Linux (push) Successful in 20m27s Details CI / Build Windows (cross-compile) (push) Successful in 32m18s Details Also includes cached tokens in cost calculations to provide more accurate billing estimates. Reviewed-on: #110 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Co-committed-by: Naomi Carrigan <commits@nhcarrigan.com>	2026-02-06 13:54:31 -08:00
naomi	6a12a7a34d	release: v1.3.0 Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 1m22s Details CI / Lint & Test (push) Successful in 17m13s Details CI / Build Linux (push) Failing after 3s Details CI / Build Windows (cross-compile) (push) Successful in 26m35s Details	2026-02-05 19:22:40 -08:00
naomi	479652b69e	fix: resolve the weird path issues from windows <-> WSL (#106 ) Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 1m18s Details CI / Lint & Test (push) Has been cancelled Details CI / Build Linux (push) Has been cancelled Details CI / Build Windows (cross-compile) (push) Has been cancelled Details ### Explanation _No response_ ### Issue _No response_ ### Attestations - [ ] I have read and agree to the [Code of Conduct](https://docs.nhcarrigan.com/community/coc/) - [ ] I have read and agree to the [Community Guidelines](https://docs.nhcarrigan.com/community/guide/). - [ ] My contribution complies with the [Contributor Covenant](https://docs.nhcarrigan.com/dev/covenant/). ### Dependencies - [ ] I have pinned the dependencies to a specific patch version. ### Style - [ ] I have run the linter and resolved any errors. - [ ] My pull request uses an appropriate title, matching the conventional commit standards. - [ ] My scope of feat/fix/chore/etc. correctly matches the nature of changes in my pull request. ### Tests - [ ] My contribution adds new code, and I have added tests to cover it. - [ ] My contribution modifies existing code, and I have updated the tests to reflect these changes. - [ ] All new and existing tests pass locally with my changes. - [ ] Code coverage remains at or above the configured threshold. ### Documentation _No response_ ### Versioning _No response_ Reviewed-on: #106 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Co-committed-by: Naomi Carrigan <commits@nhcarrigan.com>	2026-02-05 19:21:36 -08:00
naomi	a72f2afaff	feat: add discord rich presence (#105 ) Security Scan and Upload / Security & DefectDojo Upload (push) Successful in 59s Details CI / Lint & Test (push) Successful in 16m5s Details CI / Build Linux (push) Successful in 19m33s Details CI / Build Windows (cross-compile) (push) Successful in 29m9s Details ### Explanation _No response_ ### Issue _No response_ ### Attestations - [ ] I have read and agree to the [Code of Conduct](https://docs.nhcarrigan.com/community/coc/) - [ ] I have read and agree to the [Community Guidelines](https://docs.nhcarrigan.com/community/guide/). - [ ] My contribution complies with the [Contributor Covenant](https://docs.nhcarrigan.com/dev/covenant/). ### Dependencies - [ ] I have pinned the dependencies to a specific patch version. ### Style - [ ] I have run the linter and resolved any errors. - [ ] My pull request uses an appropriate title, matching the conventional commit standards. - [ ] My scope of feat/fix/chore/etc. correctly matches the nature of changes in my pull request. ### Tests - [ ] My contribution adds new code, and I have added tests to cover it. - [ ] My contribution modifies existing code, and I have updated the tests to reflect these changes. - [ ] All new and existing tests pass locally with my changes. - [ ] Code coverage remains at or above the configured threshold. ### Documentation _No response_ ### Versioning _No response_ Reviewed-on: #105 Co-authored-by: Naomi Carrigan <commits@nhcarrigan.com> Co-committed-by: Naomi Carrigan <commits@nhcarrigan.com>	2026-02-05 16:09:40 -08:00