diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a956de8..4cbba46 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,4 +1,4 @@
-name: Build Unity WakaTime
+name: Build Creative WakaTime
 
 on:
   pull_request:
@@ -72,8 +72,8 @@ jobs:
       shell: msys2 {0}
       run: |
         echo "✅ Ninja build test completed!"
-        if [ -f "build/unity_wakatime.exe" ]; then
-          echo "📦 Executable created: $(stat -c%s build/unity_wakatime.exe) bytes"
+        if [ -f "build/creative_wakatime.exe" ]; then
+          echo "📦 Executable created: $(stat -c%s build/creative_wakatime.exe) bytes"
           echo "🥷 Ninja build test passed - ready for production!"
         else
           echo "❌ Ninja build test failed!"
@@ -135,15 +135,15 @@ jobs:
     - name: Build Production Release (Ninja)
       shell: msys2 {0}
       run: |
-        echo "🥷 Building Unity WakaTime with Ninja v${{ env.RELEASE_VERSION }}..."
+        echo "🥷 Building Creative WakaTime with Ninja v${{ env.RELEASE_VERSION }}..."
         cmake --build build --config $BUILD_TYPE --parallel $(nproc)
 
     - name: Verify Production Build
       shell: msys2 {0}
       run: |
-        if [ -f "build/unity_wakatime.exe" ]; then
+        if [ -f "build/creative_wakatime.exe" ]; then
           echo "✅ Ninja production build successful!"
-          echo "📦 Final executable size: $(stat -c%s build/unity_wakatime.exe) bytes"
+          echo "📦 Final executable size: $(stat -c%s build/creative_wakatime.exe) bytes"
         else
           echo "❌ Ninja production build failed!"
           exit 1
@@ -151,20 +151,33 @@ jobs:
     - name: Create Release Package
       shell: msys2 {0}
       run: |
-        PACKAGE_NAME="Unity-Wakatime_v${{ env.RELEASE_VERSION }}"
+        PACKAGE_NAME="Creative-Wakatime_v${{ env.RELEASE_VERSION }}"
+        EXTENSION_NAME="creative-wakatime"
         echo "📦 Creating release package: $PACKAGE_NAME"
 
         mkdir -p "release-package/$PACKAGE_NAME"
-        cp build/unity_wakatime.exe "release-package/$PACKAGE_NAME/"
+        cp build/creative_wakatime.exe "release-package/$PACKAGE_NAME/"
         cp build/logo_32.png "release-package/$PACKAGE_NAME/"
 
         [ -f README.md ] && cp README.md "release-package/$PACKAGE_NAME/" || echo "README.md not found"
         [ -f LICENSE ] && cp LICENSE "release-package/$PACKAGE_NAME/" || echo "LICENSE not found"
 
+        # Aseprite extension은 별도 설치 가능한 .aseprite-extension(zip)으로 패키징
+        if [ -d aseprite-extension ]; then
+          mkdir -p release-package/aseprite-extension-build
+          cp aseprite-extension/package.json release-package/aseprite-extension-build/
+          cp aseprite-extension/wakatime.lua release-package/aseprite-extension-build/
+          (cd release-package/aseprite-extension-build && 7z a "../${EXTENSION_NAME}.aseprite-extension" package.json wakatime.lua)
+        else
+          echo "aseprite-extension not found"
+        fi
+
         echo "📋 Release package contents:"
         ls -la "release-package/$PACKAGE_NAME/"
+        ls -lh release-package/*.aseprite-extension || true
 
         echo "PACKAGE_NAME=$PACKAGE_NAME" >> $GITHUB_ENV
+        echo "EXTENSION_NAME=$EXTENSION_NAME" >> $GITHUB_ENV
 
     - name: Create ZIP Archive
       shell: msys2 {0}
@@ -180,7 +193,9 @@ jobs:
       uses: actions/upload-artifact@v4
       with:
         name: ${{ env.PACKAGE_NAME }}
-        path: release-package/${{ env.PACKAGE_NAME }}/
+        path: |
+          release-package/${{ env.PACKAGE_NAME }}/
+          release-package/${{ env.EXTENSION_NAME }}.aseprite-extension
         retention-days: 90
 
     - name: Upload ZIP to Release
@@ -188,4 +203,6 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
-        files: release-package/${{ env.PACKAGE_NAME }}.zip
\ No newline at end of file
+        files: |
+          release-package/${{ env.PACKAGE_NAME }}.zip
+          release-package/${{ env.EXTENSION_NAME }}.aseprite-extension
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ab50b2c..a722549 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.23)
-project(unity_wakatime)
+project(creative_wakatime)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -11,6 +11,7 @@ set(SOURCES
         src/process_monitor.cpp
         src/file_watcher.cpp
         src/wakatime_client.cpp
+        src/inbox_bridge.cpp
         src/tray_icon.cpp
         src/windows_dark_mode.cpp
         src/unity_focus_detector.cpp
@@ -21,15 +22,16 @@ set(HEADERS
         include/process_monitor.h
         include/file_watcher.h
         include/wakatime_client.h
+        include/inbox_bridge.h
         include/tray_icon.h
         include/windows_dark_mode.h
         include/unity_focus_detector.h
 )
 
-add_executable(unity_wakatime ${SOURCES} ${HEADERS})
+add_executable(creative_wakatime ${SOURCES} ${HEADERS})
 
 if(WIN32)
-    target_compile_definitions(unity_wakatime PRIVATE
+    target_compile_definitions(creative_wakatime PRIVATE
             WINVER=0x0601
             _WIN32_WINNT=0x0601
             UNICODE=1
@@ -38,7 +40,7 @@ if(WIN32)
     )
 
     if(MINGW)
-        target_link_options(unity_wakatime PRIVATE
+        target_link_options(creative_wakatime PRIVATE
                 -static-libgcc
                 -static-libstdc++
                 -static
@@ -46,7 +48,7 @@ if(WIN32)
                 -Wl,--enable-stdcall-fixup
         )
 
-        target_link_libraries(unity_wakatime
+        target_link_libraries(creative_wakatime
                 winhttp
                 shell32
                 psapi
@@ -58,7 +60,7 @@ if(WIN32)
         )
     else()
         # MSVC용 설정
-        target_link_libraries(unity_wakatime
+        target_link_libraries(creative_wakatime
                 winhttp
                 shell32
                 psapi
@@ -74,23 +76,22 @@ if(WIN32)
     if(CMAKE_BUILD_TYPE STREQUAL "Release")
         if(MSVC)
             # MSVC: Windows 서브시스템 설정
-            set_property(TARGET unity_wakatime PROPERTY WIN32_EXECUTABLE TRUE)
-            target_link_options(unity_wakatime PRIVATE
+            set_property(TARGET creative_wakatime PROPERTY WIN32_EXECUTABLE TRUE)
+            target_link_options(creative_wakatime PRIVATE
                     /SUBSYSTEM:WINDOWS
                     /ENTRY:mainCRTStartup
             )
         elseif(MINGW)
-            # MinGW: 크기 최적화 (-Os), LTO, 미사용 섹션 제거 (Resident Set Size 최소화)
-            target_compile_options(unity_wakatime PRIVATE
+            # MinGW: 크기 최적화 (-Os), 미사용 섹션 제거 (Resident Set Size 최소화)
+            # GCC 16.1.0(MSYS2 MinGW)에서 LTO(-flto) 링크 중 내부 컴파일러 오류가 발생하므로 비활성화한다.
+            target_compile_options(creative_wakatime PRIVATE
                     -Os
-                    -flto
                     -ffunction-sections
                     -fdata-sections
             )
-            target_link_options(unity_wakatime PRIVATE
-                    -Os  # LTO 링크 단계 최적화도 크기 우선으로
+            target_link_options(creative_wakatime PRIVATE
+                    -Os  # 링크 단계도 크기 우선으로 최적화
                     -s   # Strip symbols for smaller file size
-                    -flto
                     -Wl,--gc-sections
             )
         endif()
diff --git a/README.md b/README.md
index 3690ba4..f6dcbde 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,11 @@
 <div align="center">
 
-## Unity - WakaTime
+## Creative - WakaTime
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-skyblue.svg?style=for-the-badge&logo=github)](LICENSE)
-![GitHub Repo stars](https://img.shields.io/github/stars/snow0406/Unity-Wakatime?style=for-the-badge&logo=github&color=%23ef8d9d)
+![GitHub Repo stars](https://img.shields.io/github/stars/snow0406/creative-wakatime?style=for-the-badge&logo=github&color=%23ef8d9d)
 
-🎯 Automatic Unity project detection and time tracking for WakaTime
+🎯 Automatic time tracking for **Unity** and **Aseprite** via WakaTime
 
 ---
 
@@ -13,23 +13,25 @@
 
 ### 🚀 Features
 
-- **Automatic Detection**: Finds Unity projects automatically
-- **Real-time Monitoring**: Tracks file changes as you code
+- **Unity**: Automatic project detection + real-time file change tracking
+- **Aseprite**: Editing & saving activity tracking via a lightweight Lua extension
 - **Version Support**: Detects Unity editor versions (e.g., "Unity 2022.3")
 - **System Tray**: Runs quietly in background with right-click menu
 - **Smart Notifications**: Shows project start/stop alerts
+- **Separate dashboards**: Unity and Aseprite are reported as distinct editors on WakaTime
 
 ### 🔧 System Requirements
 
 - **OS**: Windows
 - **API key**: WakaTime API KEY (free at wakatime.com)
+- **Aseprite** (optional): for sprite/pixel-art tracking
 
 ### 📦 Installation
 
-1. Go to [Releases](https://github.com/Snow0406/Unity-Wakatime/releases)
-2. Download the latest `Unity-Wakatime_vX.X.X.zip`
+1. Go to [Releases](https://github.com/Snow0406/creative-wakatime/releases)
+2. Download the latest `Creative-Wakatime_vX.X.X.zip`
 3. Extract to your preferred location
-4. Run `unity_wakatime.exe`
+4. Run `creative_wakatime.exe`
 
 ### ⚙️ Setup
 
@@ -37,16 +39,67 @@
     - Visit https://wakatime.com/api-key
     - Copy your API key
 
-2. **Configure Unity WakaTime**:
+2. **Configure Creative WakaTime**:
     - Right-click the system tray icon
     - Click "🔑 Setup API Key"
     - The WakaTime website will open automatically
     - Copy your API key and click OK
     - Wait for validation ✅
+    - The API key is stored at `%APPDATA%/creative-wakatime/wakatime_config.txt`
 
-3. **Start Unity and Code!**
+3. **Unity** — Start and Code!
     - Open any Unity project
-    - The app will automatically detect and start tracking
+    - The app automatically detects and starts tracking
+
+4. **Aseprite** — Install the extension (optional):
+    - Download `creative-wakatime.aseprite-extension` from the same release.
+    - Double-click it, or install it from Aseprite via
+      **Edit > Preferences > Extensions > Add Extension**.
+    - Restart Aseprite.
+    - The extension writes local event files to `%APPDATA%/creative-wakatime/events/`.
+    - Creative WakaTime watches that folder and forwards heartbeats.
+
+### 🧩 How Aseprite tracking works
+
+Aseprite cannot be hooked directly from C++, so a small Aseprite **Lua extension**
+emits local JSON event files on edit/save. The tray app watches
+`%APPDATA%/creative-wakatime/events/` (event-driven, no polling) and converts each
+event into a WakaTime heartbeat, then deletes the file.
+
+```
+Unity     -> ProcessMonitor / FileWatcher -> WakaTimeClient -> WakaTime API
+Aseprite  -> Lua extension -> events/*.json -> Inbox bridge -> WakaTimeClient -> WakaTime API
+```
+
+Aseprite events are intentionally optional. If the extension is not installed,
+Creative WakaTime only watches an empty local inbox and no Aseprite heartbeat is
+created.
+
+#### Aseprite extension behavior
+
+- **Edit activity** (`sitechange`): active sprite/layer/frame changes are reported
+  as `is_write=false` with a 2-minute per-file debounce.
+- **Save activity** (`aftercommand` → `SaveFile`/`SaveFileAs`/`SaveFileCopyAs`):
+  reported immediately as `is_write=true`.
+- Unsaved sprites without a file path are ignored.
+- `project` is the parent folder name of the sprite file.
+- The extension does not call the WakaTime API directly; it only writes local
+  `.json` event files for the tray app to consume.
+
+#### Manual Aseprite extension install
+
+If you are building from source instead of using the release asset, zip the
+contents of `aseprite-extension/` so that `package.json` and `wakatime.lua` are at
+the root of the archive, then rename the archive to
+`creative-wakatime.aseprite-extension`.
+
+You can also copy the folder manually:
+
+```text
+%APPDATA%/Aseprite/extensions/creative-wakatime/
+```
+
+The folder must contain both `package.json` and `wakatime.lua`.
 
 ## License
 
@@ -54,4 +107,4 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ---
 
-Made with ♥ by hy
\ No newline at end of file
+Made with ♥ by hy
diff --git a/aseprite-extension/package.json b/aseprite-extension/package.json
new file mode 100644
index 0000000..e8b90dc
--- /dev/null
+++ b/aseprite-extension/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "creative-wakatime",
+  "displayName": "Creative WakaTime",
+  "description": "Tracks Aseprite editing/saving activity for Creative WakaTime (WakaTime). Writes local event files consumed by the Creative WakaTime tray app.",
+  "version": "2.0.0",
+  "author": {
+    "name": "hy"
+  },
+  "contributes": {
+    "scripts": [
+      { "path": "./wakatime.lua" }
+    ]
+  }
+}
diff --git a/aseprite-extension/wakatime.lua b/aseprite-extension/wakatime.lua
new file mode 100644
index 0000000..5a02a3d
--- /dev/null
+++ b/aseprite-extension/wakatime.lua
@@ -0,0 +1,142 @@
+-- Creative WakaTime - Aseprite extension
+--
+-- Aseprite의 편집/저장 활동을 감지해, WakaTime API로 직접 보내지 않고
+-- 로컬 이벤트 파일(%APPDATA%/creative-wakatime/events/*.json)을 생성한다.
+-- Creative WakaTime 트레이 앱(C++)이 그 폴더를 감시해 heartbeat로 변환한다.
+--
+-- 이벤트:
+--   sitechange   -> 활성 sprite 전환 등 편집 활동 (is_write = false)
+--   aftercommand -> SaveFile / SaveFileAs / SaveFileCopyAs 이후 (is_write = true)
+--
+-- Aseprite Lua sandbox에서는 rename이 제공되지 않으므로 .json에 직접 쓴다.
+-- C++ 소비자는 빈/미완성 JSON을 삭제하지 않고 다음 이벤트나 시작 스캔에서 재시도한다.
+
+local EDIT_DEBOUNCE_SECONDS = 120 -- 동일 파일 편집 heartbeat 최소 간격(2분)
+
+-- 저장 명령으로 간주할 command 이름 집합
+local SAVE_COMMANDS = {
+    SaveFile = true,
+    SaveFileAs = true,
+    SaveFileCopyAs = true,
+}
+
+local lastSentByEntity = {}   -- entity -> 마지막 전송 os.time()
+local writeCounter = 0        -- 같은 초 내 파일명 충돌 방지
+local listenerKeys = {}       -- 해제할 리스너 키 보관
+
+-- JSON 문자열 값 이스케이프
+local function jsonEscape(s)
+    s = s:gsub('\\', '\\\\')
+    s = s:gsub('"', '\\"')
+    s = s:gsub('\n', '\\n')
+    s = s:gsub('\r', '\\r')
+    s = s:gsub('\t', '\\t')
+    return s
+end
+
+-- 이벤트 폴더 경로 반환 (없으면 생성). 실패 시 nil.
+local function getEventsDir()
+    local appData = os.getenv("APPDATA")
+    if not appData or appData == "" then
+        return nil
+    end
+
+    local dir = app.fs.joinPath(appData, "creative-wakatime", "events")
+    if not app.fs.isDirectory(dir) then
+        app.fs.makeAllDirectories(dir)
+    end
+    if not app.fs.isDirectory(dir) then
+        return nil
+    end
+
+    return dir
+end
+
+-- HeartbeatData 한 건을 이벤트 파일로 기록
+local function writeEvent(entity, project, isWrite)
+    local dir = getEventsDir()
+    if not dir then
+        return
+    end
+
+    -- 경로를 forward slash로 정규화 (대시보드 표기 일관성)
+    local normEntity = entity:gsub('\\', '/')
+
+    writeCounter = writeCounter + 1
+    local fname = "aseprite-" .. tostring(os.time()) .. "-" .. tostring(writeCounter) .. ".json"
+    local finalPath = app.fs.joinPath(dir, fname)
+
+    local json = "{"
+        .. '"source":"aseprite",'
+        .. '"entity":"' .. jsonEscape(normEntity) .. '",'
+        .. '"project":"' .. jsonEscape(project) .. '",'
+        .. '"language":"Aseprite",'
+        .. '"editor":"Aseprite",'
+        .. '"is_write":' .. (isWrite and "true" or "false") .. ','
+        .. '"time":' .. tostring(os.time())
+        .. "}"
+
+    local f = io.open(finalPath, "w")
+    if not f then
+        return
+    end
+    f:write(json)
+    f:close()
+end
+
+-- 현재 활성 sprite의 파일 경로/프로젝트명을 구해 이벤트 기록
+local function emit(isWrite)
+    local sprite = app.sprite or app.activeSprite
+    if not sprite then
+        return -- 열린 sprite 없음
+    end
+
+    local entity = sprite.filename
+    if not entity or entity == "" then
+        return -- 미저장 새 파일 (filename 없음)
+    end
+
+    -- project = 파일의 부모 폴더 basename
+    local parentPath = app.fs.filePath(entity)
+    local project = app.fs.fileName(parentPath)
+    if not project or project == "" then
+        project = "Aseprite"
+    end
+
+    local now = os.time()
+
+    if not isWrite then
+        -- 편집 활동: entity별 2분 debounce (C++ 측 debounce와 이중 안전)
+        local last = lastSentByEntity[entity]
+        if last and (now - last) < EDIT_DEBOUNCE_SECONDS then
+            return
+        end
+    end
+
+    lastSentByEntity[entity] = now
+    writeEvent(entity, project, isWrite)
+end
+
+local function onActivity()
+    emit(false)
+end
+
+local function onAfterCommand(ev)
+    if ev and ev.name and SAVE_COMMANDS[ev.name] then
+        emit(true)
+    end
+end
+
+function init(plugin)
+    -- 활성 sprite/layer/frame 전환 = 편집 활동
+    listenerKeys[#listenerKeys + 1] = app.events:on('sitechange', onActivity)
+    -- 저장 명령 이후
+    listenerKeys[#listenerKeys + 1] = app.events:on('aftercommand', onAfterCommand)
+end
+
+function exit(plugin)
+    for _, key in ipairs(listenerKeys) do
+        app.events:off(key)
+    end
+    listenerKeys = {}
+end
diff --git a/include/file_watcher.h b/include/file_watcher.h
index 7c90bed..9b4da07 100644
--- a/include/file_watcher.h
+++ b/include/file_watcher.h
@@ -9,11 +9,16 @@
  */
 class FileWatcher {
 private:
+    // 감시 종류: Unity 프로젝트 폴더(재귀) vs 외부 이벤트 inbox 폴더(평면)
+    enum class Kind { Unity, Inbox };
+
     // 감시 중인 프로젝트 정보
     struct WatchedProject {
         std::string projectPath;        // 프로젝트 경로
         std::string projectName;        // 프로젝트 이름
         std::string unityVersion;       // 유니티 버전
+        Kind kind;                      // 감시 종류 (기본 Unity)
+        BOOL recursive;                 // 하위 디렉토리 포함 여부 (Unity: TRUE, Inbox: FALSE)
         HANDLE directoryHandle;         // 디렉토리 핸들
         std::thread watchThread;        // 감시 스레드
         std::atomic<bool> shouldStop;   // 스레드 종료 플래그
@@ -23,6 +28,8 @@ class FileWatcher {
         HANDLE ioEvent;
 
         WatchedProject() :
+            kind(Kind::Unity),
+            recursive(TRUE),
             directoryHandle(INVALID_HANDLE_VALUE),
             shouldStop(false),
             stopEvent(nullptr),
@@ -55,10 +62,14 @@ class FileWatcher {
     mutable std::mutex projectsMutex;  // 스레드 안전성을 위한 뮤텍스
     std::deque<FileChangeEvent> pendingEvents;
     mutable std::mutex pendingEventsMutex;
+    std::deque<std::string> pendingInboxFiles;     // inbox에서 감지된 .json 경로 큐
+    mutable std::mutex pendingInboxMutex;
     std::atomic<bool> notifyScheduled{false};  // PostMessage 코얼레싱 (큐 적재 통지 1회로 합침)
 
     // 파일 변경 이벤트 콜백 함수
     std::function<void(const FileChangeEvent&)> changeCallback;
+    // inbox에서 .json 파일이 감지될 때 호출 (전체 경로 전달)
+    std::function<void(const std::string&)> inboxCallback;
     // 큐에 이벤트가 적재되었음을 메인 스레드에 통지 (PostMessage 등)
     std::function<void()> notifyCallback;
 
@@ -106,7 +117,14 @@ class FileWatcher {
      * @param callback 통지 시 호출될 함수 (예: PostMessage)
      */
     void SetNotifyCallback(std::function<void()> callback);
-    
+
+    /**
+     * inbox 콜백 설정 (외부 이벤트 .json 파일이 감지될 때 호출).
+     * 콜백은 메인 스레드의 DrainPendingEvents 흐름에서 디스패치된다.
+     * @param callback .json 전체 경로를 받는 함수
+     */
+    void SetInboxCallback(std::function<void(const std::string&)> callback);
+
     /**
      * Unity 프로젝트 감시 시작
      * @param projectPath 감시할 프로젝트 경로
@@ -115,6 +133,14 @@ class FileWatcher {
      * @return 성공하면 true
      */
     bool StartWatching(const std::string& projectPath, const std::string& projectName, const std::string& unityVersion);
+
+    /**
+     * 외부 이벤트 inbox 폴더 감시 시작 (평면 구조, 비재귀).
+     * 폴더 내 .json 파일 생성/이름변경/수정 시 inboxCallback이 호출된다.
+     * @param inboxPath 감시할 inbox 폴더 경로 (예: %APPDATA%/creative-wakatime/events)
+     * @return 성공하면 true
+     */
+    bool StartWatchingInbox(const std::string& inboxPath);
     
     /**
      * 특정 프로젝트 감시 중지
diff --git a/include/globals.h b/include/globals.h
index 1f379ab..5aa7248 100644
--- a/include/globals.h
+++ b/include/globals.h
@@ -25,6 +25,8 @@
 #include <sstream>
 #include <fstream>
 #include <algorithm>
+#include <cstdlib>
+#include <system_error>
 
 namespace fs = std::filesystem;
 
@@ -98,7 +100,8 @@ namespace Config
 
     // WakaTime 설정
     const std::string WAKATIME_API_URL = "https://api.wakatime.com/api/v1/users/current/heartbeats";
-    const std::string USER_AGENT = "unity-wakatime/1.0";
+    const std::string APP_NAME = "creative-wakatime";
+    const std::string APP_VERSION = "2.0";
     const int HEARTBEAT_TIMEOUT_MS = 5000;
     const int FILE_WATCHER_BUFFER_SIZE = 4096;
     const int HEARTBEAT_DEBOUNCE_MS = 2000;
@@ -118,6 +121,70 @@ namespace Config
         static const auto folders = std::unordered_set<std::string>(IGNORE_FOLDERS.begin(), IGNORE_FOLDERS.end());
         return folders;
     }
+
+    /**
+     * 앱 데이터 디렉토리 경로 반환 (%APPDATA%/creative-wakatime/).
+     * 폴더가 없으면 events/ 하위까지 생성한다. 실패 시 빈 문자열.
+     * @return 앱 데이터 디렉토리 경로 (끝에 구분자 없음), 실패 시 ""
+     */
+    inline std::string GetAppDataDir()
+    {
+        const char *appData = std::getenv("APPDATA");
+        if (appData == nullptr || appData[0] == '\0')
+        {
+            return "";
+        }
+
+        const std::string dir = std::string(appData) + "\\" + APP_NAME;
+
+        std::error_code ec;
+        fs::create_directories(dir, ec); // 이미 존재해도 에러 아님
+        if (ec)
+        {
+            return "";
+        }
+
+        return dir;
+    }
+
+    /**
+     * 이벤트 inbox 디렉토리 경로 반환 (%APPDATA%/creative-wakatime/events/).
+     * 폴더가 없으면 생성한다. 실패 시 빈 문자열.
+     */
+    inline std::string GetEventsDir()
+    {
+        const std::string base = GetAppDataDir();
+        if (base.empty())
+        {
+            return "";
+        }
+
+        const std::string dir = base + "\\events";
+
+        std::error_code ec;
+        fs::create_directories(dir, ec);
+        if (ec)
+        {
+            return "";
+        }
+
+        return dir;
+    }
+
+    /**
+     * API 키 config 파일 경로 반환 (%APPDATA%/creative-wakatime/wakatime_config.txt).
+     * 앱 데이터 디렉토리를 얻지 못하면 빈 문자열.
+     */
+    inline std::string GetConfigFilePath()
+    {
+        const std::string base = GetAppDataDir();
+        if (base.empty())
+        {
+            return "";
+        }
+
+        return base + "\\wakatime_config.txt";
+    }
 }
 
 extern WakaTimeClient *g_wakatimeClient;
diff --git a/include/inbox_bridge.h b/include/inbox_bridge.h
new file mode 100644
index 0000000..fc96659
--- /dev/null
+++ b/include/inbox_bridge.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "globals.h"
+
+class WakaTimeClient;
+struct HeartbeatData;
+
+/**
+ * 외부(Aseprite 등) 이벤트 inbox(.json)를 소비해 WakaTimeClient로 heartbeat를 보낸다.
+ *
+ * Lua extension이 `%APPDATA%/creative-wakatime/events/`에 `.json` 이벤트 파일을 쓰면
+ * FileWatcher의 inbox 콜백 또는 시작 시 스캔으로 받아 파싱 → EnqueueHeartbeat → 파일 삭제한다.
+ *
+ * 외부 라이브러리 없이 고정 스키마 키만 추출하는 경량 파서를 사용한다(직렬화도 수동).
+ */
+namespace InboxBridge
+{
+    /**
+     * inbox에서 감지된 단일 .json 파일을 처리한다.
+     * 성공/파싱 실패 모두 파일을 삭제해 무한 재시도를 차단한다.
+     * (읽기 자체 실패 = 아직 안 풀린 lock 등은 남겨두고 다음 기회에 재시도)
+     * @param jsonPath 이벤트 파일 전체 경로
+     * @param client heartbeat를 적재할 클라이언트
+     * @param onHeartbeat 처리 성공 시 생성된 heartbeat를 전달받는 선택 콜백
+     */
+    void ProcessFile(const std::string& jsonPath, WakaTimeClient* client,
+                     const std::function<void(const HeartbeatData&)>& onHeartbeat = {});
+
+    /**
+     * 앱 시작 시 events/ 폴더에 쌓인 잔여 .json을 1회 스캔·소비한다.
+     * ReadDirectoryChangesW는 기존 파일에 이벤트를 주지 않으므로 필수.
+     * @param eventsDir 이벤트 폴더 경로
+     * @param client heartbeat를 적재할 클라이언트
+     * @param onHeartbeat 처리 성공 시 생성된 heartbeat를 전달받는 선택 콜백
+     * @return 처리한 파일 수
+     */
+    int InitialScan(const std::string& eventsDir, WakaTimeClient* client,
+                    const std::function<void(const HeartbeatData&)>& onHeartbeat = {});
+}
diff --git a/include/tray_icon.h b/include/tray_icon.h
index b058fea..b2862b3 100644
--- a/include/tray_icon.h
+++ b/include/tray_icon.h
@@ -35,7 +35,7 @@ class TrayIcon {
     
     // 상태 정보
     bool isMonitoring;               // 모니터링 활성 상태
-    std::string currentProject;      // 현재 활성 프로젝트
+    std::string activeContext;       // 현재 활성 컨텍스트(프로젝트/도구)
     int totalHeartbeats;             // 총 heartbeat 수
     bool initialized;                // 초기화 상태
     
@@ -145,10 +145,16 @@ class TrayIcon {
      * @param appName 애플리케이션 이름
      * @return 성공하면 true
      */
-    bool Initialize(const std::string& appName = "Unity WakaTime");
+    bool Initialize(const std::string& appName = "Creative WakaTime");
     
     /**
-     * 현재 프로젝트 설정 (툴팁 업데이트)
+     * 현재 활동 컨텍스트 설정 (툴팁 업데이트)
+     * @param contextName 프로젝트 또는 도구 이름
+     */
+    void SetActiveContext(const std::string& contextName);
+
+    /**
+     * 현재 프로젝트 설정 (이전 API 호환용)
      * @param projectName 프로젝트 이름
      */
     void SetCurrentProject(const std::string& projectName);
diff --git a/include/wakatime_client.h b/include/wakatime_client.h
index 948b299..8b7a627 100644
--- a/include/wakatime_client.h
+++ b/include/wakatime_client.h
@@ -3,6 +3,7 @@
 #include "globals.h"
 #include <winhttp.h>    // Windows HTTP API
 #include <queue>
+#include <unordered_map>
 #include <condition_variable>
 
 #pragma comment(lib, "winhttp.lib") // WinHTTP 라이브러리 링크
@@ -47,9 +48,9 @@ class WakaTimeClient {
     mutable std::mutex queueMutex;              // 큐 접근 동기화
     std::condition_variable queueCv;            // 큐 대기/통지 (busy-poll 제거)
     std::queue<HeartbeatData> heartbeatQueue;   // 전송 대기 큐
-    std::chrono::steady_clock::time_point lastQueuedAt;
-    std::string lastQueuedEntity;
-    std::string lastQueuedProject;
+    // entity+project별 마지막 적재 시각. Unity/Aseprite 파일이 번갈아 들어와도
+    // 서로의 debounce를 무효화하지 않도록 컨텍스트별로 분리한다.
+    std::unordered_map<std::string, std::chrono::steady_clock::time_point> lastQueuedByEntity;
     std::thread senderThread;                   // 백그라운드 전송 스레드
     std::atomic<bool> shouldStop;               // 스레드 종료 플래그
     
@@ -104,9 +105,19 @@ class WakaTimeClient {
     /**
      * 실제 HTTP POST 요청 수행
      * @param jsonData 전송할 JSON 데이터
+     * @param heartbeat User-Agent 구성을 위한 heartbeat (editor 식별용)
      * @return 성공하면 true
      */
-    bool SendHttpRequest(const std::string& jsonData);
+    bool SendHttpRequest(const std::string& jsonData, const HeartbeatData& heartbeat);
+
+    /**
+     * heartbeat의 editor에 맞춰 WakaTime User-Agent 문자열을 구성한다.
+     * WakaTime 대시보드는 User-Agent로 editor/plugin을 식별하므로
+     * Unity/Aseprite를 분리해서 집계하려면 editor별로 다른 UA가 필요하다.
+     * @param heartbeat editor 정보를 담은 heartbeat
+     * @return User-Agent 문자열
+     */
+    std::string BuildUserAgent(const HeartbeatData& heartbeat) const;
     
     /**
      * 백그라운드 전송 스레드 함수
@@ -171,6 +182,14 @@ class WakaTimeClient {
      * @param event 파일 변경 이벤트
      */
     void SendHeartbeatFromEvent(const FileChangeEvent& event);
+
+    /**
+     * 외부에서 완성된 HeartbeatData를 전송 큐에 적재 (비동기).
+     * entity+project별 debounce를 적용하며, Unity 내부 경로와 Aseprite 등
+     * 외부(inbox) heartbeat가 공유하는 단일 진입점이다.
+     * @param heartbeat 적재할 heartbeat 데이터
+     */
+    void EnqueueHeartbeat(const HeartbeatData& heartbeat);
     
     /**
      * 전송 큐에 대기 중인 heartbeat 수
diff --git a/main.cpp b/main.cpp
index 706b5b8..d188286 100644
--- a/main.cpp
+++ b/main.cpp
@@ -2,6 +2,7 @@
 #include "process_monitor.h"
 #include "file_watcher.h"
 #include "wakatime_client.h"
+#include "inbox_bridge.h"
 #include "tray_icon.h"
 #include "unity_focus_detector.h"
 #include "windows_dark_mode.h"
@@ -53,6 +54,35 @@ void OnFileChanged(const FileChangeEvent &event)
     }
 }
 
+void OnInboxHeartbeat(const HeartbeatData &heartbeat)
+{
+    if (!g_trayIcon) return;
+
+    g_trayIcon->IncrementHeartbeats();
+    const std::string editor = heartbeat.editor.empty() ? "Creative tool" : heartbeat.editor;
+    if (!heartbeat.project.empty())
+    {
+        g_trayIcon->SetActiveContext(editor + " - " + heartbeat.project);
+    }
+    else
+    {
+        g_trayIcon->SetActiveContext(editor);
+    }
+}
+
+// 외부 이벤트(.json) inbox 파일 처리 - Aseprite 등이 떨어뜨린 이벤트를 heartbeat로 변환
+void OnInboxFile(const std::string &jsonPath)
+{
+    if (!g_wakatimeClient) return;
+    if (!g_wakatimeClient->IsInitialized())
+    {
+        WT_LOG("[INBOX] ⚠️ Skipped - WakaTime client not initialized: " << jsonPath);
+        return;
+    }
+
+    InboxBridge::ProcessFile(jsonPath, g_wakatimeClient, OnInboxHeartbeat);
+}
+
 // 트레이 아이콘 콜백 함수들
 void OnTrayExit()
 {
@@ -101,7 +131,8 @@ void OnTrayShowSettings()
     {
         std::ostringstream settings;
         settings << "API Key: " << g_wakatimeClient->GetMaskedApiKey() << "\n"
-                << "Watching " << g_fileWatcher->GetWatchedProjectCount() << " Unity projects";
+                << "Unity projects watched: " << g_fileWatcher->GetWatchedProjectCount() << "\n"
+                << "Aseprite inbox: active";
 
         g_trayIcon->ShowInfoNotification(settings.str());
     }
@@ -169,8 +200,8 @@ void HandleNewUnityInstances(const std::vector<UnityInstance> &newInstances)
             if (g_trayIcon)
             {
                 g_trayIcon->SetCurrentProject(instance.projectName);
-                g_trayIcon->ShowInfoNotification("New Unity project: " + instance.projectName +
-                                                 " (Unity " + instance.editorVersion + ")");
+                g_trayIcon->ShowInfoNotification("Unity detected: " + instance.projectName +
+                                                 " (" + instance.editorVersion + ")");
             }
         }
         else
@@ -193,7 +224,7 @@ void HandleClosedUnityInstances(const std::vector<UnityInstance> &closedInstance
 
         if (g_trayIcon)
         {
-            g_trayIcon->ShowInfoNotification("Unity project closed: " + instance.projectName);
+            g_trayIcon->ShowInfoNotification("Unity closed: " + instance.projectName);
 
             // 다른 활성 프로젝트로 전환
             if (g_fileWatcher)
@@ -255,7 +286,7 @@ void CALLBACK FocusWinEventProc(HWINEVENTHOOK, const DWORD event, const HWND hwn
 
 int main()
 {
-    WT_LOG("[Main] Unity WakaTime Monitor Starting...");
+    WT_LOG("[Main] Creative WakaTime Monitor Starting...");
     const bool darkModeAvailable = WindowsDarkMode::EnableForApp();
     WT_LOG("[Main] Dark mode menu opt-in: "
               << (darkModeAvailable ? "enabled" : "not available"));
@@ -263,7 +294,7 @@ int main()
     TrayIcon trayIcon;
     g_trayIcon = &trayIcon;
 
-    if (!trayIcon.Initialize("Unity WakaTime"))
+    if (!trayIcon.Initialize("Creative WakaTime"))
     {
         WT_ERR("[Main] Failed to initialize tray icon!");
         return 1;
@@ -277,7 +308,7 @@ int main()
     trayIcon.SetShowSettingsCallback(OnTrayShowSettings);
     trayIcon.SetApiKeyChangeCallback(OnApiKeyChanged);
 
-    trayIcon.ShowInfoNotification("Unity WakaTime started !");
+    trayIcon.ShowInfoNotification("Creative WakaTime started !");
 
     WakaTimeClient wakatimeClient;
     g_wakatimeClient = &wakatimeClient;
@@ -294,12 +325,33 @@ int main()
     g_fileWatcher = &fileWatcher;
 
     fileWatcher.SetChangeCallback(OnFileChanged);
+    fileWatcher.SetInboxCallback(OnInboxFile);
     // 워커 스레드의 파일 변경 → 메인 스레드로 PostMessage 마샬링 (InitialScan 이전에 설치)
     fileWatcher.SetNotifyCallback([&trayIcon]()
     {
         trayIcon.NotifyFileEvent();
     });
 
+    // 외부 이벤트 inbox(%APPDATA%/creative-wakatime/events) 감시 시작 + 잔여 처리.
+    // 앱이 꺼진 동안 쌓인 이벤트는 ReadDirectoryChangesW가 통지하지 않으므로 시작 시 1회 스캔.
+    const std::string eventsDir = Config::GetEventsDir();
+    if (!eventsDir.empty())
+    {
+        if (fileWatcher.StartWatchingInbox(eventsDir))
+        {
+            WT_LOG("[Main] Watching external events inbox: " << eventsDir);
+        }
+        else
+        {
+            WT_ERR("[Main] Failed to watch events inbox: " << eventsDir);
+        }
+        InboxBridge::InitialScan(eventsDir, &wakatimeClient, OnInboxHeartbeat);
+    }
+    else
+    {
+        WT_ERR("[Main] Could not resolve events directory (APPDATA missing)");
+    }
+
     UnityFocusDetector unityFocusDetector;
     g_unityFocusDetector = &unityFocusDetector;
 
@@ -311,7 +363,7 @@ int main()
 
     trayIcon.SetMonitoringState(true);
 
-    WT_LOG("\n[Main] Unity WakaTime is now running in background!");
+    WT_LOG("\n[Main] Creative WakaTime is now running in background!");
 
     // 이벤트 허브 콜백 배선 (TrayIcon의 메시지 펌프에서 디스패치)
     trayIcon.SetFileEventCallback([]()
@@ -348,8 +400,8 @@ int main()
 
     if (focusHook) UnhookWinEvent(focusHook);
 
-    WT_LOG("\n[Main] Shutting down Unity WakaTime...");
-    trayIcon.ShowInfoNotification("Unity WakaTime shutting down...");
+    WT_LOG("\n[Main] Shutting down Creative WakaTime...");
+    trayIcon.ShowInfoNotification("Creative WakaTime shutting down...");
 
     // 남은 heartbeat 전송
     if (g_wakatimeClient)
@@ -372,6 +424,6 @@ int main()
 
     Globals::Cleanup();
 
-    WT_LOG("[Main] Unity WakaTime stopped gracefully.");
+    WT_LOG("[Main] Creative WakaTime stopped gracefully.");
     return 0;
 }
diff --git a/src/file_watcher.cpp b/src/file_watcher.cpp
index 6522b02..f247169 100644
--- a/src/file_watcher.cpp
+++ b/src/file_watcher.cpp
@@ -30,6 +30,80 @@ void FileWatcher::SetNotifyCallback(std::function<void()> callback)
     WT_LOG("[FileWatcher] Notify callback set");
 }
 
+void FileWatcher::SetInboxCallback(std::function<void(const std::string &)> callback)
+{
+    inboxCallback = std::move(callback);
+    WT_LOG("[FileWatcher] Inbox callback set");
+}
+
+bool FileWatcher::StartWatchingInbox(const std::string &inboxPath)
+{
+    std::lock_guard<std::mutex> lock(projectsMutex);
+
+    // 이미 감시 중인지 확인
+    for (const auto &project: watchedProjects)
+    {
+        if (project->projectPath == inboxPath) return true;
+    }
+
+    if (!fs::exists(inboxPath))
+    {
+        WT_ERR("[FileWatcher] Inbox path does not exist: " << inboxPath);
+        return false;
+    }
+
+    auto project = std::make_unique<WatchedProject>();
+    if (project->stopEvent == nullptr || project->ioEvent == nullptr)
+    {
+        WT_ERR("[FileWatcher] Failed to create watcher events for inbox: " << inboxPath);
+        return false;
+    }
+
+    project->projectPath = inboxPath;
+    project->projectName = "events";
+    project->kind = Kind::Inbox;
+    project->recursive = FALSE; // events 폴더는 평면 구조라 하위 트리 감시 불필요
+    project->shouldStop = false;
+
+    ZeroMemory(&project->overlapped, sizeof(OVERLAPPED));
+    project->overlapped.hEvent = project->ioEvent;
+    ZeroMemory(project->buffer, sizeof(project->buffer));
+
+    project->directoryHandle = CreateFileA(
+        inboxPath.c_str(),
+        FILE_LIST_DIRECTORY,
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+        nullptr,
+        OPEN_EXISTING,
+        FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
+        nullptr
+    );
+
+    if (project->directoryHandle == INVALID_HANDLE_VALUE)
+    {
+        const DWORD error = GetLastError();
+        WT_ERR("[FileWatcher] Failed to open inbox directory: " << inboxPath << " (Error: " << error << ")");
+        return false;
+    }
+
+    WT_LOG("[FileWatcher] Started watching inbox at " << inboxPath);
+
+    WatchedProject *projectPtr = project.get();
+    try
+    {
+        project->watchThread = std::thread(&FileWatcher::WatchProjectThread, this, projectPtr);
+    }
+    catch (const std::system_error &e)
+    {
+        WT_ERR("[FileWatcher] Failed to start inbox watch thread: " << e.what());
+        return false;
+    }
+
+    watchedProjects.push_back(std::move(project));
+
+    return true;
+}
+
 bool FileWatcher::StartWatching(const std::string &projectPath, const std::string &projectName, const std::string &unityVersion)
 {
     std::lock_guard<std::mutex> lock(projectsMutex);
@@ -128,12 +202,12 @@ void FileWatcher::WatchProjectThread(WatchedProject *project)
         ResetEvent(project->ioEvent);
 
         // ReadDirectoryChangesW: 디렉토리 변경사항을 감지하는 핵심 함수
-        // TRUE: 하위 폴더도 감시
+        // recursive: Unity는 TRUE(하위 폴더 포함), inbox는 FALSE(평면 구조)
         const BOOL result = ReadDirectoryChangesW(
             project->directoryHandle,           // 디렉토리 핸들
             project->buffer,                    // 결과를 받을 버퍼
             sizeof(project->buffer),            // 버퍼 크기
-            TRUE,                               // 하위 디렉토리 포함
+            project->recursive,                 // 하위 디렉토리 포함 여부
             FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_FILE_NAME,
             &bytesReturned,                     // 받은 데이터 크기
             &project->overlapped,               // 비동기 I/O 구조체
@@ -233,49 +307,89 @@ void FileWatcher::ProcessFileChanges(char *buffer, DWORD bytesReturned, WatchedP
             std::replace(fullPath.begin(), fullPath.end(), '\\', '/');
             std::replace(fileName.begin(), fileName.end(), '\\', '/');
 
-            // 무시할 폴더인지 확인
-            bool shouldIgnore = false;
-            std::istringstream pathStream(fileName);
-            std::string segment;
-
-            while (std::getline(pathStream, segment, '/'))
+            if (project->kind == Kind::Inbox)
             {
-                if (ShouldIgnoreFolder(segment))
+                // inbox: IGNORE_FOLDERS/IsUnityFile 건너뛰고, .json 추가/이름변경/수정만 처리.
+                // Aseprite Lua sandbox에는 rename이 없어 .json에 직접 쓰며, 빈/미완성 파일은
+                // InboxBridge가 삭제하지 않고 다음 이벤트나 시작 스캔에서 재시도한다.
+                const bool relevantAction =
+                    (info->Action == FILE_ACTION_ADDED ||
+                     info->Action == FILE_ACTION_RENAMED_NEW_NAME ||
+                     info->Action == FILE_ACTION_MODIFIED);
+
+                const bool isJson = [&fileName]() {
+                    if (fileName.size() < 5) return false;
+                    std::string ext = fileName.substr(fileName.size() - 5);
+                    std::transform(ext.begin(), ext.end(), ext.begin(),
+                                   [](const unsigned char c) { return static_cast<char>(::tolower(c)); });
+                    return ext == ".json";
+                }();
+
+                if (relevantAction && isJson)
                 {
-                    shouldIgnore = true;
-                    break;
+                    WT_LOG("[FileWatcher] Inbox event: " << fileName);
+
+                    {
+                        std::lock_guard<std::mutex> lock(pendingInboxMutex);
+                        while (pendingInboxFiles.size() >= kMaxPendingEvents)
+                        {
+                            pendingInboxFiles.pop_front();
+                        }
+                        pendingInboxFiles.emplace_back(std::move(fullPath));
+                    }
+
+                    if (notifyCallback && !notifyScheduled.exchange(true))
+                    {
+                        notifyCallback();
+                    }
                 }
             }
-
-            // Unity 파일이고 무시할 폴더가 아닌 경우에만 처리
-            if (!shouldIgnore && IsUnityFile(fileName))
+            else
             {
-                // FileChangeEvent 생성
-                FileChangeEvent event;
-                event.filePath = fullPath;
-                event.fileName = fileName;
-                event.projectPath = project->projectPath;
-                event.projectName = project->projectName;
-                event.unityVersion = project->unityVersion;
-                event.action = info->Action;
-                event.timestamp = std::chrono::system_clock::now();
-
-                WT_LOG("[FileWatcher] Change" << ": " << fileName << " in " << project->projectName);
-
-                // 워커 스레드에서 직접 UI/앱 콜백을 호출하지 않고 큐에 적재
+                // 무시할 폴더인지 확인
+                bool shouldIgnore = false;
+                std::istringstream pathStream(fileName);
+                std::string segment;
+
+                while (std::getline(pathStream, segment, '/'))
                 {
-                    std::lock_guard<std::mutex> lock(pendingEventsMutex);
-                    while (pendingEvents.size() >= kMaxPendingEvents)
+                    if (ShouldIgnoreFolder(segment))
                     {
-                        pendingEvents.pop_front();
+                        shouldIgnore = true;
+                        break;
                     }
-                    pendingEvents.emplace_back(std::move(event));
                 }
 
-                // 메인 스레드에 통지 (코얼레싱: 이미 예약돼 있으면 추가 post 생략)
-                if (notifyCallback && !notifyScheduled.exchange(true))
+                // Unity 파일이고 무시할 폴더가 아닌 경우에만 처리
+                if (!shouldIgnore && IsUnityFile(fileName))
                 {
-                    notifyCallback();
+                    // FileChangeEvent 생성
+                    FileChangeEvent event;
+                    event.filePath = fullPath;
+                    event.fileName = fileName;
+                    event.projectPath = project->projectPath;
+                    event.projectName = project->projectName;
+                    event.unityVersion = project->unityVersion;
+                    event.action = info->Action;
+                    event.timestamp = std::chrono::system_clock::now();
+
+                    WT_LOG("[FileWatcher] Change" << ": " << fileName << " in " << project->projectName);
+
+                    // 워커 스레드에서 직접 UI/앱 콜백을 호출하지 않고 큐에 적재
+                    {
+                        std::lock_guard<std::mutex> lock(pendingEventsMutex);
+                        while (pendingEvents.size() >= kMaxPendingEvents)
+                        {
+                            pendingEvents.pop_front();
+                        }
+                        pendingEvents.emplace_back(std::move(event));
+                    }
+
+                    // 메인 스레드에 통지 (코얼레싱: 이미 예약돼 있으면 추가 post 생략)
+                    if (notifyCallback && !notifyScheduled.exchange(true))
+                    {
+                        notifyCallback();
+                    }
                 }
             }
         }
@@ -299,7 +413,8 @@ bool FileWatcher::IsUnityFile(const std::string &fileName) const
     if (dotPos == std::string::npos) return false; // 확장자가 없으면 무시
 
     std::string extension = fileName.substr(dotPos);
-    std::transform(extension.begin(), extension.end(), extension.begin(), tolower); // 소문자로 변환
+    std::transform(extension.begin(), extension.end(), extension.begin(),
+                   [](const unsigned char c) { return static_cast<char>(::tolower(c)); }); // 소문자로 변환
 
     const auto &extensions = Config::GetUnityExtensions();
     return extensions.find(extension) != extensions.end();
@@ -308,13 +423,15 @@ bool FileWatcher::IsUnityFile(const std::string &fileName) const
 bool FileWatcher::ShouldIgnoreFolder(const std::string &folderName) const
 {
     std::string normalizedFolder = folderName;
-    std::transform(normalizedFolder.begin(), normalizedFolder.end(), normalizedFolder.begin(), tolower);
+    std::transform(normalizedFolder.begin(), normalizedFolder.end(), normalizedFolder.begin(),
+                   [](const unsigned char c) { return static_cast<char>(::tolower(c)); });
 
     const auto &ignoreFolders = Config::GetIgnoreFolders();
     for (const auto &ignoreFolder: ignoreFolders)
     {
         std::string normalizedIgnore = ignoreFolder;
-        std::transform(normalizedIgnore.begin(), normalizedIgnore.end(), normalizedIgnore.begin(), tolower);
+        std::transform(normalizedIgnore.begin(), normalizedIgnore.end(), normalizedIgnore.begin(),
+                       [](const unsigned char c) { return static_cast<char>(::tolower(c)); });
         if (normalizedFolder == normalizedIgnore)
         {
             return true;
@@ -401,7 +518,7 @@ void FileWatcher::StopAllWatching()
 
 void FileWatcher::DrainPendingEvents(const size_t maxEvents)
 {
-    if (!changeCallback || maxEvents == 0)
+    if (maxEvents == 0)
     {
         return;
     }
@@ -409,29 +526,52 @@ void FileWatcher::DrainPendingEvents(const size_t maxEvents)
     // 드레인 시작 전에 예약 플래그를 내려, 이 시점 이후 도착하는 이벤트는 새 통지를 post하도록 한다.
     notifyScheduled.store(false);
 
-    std::vector<FileChangeEvent> localEvents;
     bool moreRemaining = false;
+
+    // 1) Unity 파일 변경 이벤트 드레인
+    if (changeCallback)
     {
-        std::lock_guard<std::mutex> lock(pendingEventsMutex);
-        if (pendingEvents.empty())
+        std::vector<FileChangeEvent> localEvents;
         {
-            return;
+            std::lock_guard<std::mutex> lock(pendingEventsMutex);
+            const size_t count = std::min(maxEvents, pendingEvents.size());
+            localEvents.reserve(count);
+            for (size_t i = 0; i < count; ++i)
+            {
+                localEvents.emplace_back(std::move(pendingEvents.front()));
+                pendingEvents.pop_front();
+            }
+
+            if (!pendingEvents.empty()) moreRemaining = true;
         }
 
-        const size_t count = std::min(maxEvents, pendingEvents.size());
-        localEvents.reserve(count);
-        for (size_t i = 0; i < count; ++i)
+        for (const auto &event: localEvents)
         {
-            localEvents.emplace_back(std::move(pendingEvents.front()));
-            pendingEvents.pop_front();
+            changeCallback(event);
         }
-
-        moreRemaining = !pendingEvents.empty();
     }
 
-    for (const auto &event: localEvents)
+    // 2) inbox(.json) 이벤트 드레인
+    if (inboxCallback)
     {
-        changeCallback(event);
+        std::vector<std::string> localInbox;
+        {
+            std::lock_guard<std::mutex> lock(pendingInboxMutex);
+            const size_t count = std::min(maxEvents, pendingInboxFiles.size());
+            localInbox.reserve(count);
+            for (size_t i = 0; i < count; ++i)
+            {
+                localInbox.emplace_back(std::move(pendingInboxFiles.front()));
+                pendingInboxFiles.pop_front();
+            }
+
+            if (!pendingInboxFiles.empty()) moreRemaining = true;
+        }
+
+        for (const auto &jsonPath: localInbox)
+        {
+            inboxCallback(jsonPath);
+        }
     }
 
     // maxEvents 한도로 다 비우지 못했으면 다음 처리를 위해 통지를 다시 예약
@@ -444,7 +584,13 @@ void FileWatcher::DrainPendingEvents(const size_t maxEvents)
 size_t FileWatcher::GetWatchedProjectCount() const
 {
     std::lock_guard<std::mutex> lock(projectsMutex);
-    return watchedProjects.size();
+    // inbox 감시는 Unity 프로젝트가 아니므로 카운트에서 제외
+    size_t count = 0;
+    for (const auto &project: watchedProjects)
+    {
+        if (project->kind == Kind::Unity) ++count;
+    }
+    return count;
 }
 
 std::vector<WatchedProjectInfo> FileWatcher::GetWatchedProjects() const
@@ -456,6 +602,7 @@ std::vector<WatchedProjectInfo> FileWatcher::GetWatchedProjects() const
 
     for (const auto &project: watchedProjects)
     {
+        if (project->kind != Kind::Unity) continue; // inbox 제외
         WatchedProjectInfo info;
         info.projectPath = project->projectPath;
         info.projectName = project->projectName;
diff --git a/src/inbox_bridge.cpp b/src/inbox_bridge.cpp
new file mode 100644
index 0000000..492164f
--- /dev/null
+++ b/src/inbox_bridge.cpp
@@ -0,0 +1,288 @@
+#include "inbox_bridge.h"
+#include "wakatime_client.h"
+
+namespace
+{
+    // JSON 문자열 이스케이프 해제 (\" \\ \/ \n \r \t \b \f \uXXXX 일부 처리)
+    std::string UnescapeJson(const std::string &raw)
+    {
+        std::string out;
+        out.reserve(raw.size());
+
+        for (size_t i = 0; i < raw.size(); ++i)
+        {
+            const char c = raw[i];
+            if (c == '\\' && i + 1 < raw.size())
+            {
+                const char next = raw[++i];
+                switch (next)
+                {
+                    case '"': out += '"'; break;
+                    case '\\': out += '\\'; break;
+                    case '/': out += '/'; break;
+                    case 'n': out += '\n'; break;
+                    case 'r': out += '\r'; break;
+                    case 't': out += '\t'; break;
+                    case 'b': out += '\b'; break;
+                    case 'f': out += '\f'; break;
+                    case 'u':
+                        // \uXXXX: BMP 범위만 단순 처리 (ASCII면 그대로, 아니면 UTF-8 인코딩)
+                        if (i + 4 < raw.size())
+                        {
+                            const std::string hex = raw.substr(i + 1, 4);
+                            i += 4;
+                            try
+                            {
+                                const unsigned int cp = std::stoul(hex, nullptr, 16);
+                                if (cp < 0x80)
+                                {
+                                    out += static_cast<char>(cp);
+                                }
+                                else if (cp < 0x800)
+                                {
+                                    out += static_cast<char>(0xC0 | (cp >> 6));
+                                    out += static_cast<char>(0x80 | (cp & 0x3F));
+                                }
+                                else
+                                {
+                                    out += static_cast<char>(0xE0 | (cp >> 12));
+                                    out += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                                    out += static_cast<char>(0x80 | (cp & 0x3F));
+                                }
+                            }
+                            catch (...)
+                            {
+                                // 무시
+                            }
+                        }
+                        break;
+                    default: out += next; break;
+                }
+            }
+            else
+            {
+                out += c;
+            }
+        }
+
+        return out;
+    }
+
+    // 고정 스키마용 경량 추출: "key" : "value" 또는 "key" : value(숫자/불리언) 형태.
+    // 문자열 값이면 isString=true. 키를 못 찾으면 false.
+    bool ExtractRawValue(const std::string &json, const std::string &key,
+                         std::string &outValue, bool &outIsString)
+    {
+        const std::string needle = "\"" + key + "\"";
+        size_t pos = json.find(needle);
+        if (pos == std::string::npos) return false;
+
+        pos += needle.size();
+
+        // ':' 찾기
+        pos = json.find(':', pos);
+        if (pos == std::string::npos) return false;
+        ++pos;
+
+        // 공백 skip
+        while (pos < json.size() && (json[pos] == ' ' || json[pos] == '\t' ||
+                                     json[pos] == '\n' || json[pos] == '\r'))
+        {
+            ++pos;
+        }
+        if (pos >= json.size()) return false;
+
+        if (json[pos] == '"')
+        {
+            // 문자열 값: 닫는 따옴표(이스케이프 안 된)까지
+            ++pos;
+            const size_t start = pos;
+            std::string raw;
+            while (pos < json.size())
+            {
+                if (json[pos] == '\\' && pos + 1 < json.size())
+                {
+                    raw += json[pos];
+                    raw += json[pos + 1];
+                    pos += 2;
+                    continue;
+                }
+                if (json[pos] == '"') break;
+                raw += json[pos];
+                ++pos;
+            }
+            (void)start;
+            outValue = UnescapeJson(raw);
+            outIsString = true;
+            return true;
+        }
+
+        // 숫자/불리언/null: 구분자(, } 공백)까지
+        const size_t start = pos;
+        while (pos < json.size() && json[pos] != ',' && json[pos] != '}' &&
+               json[pos] != ' ' && json[pos] != '\t' && json[pos] != '\n' && json[pos] != '\r')
+        {
+            ++pos;
+        }
+        outValue = json.substr(start, pos - start);
+        outIsString = false;
+        return true;
+    }
+
+    std::string GetString(const std::string &json, const std::string &key)
+    {
+        std::string value;
+        bool isString = false;
+        if (ExtractRawValue(json, key, value, isString))
+        {
+            return value;
+        }
+        return "";
+    }
+
+    // 파일 전체를 문자열로 읽기. 실패(열기 실패/빈 파일)면 false.
+    bool ReadWholeFile(const std::string &path, std::string &out)
+    {
+        std::ifstream file(path, std::ios::binary);
+        if (!file.is_open()) return false;
+
+        std::ostringstream ss;
+        ss << file.rdbuf();
+        out = ss.str();
+
+        return !out.empty();
+    }
+
+    bool IsProbablyCompleteJson(const std::string &content)
+    {
+        const auto first = content.find_first_not_of(" \t\r\n");
+        if (first == std::string::npos || content[first] != '{') return false;
+
+        const auto last = content.find_last_not_of(" \t\r\n");
+        return last != std::string::npos && content[last] == '}';
+    }
+}
+
+namespace InboxBridge
+{
+    void ProcessFile(const std::string &jsonPath, WakaTimeClient *client,
+                     const std::function<void(const HeartbeatData&)> &onHeartbeat)
+    {
+        if (client == nullptr) return;
+
+        std::string content;
+        if (!ReadWholeFile(jsonPath, content))
+        {
+            // 아직 안 풀린 lock이거나 빈 파일 → 삭제하지 않고 다음 기회에 재시도.
+            WT_LOG("[InboxBridge] Skip (unreadable/empty): " << jsonPath);
+            return;
+        }
+
+        if (!IsProbablyCompleteJson(content))
+        {
+            // Aseprite Lua는 .json에 직접 쓰므로 파일 쓰기 중 MODIFIED 이벤트가 먼저 올 수 있다.
+            // 이 경우 삭제하지 않고 다음 MODIFIED/시작 스캔에서 재시도한다.
+            WT_LOG("[InboxBridge] Skip (incomplete json): " << jsonPath);
+            return;
+        }
+
+        // 필수 키 추출
+        const std::string entity = GetString(content, "entity");
+        if (entity.empty())
+        {
+            // 스키마 위반 → 무한 재시도 방지 위해 삭제
+            WT_ERR("[InboxBridge] Invalid event (no entity), deleting: " << jsonPath);
+            std::error_code ec;
+            fs::remove(jsonPath, ec);
+            return;
+        }
+
+        HeartbeatData hb;
+        hb.entity = entity;
+        hb.project = GetString(content, "project");
+        hb.language = GetString(content, "language");
+        hb.editor = GetString(content, "editor");
+        if (hb.editor.empty()) hb.editor = "Aseprite";
+        if (hb.language.empty()) hb.language = hb.editor;
+
+        // is_write (불리언)
+        std::string isWriteRaw;
+        bool isStr = false;
+        hb.is_write = false;
+        if (ExtractRawValue(content, "is_write", isWriteRaw, isStr))
+        {
+            hb.is_write = (isWriteRaw == "true" || isWriteRaw == "1");
+        }
+
+        // time (Unix timestamp). 없거나 0이면 현재 시각.
+        std::string timeRaw;
+        hb.time = 0;
+        if (ExtractRawValue(content, "time", timeRaw, isStr) && !timeRaw.empty())
+        {
+            try
+            {
+                hb.time = static_cast<int64_t>(std::stoll(timeRaw));
+            }
+            catch (...)
+            {
+                hb.time = 0;
+            }
+        }
+        if (hb.time <= 0)
+        {
+            const auto now = std::chrono::system_clock::now().time_since_epoch();
+            hb.time = std::chrono::duration_cast<std::chrono::seconds>(now).count();
+        }
+
+        WT_LOG("[InboxBridge] Heartbeat: " << hb.entity << " (" << hb.project
+                << ", " << hb.editor << ", write=" << (hb.is_write ? "1" : "0") << ")");
+
+        client->EnqueueHeartbeat(hb);
+        if (onHeartbeat)
+        {
+            onHeartbeat(hb);
+        }
+
+        // 처리 성공 → 파일 삭제
+        std::error_code ec;
+        fs::remove(jsonPath, ec);
+        if (ec)
+        {
+            WT_ERR("[InboxBridge] Failed to delete consumed event: " << jsonPath);
+        }
+    }
+
+    int InitialScan(const std::string &eventsDir, WakaTimeClient *client,
+                    const std::function<void(const HeartbeatData&)> &onHeartbeat)
+    {
+        if (client == nullptr || eventsDir.empty()) return 0;
+
+        std::error_code ec;
+        if (!fs::exists(eventsDir, ec)) return 0;
+
+        int processed = 0;
+        for (const auto &entry: fs::directory_iterator(eventsDir, ec))
+        {
+            if (ec) break;
+            if (!entry.is_regular_file(ec)) continue;
+
+            const auto &path = entry.path();
+            std::string ext = path.extension().string();
+            std::transform(ext.begin(), ext.end(), ext.begin(),
+                           [](const unsigned char c) { return static_cast<char>(::tolower(c)); });
+            if (ext != ".json") continue;
+
+            std::string full = path.string();
+            std::replace(full.begin(), full.end(), '\\', '/');
+            ProcessFile(full, client, onHeartbeat);
+            ++processed;
+        }
+
+        if (processed > 0)
+        {
+            WT_LOG("[InboxBridge] Initial scan processed " << processed << " event(s)");
+        }
+
+        return processed;
+    }
+}
diff --git a/src/process_monitor.cpp b/src/process_monitor.cpp
index b4af22f..ff4022f 100644
--- a/src/process_monitor.cpp
+++ b/src/process_monitor.cpp
@@ -234,7 +234,8 @@ void ProcessMonitor::PollChanges(std::vector<UnityInstance>& started, std::vecto
 std::string ProcessMonitor::ExtractProjectPath(const std::string &commandLine)
 {
     std::string lowerCommandLine = commandLine;
-    std::transform(lowerCommandLine.begin(), lowerCommandLine.end(), lowerCommandLine.begin(), tolower);
+    std::transform(lowerCommandLine.begin(), lowerCommandLine.end(), lowerCommandLine.begin(),
+                   [](const unsigned char c) { return static_cast<char>(::tolower(c)); });
 
     constexpr char projectPathArg[] = "-projectpath";
     size_t pos = lowerCommandLine.find(projectPathArg);
diff --git a/src/tray_icon.cpp b/src/tray_icon.cpp
index ccaabab..02c92bb 100644
--- a/src/tray_icon.cpp
+++ b/src/tray_icon.cpp
@@ -66,7 +66,7 @@ bool TrayIcon::CreateHiddenWindow()
     // 창 클래스 등록
     wc.lpfnWndProc = WindowProc; // 윈도우 프로시저
     wc.hInstance = GetModuleHandle(nullptr); // 현재 모듈 핸들
-    wc.lpszClassName = L"UnityWakaTimeTray"; // 클래스 이름
+    wc.lpszClassName = L"CreativeWakaTimeTray"; // 클래스 이름
     wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
     wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
 
@@ -84,8 +84,8 @@ bool TrayIcon::CreateHiddenWindow()
     // WS_OVERLAPPED: 기본 창 스타일
     // CW_USEDEFAULT: 기본 위치/크기
     hwnd = CreateWindowW(
-        L"UnityWakaTimeTray",           // 클래스 이름
-        L"Unity WakaTime",              // 창 제목
+        L"CreativeWakaTimeTray",        // 클래스 이름
+        L"Creative WakaTime",           // 창 제목
         WS_OVERLAPPED,                  // 창 스타일
         CW_USEDEFAULT, CW_USEDEFAULT,   // 위치
         1, 1,                           // 크기 (최소)
@@ -117,7 +117,7 @@ bool TrayIcon::CreateTrayIcon() {
 
     nid.hIcon = LoadPngIcon("logo_32.png");
 
-    wcscpy_s(nid.szTip, L"Unity WakaTime - Starting...");
+    wcscpy_s(nid.szTip, L"Creative WakaTime - Starting...");
 
     if (!Shell_NotifyIconW(NIM_ADD, &nid)) {
         DWORD error = GetLastError();
@@ -340,14 +340,14 @@ HMENU TrayIcon::CreateStatusSubMenu()
     const std::wstring monitoringStatus = isMonitoring ? L"Monitoring: Active" : L"Monitoring: Paused";
     AppendMenuW(subMenu, MF_STRING | MF_GRAYED, 0, monitoringStatus.c_str());
 
-    // Current project
-    if (!currentProject.empty())
+    // Active context
+    if (!activeContext.empty())
     {
-        const std::wstring projectInfo = L"Current Project: " + std::wstring(currentProject.begin(), currentProject.end());
-        AppendMenuW(subMenu, MF_STRING | MF_GRAYED, 0, projectInfo.c_str());
+        const std::wstring contextInfo = L"Active: " + std::wstring(activeContext.begin(), activeContext.end());
+        AppendMenuW(subMenu, MF_STRING | MF_GRAYED, 0, contextInfo.c_str());
     } else
     {
-        AppendMenuW(subMenu, MF_STRING | MF_GRAYED, 0, L"No Unity project detected");
+        AppendMenuW(subMenu, MF_STRING | MF_GRAYED, 0, L"No active creative tool detected");
     }
 
     // Heartbeat summary
@@ -390,7 +390,7 @@ void TrayIcon::UpdateContextMenu()
 }
 
 void TrayIcon::OpenGitHubRepository() {
-    const auto githubUrl = "https://github.com/Snow0406/Unity-Wakatime";
+    const auto githubUrl = "https://github.com/Snow0406/creative-wakatime";
 
     const std::wstring wGithubUrl(githubUrl, githubUrl + strlen(githubUrl));
     WT_LOG("[TrayIcon] Opening GitHub repository: " << githubUrl);
@@ -700,30 +700,35 @@ void TrayIcon::ShowBalloonNotification(const std::string &title,
     nid.uFlags &= ~NIF_INFO;
 }
 
-void TrayIcon::SetCurrentProject(const std::string &projectName)
+void TrayIcon::SetActiveContext(const std::string &contextName)
 {
-    const bool projectChanged = (currentProject != projectName);
-    currentProject = projectName;
+    const bool contextChanged = (activeContext != contextName);
+    activeContext = contextName;
 
     std::ostringstream tooltip;
-    tooltip << "Unity WakaTime";
-    if (!projectName.empty())
+    tooltip << "Creative WakaTime";
+    if (!contextName.empty())
     {
-        tooltip << " - " << projectName;
+        tooltip << " - " << contextName;
     }
     tooltip << " (" << totalHeartbeats << " heartbeats)";
 
     UpdateTooltip(tooltip.str());
-    if (projectChanged)
+    if (contextChanged)
     {
         RefreshStatusMenu();
     }
 }
 
+void TrayIcon::SetCurrentProject(const std::string &projectName)
+{
+    SetActiveContext(projectName);
+}
+
 void TrayIcon::IncrementHeartbeats()
 {
     totalHeartbeats++;
-    SetCurrentProject(currentProject);
+    SetActiveContext(activeContext);
 }
 
 void TrayIcon::SetMonitoringState(const bool monitoring)
@@ -731,10 +736,10 @@ void TrayIcon::SetMonitoringState(const bool monitoring)
     isMonitoring = monitoring;
 
     std::ostringstream tooltip;
-    tooltip << "Unity WakaTime - " << (monitoring ? "Active" : "Paused");
-    if (!currentProject.empty())
+    tooltip << "Creative WakaTime - " << (monitoring ? "Active" : "Paused");
+    if (!activeContext.empty())
     {
-        tooltip << " - " << currentProject;
+        tooltip << " - " << activeContext;
     }
 
     UpdateTooltip(tooltip.str());
@@ -775,12 +780,12 @@ void TrayIcon::Shutdown()
 
 void TrayIcon::ShowErrorNotification(const std::string &message)
 {
-    ShowBalloonNotification("Unity WakaTime Error", message, 5000, NIIF_ERROR);
+    ShowBalloonNotification("Creative WakaTime Error", message, 5000, NIIF_ERROR);
 }
 
 void TrayIcon::ShowInfoNotification(const std::string &message)
 {
-    ShowBalloonNotification("Unity WakaTime", message, 2000, NIIF_INFO);
+    ShowBalloonNotification("Creative WakaTime", message, 2000, NIIF_INFO);
 }
 
 #pragma endregion Notification
diff --git a/src/wakatime_client.cpp b/src/wakatime_client.cpp
index 81b64ac..0ec8970 100644
--- a/src/wakatime_client.cpp
+++ b/src/wakatime_client.cpp
@@ -3,6 +3,7 @@
 namespace
 {
     constexpr size_t kMaxHeartbeatQueueSize = 256;
+    constexpr size_t kMaxDebounceEntries = 256;
     constexpr auto kSameFileHeartbeatInterval = std::chrono::seconds(120);
     constexpr auto kSameFileWriteInterval = std::chrono::seconds(2);
 
@@ -26,7 +27,7 @@ WakaTimeClient::WakaTimeClient() : hSession(nullptr),
                                    totalSent(0),
                                    totalFailed(0)
 {
-    userAgent = "unity-wakatime/1.0 (Windows)";
+    userAgent = "creative-wakatime/" + Config::APP_VERSION + " (Windows)";
     machineName = GetMachineName();
 
     WT_LOG("[WakaTimeClient] Created for machine: " << machineName);
@@ -282,7 +283,34 @@ std::string WakaTimeClient::Base64Encode(const std::string &input)
     return encoded;
 }
 
-bool WakaTimeClient::SendHttpRequest(const std::string &jsonData)
+std::string WakaTimeClient::BuildUserAgent(const HeartbeatData &heartbeat) const
+{
+    // WakaTime 대시보드는 User-Agent 끝의 plugin 토큰으로 editor를 식별한다.
+    // 형식: creative-wakatime/{ver} (Windows) {editor} {plugin}/{ver}
+    const std::string base = "creative-wakatime/" + Config::APP_VERSION + " (Windows) ";
+
+    // editor 문자열에서 첫 토큰으로 어떤 도구인지 판단 ("Unity 2022.3" → "Unity").
+    std::string editorName = heartbeat.editor;
+    if (const size_t spacePos = editorName.find(' '); spacePos != std::string::npos)
+    {
+        editorName = editorName.substr(0, spacePos);
+    }
+
+    std::string lowered = editorName;
+    std::transform(lowered.begin(), lowered.end(), lowered.begin(),
+                   [](const unsigned char c) { return static_cast<char>(::tolower(c)); });
+
+    if (lowered == "aseprite")
+    {
+        return base + "Aseprite aseprite-wakatime/" + Config::APP_VERSION;
+    }
+
+    // 기본값: Unity (editor 비어있을 때 포함)
+    const std::string editorToken = heartbeat.editor.empty() ? "Unity" : heartbeat.editor;
+    return base + editorToken + " unity-wakatime/" + Config::APP_VERSION;
+}
+
+bool WakaTimeClient::SendHttpRequest(const std::string &jsonData, const HeartbeatData &heartbeat)
 {
     if (!initialized || hSession == nullptr)
     {
@@ -323,7 +351,7 @@ bool WakaTimeClient::SendHttpRequest(const std::string &jsonData)
     // HTTP 헤더 설정
     std::string authHeader = "Authorization: Basic " + Base64Encode(apiKey + ":");
     std::string contentTypeHeader = "Content-Type: application/json";
-    std::string userAgentHeader = "User-Agent: " + userAgent;
+    std::string userAgentHeader = "User-Agent: " + BuildUserAgent(heartbeat);
     std::string machineHeader = "X-Machine-Name: " + machineName;
 
     // 와이드 문자로 변환해서 헤더 추가
@@ -429,7 +457,7 @@ void WakaTimeClient::SenderThreadFunction()
         }
 
         const std::string jsonData = HeartbeatToJson(heartbeat);
-        SendHttpRequest(jsonData);
+        SendHttpRequest(jsonData, heartbeat);
 
         // 연속 전송 레이트리밋. 종료 시 즉시 깨어나도록 wait_for 사용
         {
@@ -449,7 +477,7 @@ void WakaTimeClient::SendHeartbeat(const std::string &filePath, const std::strin
         return;
     }
 
-    // HeartbeatData 생성
+    // HeartbeatData 생성 (Unity 컨텍스트)
     HeartbeatData heartbeat;
     heartbeat.entity = filePath;
     heartbeat.project = projectName;
@@ -466,15 +494,28 @@ void WakaTimeClient::SendHeartbeat(const std::string &filePath, const std::strin
         heartbeat.editor = "Unity";
     }
 
+    EnqueueHeartbeat(heartbeat);
+}
+
+void WakaTimeClient::EnqueueHeartbeat(const HeartbeatData &heartbeat)
+{
+    if (!initialized)
+    {
+        WT_ERR("[WakaTimeClient] Not initialized, cannot enqueue heartbeat");
+        return;
+    }
+
     // 큐에 추가 (비동기 전송)
     {
         std::lock_guard<std::mutex> lock(queueMutex);
 
         const auto now = std::chrono::steady_clock::now();
-        const bool isSameContext = (heartbeat.entity == lastQueuedEntity && heartbeat.project == lastQueuedProject);
-        if (lastQueuedAt.time_since_epoch().count() != 0 && isSameContext)
+        // entity + project를 \x1f(unit separator)로 결합해 컨텍스트별 키 생성
+        const std::string key = heartbeat.entity + '\x1f' + heartbeat.project;
+
+        if (const auto it = lastQueuedByEntity.find(key); it != lastQueuedByEntity.end())
         {
-            const auto elapsed = now - lastQueuedAt;
+            const auto elapsed = now - it->second;
             const auto minInterval = heartbeat.is_write ? kSameFileWriteInterval : kSameFileHeartbeatInterval;
             if (elapsed < minInterval)
             {
@@ -487,9 +528,35 @@ void WakaTimeClient::SendHeartbeat(const std::string &filePath, const std::strin
             heartbeatQueue.pop(); // 메모리 폭주 방지를 위해 가장 오래된 heartbeat 제거
         }
         heartbeatQueue.push(heartbeat);
-        lastQueuedAt = now;
-        lastQueuedEntity = heartbeat.entity;
-        lastQueuedProject = heartbeat.project;
+        lastQueuedByEntity[key] = now;
+
+        // debounce 맵 무한 증가 방지: 상한 초과 시 만료(>heartbeat interval)된 엔트리 정리.
+        // 그래도 상한을 넘으면 가장 오래된 엔트리를 제거한다.
+        if (lastQueuedByEntity.size() > kMaxDebounceEntries)
+        {
+            for (auto it = lastQueuedByEntity.begin(); it != lastQueuedByEntity.end();)
+            {
+                if (now - it->second > kSameFileHeartbeatInterval)
+                {
+                    it = lastQueuedByEntity.erase(it);
+                }
+                else
+                {
+                    ++it;
+                }
+            }
+
+            while (lastQueuedByEntity.size() > kMaxDebounceEntries)
+            {
+                auto oldest = lastQueuedByEntity.begin();
+                for (auto it = lastQueuedByEntity.begin(); it != lastQueuedByEntity.end(); ++it)
+                {
+                    if (it->second < oldest->second) oldest = it;
+                }
+                lastQueuedByEntity.erase(oldest);
+            }
+        }
+
         queueCv.notify_one();
     }
 }
@@ -521,7 +588,12 @@ std::string WakaTimeClient::GetMaskedApiKey() const
 
 bool WakaTimeClient::LoadApiKeyFromFile()
 {
-    const std::string configPath = "wakatime_config.txt";
+    const std::string configPath = Config::GetConfigFilePath();
+    if (configPath.empty())
+    {
+        WT_ERR("[WakaTimeClient] Failed to resolve config path (APPDATA missing)");
+        return false;
+    }
 
     std::ifstream file(configPath);
     if (!file.is_open())
@@ -533,7 +605,9 @@ bool WakaTimeClient::LoadApiKeyFromFile()
     std::getline(file, apiKey);
     file.close();
 
-    apiKey.erase(std::remove_if(apiKey.begin(), apiKey.end(), isspace), apiKey.end());
+    apiKey.erase(std::remove_if(apiKey.begin(), apiKey.end(),
+                                [](const unsigned char c) { return std::isspace(c) != 0; }),
+                 apiKey.end());
 
     if (apiKey.empty())
     {
@@ -547,7 +621,12 @@ bool WakaTimeClient::LoadApiKeyFromFile()
 
 bool WakaTimeClient::SaveApiKeyToFile(const std::string &key)
 {
-    const std::string configPath = "wakatime_config.txt";
+    const std::string configPath = Config::GetConfigFilePath();
+    if (configPath.empty())
+    {
+        WT_ERR("[WakaTimeClient] Failed to resolve config path (APPDATA missing)");
+        return false;
+    }
 
     std::ofstream file(configPath);
     if (!file.is_open())