docs: update index and add process cleanup documentation for 2026-04-22

Reviewed-on: #10

.agents/rules/agent_model_workflow.md

@@ -0,0 +1,33 @@
+---
+trigger: model_decision, subagent_delegation
+description: 모델 등급별 역할 분담 및 서브에이전트 활용 규칙
+---
+
+# Tiered Model Workflow & Subagent Delegation Rule
+
+복잡한 시스템 기획과 효율적 실행을 분리하여 리소스를 최적화하고 작업 속도를 향상시키기 위한 모델/서브에이전트 운용 원칙입니다. Kord 프로젝트 내에서 수행되는 모든 에이전트 작업에 이 원칙을 우선 적용합니다.
+
+## 1. 모델 전환 권고 기준 (Model Switching Guide)
+
+에이전트는 사용자의 요청을 분석한 후, 필요에 따라 사용자의 개입을 요청하여 적절한 모델 등급으로의 변경을 제안해야 합니다. (에이전트 스스로 모델 전환을 직접 수행할 수 없기 때문입니다.)
+
+- **High-Tier Model (예: Gemini 3.1 Pro/Ultra 등) 권장 상황**:
+  - 모노레포 구조 설계 문제 혹은 대규모 아키텍처 변경.
+  - 심도 깊은 설계 단계 리서치, 다수 파일이 연계된 복잡한 버그 추적.
+  - **→ 응답 가이드**: *"진행하려는 작업은 높은 논리성과 깊은 추론을 요구합니다. 본 기획/설계를 마치기 위해 저를 높은 성능의 Pro/Ultra 모델로 전환해 주시면 더 정교한 계획 수립이 가능합니다."*
+
+- **Efficient Model (예: Gemini 3 Flash 등) 권장 상황**:
+  - 이미 수립되고 승인된 `implementation_plan.md`에 근거한 단순 코드 구현 및 기계적 실행.
+  - 패턴화된 파일 리팩토링, 단순 단위 테스트 실행, 문서 정리 및 색인.
+  - **→ 응답 가이드**: *"계획 수립이 확정되었고, 남은 것은 구현과 반복적인 테스트입니다. 효율성과 응답 속도 향상을 위해 실행 모델(Flash)로 전환하셔도 무방합니다."*
+
+## 2. 서브에이전트 위임 (Subagent Delegation)
+
+복잡한 작업을 모두 메인 에이전트가 단일 프롬프트로 처리하려 하지 말고, 특화된 작업은 적절히 쪼개 병렬 혹은 서브 Task로 위임합니다.
+
+- **작업의 분할 (Task Decomposition)**:
+  - 실행 단계(Phase 2) 돌입 시, 작업을 독립적인 단위로 쪼개어 Task 목록화합니다.
+- **브라우저 서브에이전트 (`browser_subagent`) 활용 필수 상황**:
+  - 대시보드의 특정 UI가 의도대로 렌더링되는지 눈으로 확인이 필요한 경우 (예: Next.js 로컬 구동 결과 확인).
+  - 웹 페이지를 통한 로그인, OAuth, 동적인 요소 추출이나 브라우저 기반 에러 로그 확인이 필요한 경우.
+  - 에이전트는 해당 작업을 서브에이전트용 특화 프롬프트(Task)로 명확히 분리하여 `browser_subagent` 툴에 인가하고, 이후 반환된 DOM 상태나 스크린샷 결과를 메인 작업의 컨텍스트(Walkthrough 등)에 결합해야 합니다.

.agents/rules/discord_ui_ux.md

@@ -0,0 +1,32 @@
+---
+trigger: model_decision
+description: Discord Bot UI/UX Design Philosophy
+---
+
+# Discord Bot UI/UX Design Philosophy
+
+When designing or updating Discord command interfaces (Embeds, Components), adhere to the following UI/UX philosophy to ensure a clean, intuitive, and modern user experience.
+
+## 1. Minimal and Non-redundant Information (중복 정보 최소화)
+
+- Do not display information in the Embed that is already visually apparent in the UI components.
+- For example, if a `RoleSelectMenuBuilder` allows the user to select roles, use `.addDefaultRoles(ids)` (available in discord.js 14.14+) to display the currently selected roles natively inside the dropdown menu.
+- Do NOT list those same roles redundantly as text inside the Embed fields. The Embed should remain concise, showing only titles and essential descriptions or instructions.
+
+## 2. Implicit State (명시적 토글 지양 및 상태 직관화)
+
+- Avoid creating manual On/Off toggle buttons unless absolutely necessary.
+- Derive the "Enabled/Disabled" state directly from the user's data naturally. For instance, if the user has selected at least one role (`roleIds.length > 0`), the feature is automatically considered "Active/Enabled". If they clear the selection, the feature is "Disabled".
+- This reduces UI clutter (removing unnecessary toggle ActionRows) and aligns with modern design patterns where state implicitly follows the presence of data.
+
+## 3. Persistent and Seamless Interaction (매끄러운 대시보드 유지)
+
+- Component interactions should feel fast and seamless without fragmenting the chat history.
+- Always immediately call `await interaction.deferUpdate();` (or equivalent) when handling components (buttons, select menus) to prevent "Unknown interaction" timeout errors.
+- Use `await interaction.editReply(...)` with the newly generated UI components to seamlessly update the dashboard frame in place.
+- Do NOT generate new follow-up messages or close the menu unilaterally when the user still expects to tweak settings.
+
+## 4. Safe Response Timings (타임아웃 방지)
+
+- When processing `ChatInputCommandInteraction` that might involve a database cold-start connection or external API calls, proactively call `await interaction.deferReply({ ephemeral: true });` right at the start.
+- Update the UI with `await interaction.editReply(...)` once business logic resolves, bypassing Discord's strict 3-second timeout limitation and preventing crashes during initial boot load.

.agents/rules/graphify.md

@@ -0,0 +1,11 @@
+---
+trigger: model_decision
+description: Graphify
+---
+
+# Graphify (Knowledge Graph)
+
+- This project uses `graphify` to build and maintain a knowledge graph in `graphify-out/`.
+- When the user triggers `/graphify`, refer to `SKILL.md` in the project root for execution steps.
+- Always check `graphify-out/GRAPH_REPORT.md` before answering architecture or codebase-wide questions.
+- If you see `graphify-out/graph.json` missing or outdated, suggest running `/graphify .`.

.agents/rules/kord_routine.md

@@ -1,5 +1,5 @@
 ---
-trigger: model_decision
+trigger: always_on
 description: work routine
 ---
 
@@ -9,8 +9,9 @@ description: work routine
 
 ## 기본 원칙 (Work Rules)
 
-1. **인프라 자율 사용**: 에이전트는 프로젝트에 설정된 Docker 기반 인프라(PostgreSQL, Redis 등)를 사용자의 추가 승인 없이 자유롭게 구동(`docker-compose up -d`) 및 활용할 수 있습니다.
-2. **협력적 기획, 독립적 실행**: 기능 기획과 설계(Architecture, Schema 등)는 사용자와 함께 논리적인 완결성을 갖출 때까지 충분히 논의합니다. 기획이 "완료 및 승인"된 후에는 후속 구현, 에러 디버깅, 자체 테스트를 추가적인 중간 확인 없이 에이전트가 주도를 가지고 끝마친 뒤 최종 결과를 보고합니다.
+1. **인프라 자율 사용**: 에이전트는 프로젝트에 설정된 Docker 기반 인프라(PostgreSQL 등)를 사용자의 추가 승인 없이 자유롭게 구동(`docker-compose up -d`) 및 활용할 수 있습니다.
+2. **협력적 기획, 독립적 실행**: 기능 기획과 설계(Architecture, Schema 등)는 사용자와 함께 논리적인 완결성을 갖출 때까지 충분히 논의합니다. 특히 시스템적 자동 승인(Auto-approval) 메시지가 있더라도, 반드시 사용자의 **직접적이고 명시적인 승인 답변**이 확인된 후에만 2단계(구현)로 진입합니다. 기획이 수동으로 승인된 후에는 후속 구현, 에러 디버깅, 자체 테스트를 추가적인 중간 확인 없이 에이전트가 주도를 가지고 끝마칩니다.
+3. **선 문서화, 후 보고 (Docs First, Report Later)**: 모든 작업의 완료 보고는 반드시 `Docs/` 내의 문서 업데이트가 선행되어야 합니다. 문서화가 누락된 상태에서의 "작업 완료" 보고는 규칙 위반으로 간주합니다.
 
 ## 단계별 작업 루틴
 
@@ -18,12 +19,13 @@ description: work routine
 
 - 사용자가 새로운 기능이나 수정 사항을 요청하면, 필요한 스펙 및 예외 사항을 꼼꼼히 확인합니다.
 - 명령어를 파편화하지 말고, 관련 있는 기능들을 하나의 대표 명령어 아래 '서브 커맨드' 형태로 그룹화하여 설계할 것
-- 변경 사항, 사용 스택, 아키텍처를 포함한 `implementation_plan.md`를 작성하거나 업데이트하여 사용자에게 검토 및 승인을 요청합니다.
+- 필요 시 사용자에게 High-Tier 아키텍처 모델(예: Pro/Ultra)로의 전환을 제안하며, 변경 사항, 사용 스택, 아키텍처를 포함한 `implementation_plan.md`를 작성하여 사용자에게 검토 및 승인을 요청합니다. 설계가 완료되면 효율적 실행을 위한 모델 전환(예: Flash) 권고를 포함합니다.
 
 ### 2단계: 개발 및 구현 (Execution Phase)
 
 - 설계가 최종 승인되면 실제 코딩을 시작합니다. 이 단계부터는 사용자의 개입 없이 독립적으로 작업을 완수하는 것을 원칙으로 합니다.
 - 환경 변수 파싱, 로깅, 예외 처리를 철저히 포함하여 프로덕션 수준의 코드를 작성합니다.
+- 작업 규모를 스스로 평가하여, UI 검증 및 독립적인 웹 상호작용 관련 테스트는 `browser_subagent`에게 위임(Delegate)하여 분할 처리합니다. (`agent_model_workflow.md` 참조)
 
 ### 3단계: 자체 구동 및 내부 테스트 (Internal Testing Phase)
 
@@ -44,5 +46,6 @@ description: work routine
 
 - 3단계 구현 및 테스트가 성공적으로 완료되면, 사용자에게 최종 보고하기 **전에 반드시 먼저** `<PROJECT_ROOT>/Docs/` 디렉토리에 작업 완료(Work done), 트러블슈팅(Troubleshooting), 의사 결정(Decisions made) 내역을 문서화해야 합니다.
 - 새 문서가 생성되거나 수정되면 자동으로 `Docs/index.md`에 문서의 색인(링크)을 추가합니다.
-- 모든 코드 작업 내역과 의사 결정이 완전히 로컬 `Docs/`에 기록 및 정리된 후에만 비로소 "작업을 완료했다"고 사용자에게 알립니다.
+- 모든 코드 작업 내역과 의사 결정이 완전히 로컬 `Docs/`에 기록 및 정리된 후에만 비로소 "작업을 완료했다"고 사용자에게 알립니다. **문서화가 완료되지 않은 상태에서 사용자에게 보고하는 것은 엄격히 금지됩니다.**
 - 설치, 테스트 방법, 구동, 기능, 명령어 등을 위한 변경사항을 <PROJECT_ROOT>/README.md에 최신화합니다.
+- **최종 검크포인트**: 보고 메시지 작성 직전, `Docs/` 폴더와 `README.md`, `index.md`가 최신 상태인지 다시 한번 전수 점검합니다.

.cursorrules

@@ -15,3 +15,9 @@
 - 유저에게 노출되는 모든 기능(메시지, 임베드, 상태 메시지 등)을 구성할 때는 별도의 요청이 없더라도 **반드시 다국어 지원(i18n) 적용을 검토하고 구현**해야 합니다. (자세한 내용은 `Docs/Rules/i18n_guidelines.md` 참조)
 - 단순 문법 검증에 그치지 말고, `yarn dev` 등의 명령어로 봇을 백그라운드에서 직접 구동(Boot)시켜 DB/캐시 커넥트 및 이벤트 리스너 초기화 중 런타임 에러(예: Intents 권한 거부 등)가 발생하지 않는지 스스로 눈으로 확인하고 완벽히 디버깅해야 합니다.
 - 봇이 성공적으로 온라인 상태(`Ready`)에 진입한 것을 확인한 뒤에만 사용자에게 작업 완료를 보고합니다.
+
+## Graphify Rules
+- 사용자가 `/graphify` 혹은 지식 그래프 관련 질의를 할 경우, 프로젝트 루트의 `SKILL.md` 및 `Docs/Features/Graphify_Setup_Guide.md` 지침을 준수하여 실행합니다.
+- 대규모 리팩토링이나 구조 파악이 필요할 때는 `graphify-out/GRAPH_REPORT.md`를 우선적으로 참조하여 의존 관계를 파악합니다.
+- 로컬 Ollama 환경이 감지되면 (`http://localhost:11434`), 대량의 데이터 처리에 대해 `--ollama` 옵션 사용을 우선적으로 검토합니다.
+- 개발 및 잦은 코드 수정 시 항상 `python3 -m graphify.watch .` 를 백그라운드에 구동시켜 지식 그래프의 최신화를 자동화하는 것을 검토하십시오.

.env.example

@@ -6,5 +6,22 @@ DISCORD_CLIENT_ID=your_client_id_here
 # User/pass from docker-compose.yml
 DATABASE_URL="postgresql://kord:password@localhost:5432/kord_db?schema=public"
 
-## NOTE
-## This project does not use Redis.
+# Logging (log4js — file only under LOG_DIR, no console appender)
+# Levels: trace, debug, info, warn, error, fatal
+LOG_LEVEL=info
+# Log directory (kord.log + dated rotations). Relative = from process cwd; use an absolute path on servers
+# if the deploy directory is wiped (e.g. Jenkins): LOG_DIR=/var/lib/kord/logs
+LOG_DIR=logs
+
+# ----------------------------------------------------
+# E2E Live Testing Configuration (Playwright)
+# ----------------------------------------------------
+# A separate database strictly for Live E2E Testing to prevent overwriting dev data
+TEST_DATABASE_URL="postgresql://kord:password@localhost:5432/kord_test_db?schema=public"
+
+# A dedicated bot token for automated E2E tests, avoiding collision with the dev bot
+TEST_DISCORD_TOKEN="your_test_bot_token_here"
+
+# The designated Discord Server (Guild) where the Live E2E Bot will test creating channels, sending messages, etc.
+TEST_GUILD_ID="your_test_guild_id_here"
+

.turbo/cache/29fcb16557ff68aa-manifest.json

@@ -0,0 +1 @@
+{"files":{"packages/db/.turbo/turbo-generate.log":{"size":401,"mtime_nanos":1776651586075885272,"mode":420,"is_dir":false}},"order":["packages/db/.turbo/turbo-generate.log"]}

.turbo/cache/29fcb16557ff68aa-meta.json

@@ -0,0 +1 @@
+{"hash":"29fcb16557ff68aa","duration":1221,"sha":"855aad274ad148847ffefa8e54eb8fa8066713fa","dirty_hash":"5906811204abfbb072123bc0cbfc794bb506b732c5875205b21f947edcc57687"}

.turbo/cache/63605b2509e03797-meta.json

@@ -0,0 +1 @@
+{"hash":"63605b2509e03797","duration":1834,"sha":"855aad274ad148847ffefa8e54eb8fa8066713fa","dirty_hash":"d0414de747ab562fdf8628ad70f7f928ce881c495f15765d4afcb0621966da17"}

.turbo/cache/acf3ce7b1f0725e0-manifest.json

@@ -0,0 +1 @@
+{"files":{"packages/db/.turbo/turbo-generate.log":{"size":401,"mtime_nanos":1776758349447738118,"mode":420,"is_dir":false}},"order":["packages/db/.turbo/turbo-generate.log"]}

.turbo/cache/acf3ce7b1f0725e0-meta.json

@@ -0,0 +1 @@
+{"hash":"acf3ce7b1f0725e0","duration":973,"sha":"8e03562f82c54396a045cb531584408aebdb976c","dirty_hash":"bc9a3d2593e9616d8817460434cba66b1a00b3efba8cea3092233c3532581f2b"}

.windsurfrules

@@ -16,3 +16,8 @@
 - 유저에게 노출되는 모든 기능(메시지, 임베드, 상태 메시지 등)을 구성할 때는 별도의 요청이 없더라도 **반드시 다국어 지원(i18n) 적용을 검토하고 구현**해야 합니다. (자세한 내용은 `Docs/Rules/i18n_guidelines.md` 참조)
 - 단순 문법 검증에 그치지 말고, `yarn dev` 등의 명령어로 봇을 백그라운드에서 직접 구동(Boot)시켜 DB/캐시 커넥트 및 이벤트 리스너 초기화 중 런타임 에러(예: Intents 권한 거부 등)가 발생하지 않는지 스스로 눈으로 확인하고 완벽히 디버깅해야 합니다.
 - 봇이 성공적으로 온라인 상태(`Ready`)에 진입한 것을 확인한 뒤에만 사용자에게 작업 완료를 보고합니다.
+
+## Graphify Rules
+- 사용자가 `/graphify` 혹은 지식 그래프 관련 질의를 할 경우, `SKILL.md`와 `Docs/Features/Graphify_Setup_Guide.md`의 워크플로우를 참조합니다.
+- 대규모 리팩토링이나 구조 파악이 필요할 때는 `graphify-out/GRAPH_REPORT.md`를 우선적으로 참조하여 의존 관계를 파악합니다.
+- 로컬 모델을 위한 시맨틱 추출이 필요한 경우 `--ollama` 옵션의 활용을 검토하며, 코드 기반 갱신은 `python3 -m graphify.watch .` 를 이용합니다.

CLAUDE.md

@@ -0,0 +1,5 @@
+# graphify
+- **graphify** (`SKILL.md`) - any input to knowledge graph. Trigger: `/graphify`
+When the user types `/graphify`, invoke the Skill tool with `skill: "graphify"` before doing anything else.
+- 프로젝트의 구조 변경이나 문서 갱신시 실시간 업데이트를 원한다면 `python3 -m graphify.watch .` 실행을 추천하세요.
+- Ollama 연동 및 트러블슈팅 설정 등은 `Docs/Features/Graphify_Setup_Guide.md` 문서를 참고하세요.

Docs/Decisions/Dashboard_Architecture_gRPC.md

@@ -0,0 +1,33 @@
+# 결정 사항: 대시보드-봇 통신 아키텍처 (gRPC Proxy)
+
+## 배경 (Context)
+
+대시보드(Next.js)와 멀티 인스턴스 샤딩 환경의 봇 간에 실시간 통신이 필요합니다. 대시보드는 특정 길드의 설정을 변경하거나 채널 목록을 조회해야 하지만, 봇이 여러 프로세스(Shard)로 쪼개져 있어 어떤 인스턴스가 해당 길드를 관리하는지 대시보드가 알기 어려운 문제가 있습니다.
+
+## 결정된 사항 (Decision)
+
+1. **통신 프로토콜**: **gRPC (HTTP/2)** 선택
+   - 강력한 타입 시스템(`packages/grpc-contracts`) 공유를 위해 선택했습니다.
+   - 대량의 데이터 전송 및 실시간 양방향 통신 확장에 유리합니다.
+
+2. **Manager as API Proxy 패턴 채택**
+   - **구조**: Dashboard <-> ShardingManager (gRPC Server) <-> Shards (IPC)
+   - 모든 대시보드 요청은 단 하나의 포트(`50051`)를 가진 `ShardingManager`로 집중됩니다.
+   - 매니저는 `guildId` 등의 키를 확인하여 내부적으로 `broadcastEval` 또는 `IPC`를 통해 해당 Shard에게 업무를 하달합니다.
+
+3. **데이터 보관 전략**: **DB (Prisma) 중심**
+   - 실시간성이 극도로 중요한 요청 외의 설정값 변경은 DB를 우선 업데이트하고, 봇이 이를 캐시 동기화하도록 인터페이스를 구성합니다.
+
+## 장점 (Pros)
+
+- **인프라 간소화**: 봇 인스턴스가 100개로 늘어나도 대시보드 입장에서는 `50051` 포트 하나만 바라보면 됩니다.
+- **포트 충돌 방지**: 각 샤드 워커마다 별도의 서버 포트를 할당할 필요가 없습니다.
+- **코드 공유**: 모노레포 구조를 통해 클라이언트와 서버가 동일한 `.proto` 계약을 공유합니다.
+
+## 단점 (Cons)
+
+- **매니저 오버헤드**: 매니저가 모든 통신을 중계하므로, 통신량이 극도로 많아질 경우 매니저가 병목이 될 수 있습니다. (이 경우 추후 Redis Pub/Sub으로 전환 고려)
+
+## 대안 (Alternatives)
+
+- **Redis Pub/Sub**: 가장 유연하지만 추가 인프라(Redis) 관리가 필요합니다. 현재는 단일 서버 환경이므로 gRPC Proxy가 더 효율적이라고 판단했습니다.

Docs/Features/Graphify_Setup_Guide.md

@@ -0,0 +1,62 @@
+# Graphify Setup & Guide
+
+이 문서는 프로젝트 내 코드 및 문서의 지식 그래프(Knowledge Graph)를 생성하고 유지관리하기 위한 `graphify` 도구의 설치부터 Ollama 모델 연동, 그리고 실시간 자동 갱신(Watch Mode)을 적용하는 과정을 다른 환경에서도 쉽게 따라 할 수 있도록 정리한 가이드입니다.
+
+## 1. Graphify 설치 및 기본 환경 설정
+
+`graphify`는 코드베이스, 문서 등을 분석하여 구조적/시맨틱(의미론적) 연결망을 만들어주는 지식 그래프 도구입니다.
+
+### Python 인터프리터 구성
+- 시스템 전역 파이썬 대신 `venv` 등의 가상 환경에 구성된 파이썬을 이용하는 것을 권장합니다.
+- `graphify` 설치 명령어:
+  ```bash
+  python3 -m pip install graphifyy -q --break-system-packages
+  ```
+- 에이전트(Claude 등)가 일관된 파이썬을 사용할 수 있게 프로젝트 루트에 `.graphify_python` 파일을 생성해 파이썬 경로를 저장합니다.
+  ```bash
+  python3 -c "import sys; open('.graphify_python', 'w').write(sys.executable)"
+  ```
+
+## 2. 로컬 LLM (Ollama) 연동 및 시맨틱 분석
+
+`graphify`는 문서나 코드의 주석 등을 기반으로 추론된 엣지(INFERRED)를 찾을 때 LLM을 사용합니다. 외부 API 대신 로컬 Ollama 모델을 활용하면 토큰 비용을 아낄 수 있습니다.
+
+### Ollama 연결 확인 및 모델 설정
+- 로컬의 `11434` 포트에서 Ollama 데몬이 실행 중인지 확인합니다.
+  ```bash
+  curl -s http://localhost:11434/api/tags > .ollama_tags.json
+  ```
+- 로드된 언어 모델(예: `gemma4:e4b-it-q4_K_M`, `llama3` 등)을 `.ollama_models.json` 캐시로 저장합니다.
+- 이후 그래프 생성 명령 시 `--ollama` 플래그를 붙여 로컬 연동을 지시합니다.
+  ```bash
+  /graphify . --ollama --model gemma4:e4b-it-q4_K_M
+  ```
+
+### 트러블슈팅: f-string 및 패키지 오류 (semantic_llm.py)
+파이썬 버전 또는 패키지 업데이트 상태에 따라 Ollama API를 호출하는 `semantic_llm.py` 내부 로직에서 몇 가지 오류가 발생할 수 있습니다. (에이전트가 실행 시 자동 수정하거나, 수동으로 수정해야 합니다.)
+1. **f-string `{}` 파싱 오류**: `extract_semantic` 프롬프트 내 JSON 예시의 괄호(`{`, `}`)가 f-string의 변수로 인식되어 `ValueError`가 발생할 수 있습니다. JSON 중괄호를 모두 `{{`, `}}`로 더블 이스케이프해야 합니다.
+2. **urllib Request 오류**: `urllib.request.Request` 호출 시 `content_type="application/json"` 인자가 거부될 경우, `headers={"Content-Type": "application/json"}` 형태로 교체해야 합니다.
+
+## 3. 지식 그래프 자동 갱신 설정 (Watch Mode)
+
+개발 과정 중 코드나 문서가 빈번하게수정될 때, 그래프를 백그라운드에서 실시간으로 최신화하는 `watch` 모드를 설정할 수 있습니다. (문서 수정은 수동 업데이트 필요, 코드는 자동 재구성)
+
+### 의존성 설치
+watch 모드는 `watchdog` 라이브러리를 요구합니다.
+```bash
+python3 -m pip install watchdog
+```
+
+### 상태 감시 실행
+터미널을 열어 아래 명령어를 유지합니다:
+```bash
+python3 -m graphify.watch .
+```
+
+- **코드 파일**이 변경된 경우: 백그라운드에서 즉각적으로 AST 추출이 다시 실행되고 `graph.json`과 리포트가 갱신됩니다.
+- **문서 파일**이 변경된 경우: LLM 추론이 필요하므로 `need_update` 플래그만 기록합니다. 이후 에이전트나 사용자가 명시적으로 `/graphify . --update` 를 실행하여 최신화합니다.
+
+## 4. 에이전트 설정(IDE Rules) 연계
+
+- **CLAUDE.md 및 .cursorrules**: AI 에이전트가 `graphify` 관련 요청을 받을 경우 `SKILL.md`를 우선 확인하도록 규칙이 지정되어 있습니다.
+- 백그라운드에서 감지될 수 있도록 에이전트는 "대규모 리팩토링이나 구조 파악 전 `GRAPH_REPORT.md` 검토", "코드 작성 중 `watchdog`에 의한 자동 갱신 확인" 등을 수행합니다.

Docs/Plans/Error_Guidance_Plan.md

@@ -39,7 +39,7 @@
 |----------|-------------|------|------------------|
 | `USER_INPUT` | `E1xxx` | 잘못된 입력값 (범위 초과, 형식 오류 등) | 올바른 입력 예시 안내, 재입력 유도 |
 | `PERMISSION` | `E2xxx` | 봇 또는 사용자 권한 부족 | 필요 권한 안내, 서버 관리자 문의 유도 |
-| `BOT_INTERNAL` | `E3xxx` | 봇 내부 오류 (DB, Redis, 로직 오류) | 잠시 후 재시도 안내, 지속 시 관리자 문의 |
+| `BOT_INTERNAL` | `E3xxx` | 봇 내부 오류 (DB, 로직 오류 등) | 잠시 후 재시도 안내, 지속 시 관리자 문의 |
 | `DISCORD_API` | `E4xxx` | Discord API 오류 (Rate Limit, 서비스 장애 등) | 잠시 후 재시도, Discord 상태 확인 안내 |
 
 ### 주요 에러 코드 예시
@@ -51,7 +51,7 @@ E2001  봇에 Manage Channels 권한 없음
 E2002  사용자에게 관리자 권한 없음
 E2003  채널 소유자만 사용 가능
 E3001  데이터베이스 연결/쿼리 실패
-E3002  캐시(Redis) 연결 실패
+E3002  내부 캐시/상태 계층 오류
 E4001  Discord API Rate Limit
 E4002  Discord API 50013 (Missing Permissions)
 E4003  Discord API 일시적 오류

Docs/Plans/Event_Schedule_Management_Plan.md

@@ -173,11 +173,10 @@ enum EventStatus {
 ### 중복 방지
 
 - 전송 직후 `remindedOneHour`, `remindedTenMinutes` 업데이트
-- 다중 인스턴스 환경에서는 Redis lock 또는 `INSTANCE_ID` 기반 단일 실행 제어 고려
+- 다중 인스턴스 환경에서는 DB advisory lock 또는 `INSTANCE_ID` 기반 단일 실행 제어 고려
 
 > [!NOTE]
-> 현재 프로젝트는 글로벌 커맨드 동기화 시 Redis lock을 사용하므로,
-> 이벤트 리마인더도 같은 방식으로 확장하기 좋습니다.
+> 글로벌 커맨드 등록 등은 애플리케이션 레벨에서 처리하며, 이벤트 리마인더도 유사한 단일 실행 패턴으로 확장할 수 있습니다.
 
 ---
 

Docs/Plans/Fishing_MiniGame_Plan.md

@@ -0,0 +1,410 @@
+# 낚시 미니게임 구현 기획안
+
+이 문서는 Kord의 `낚시(Fishing)` 미니게임 시스템에 대한 설계 방향과 구현 범위를 정리한 기획서입니다.
+
+## 개요
+
+낚시 미니게임은 기존 미니게임 경제 시스템에서 사용할 재화를 공급하는, 실시간 이모지 조작형 미니게임입니다.
+
+사용자는 1초마다 갱신되는 상태 메시지를 보며 입력을 미리 선택하고, 물고기가 특정 위치에 일정 시간 머문 뒤 그 입력이 맞았는지 판정받습니다. 핵심 목표는 물고기를 끌어와 거리를 줄이는 동시에, 낚시줄 끊어짐 게이지가 가득 차지 않도록 관리하는 것입니다.
+
+이 게임은 단순 슬래시 명령 기반이 아니라, 버튼 조작과 실시간 게이지 변화, 물고기 이모지 표시를 통해 더 직접적인 조작감을 주는 것을 목표로 합니다.
+
+## 핵심 게임 루프
+
+### 1. 스레드 입장과 세션 시작
+
+- 사용자는 먼저 `/fishing enter` 명령으로 낚시 전용 스레드에 입장합니다.
+- 봇은 명령을 실행한 채널에 `UserName's Fishing Spot` 형식의 전용 스레드를 생성합니다.
+- 이미 같은 사용자의 낚시 스레드가 있으면 기존 스레드를 재사용합니다.
+- 실제 낚시 세션 시작은 전용 스레드 안에서 `/fishing cast`를 입력했을 때만 가능합니다.
+- 즉, 스레드 생성과 게임 시작은 별도 단계로 분리합니다.
+- 봇은 실시간 게임 메시지를 생성합니다.
+- 메시지에는 다음 요소가 포함됩니다.
+- 중앙에 표시되는 물고기 이모지
+- 거리 게이지
+- 낚시줄 끊어짐 게이지
+- 네 개의 조작 버튼
+- 현재 라운드에 예약된 입력
+- 다음 판정까지 남은 시간
+
+### 1-1. 전용 스레드 규칙
+
+- 스레드 이름은 영문 기준 `UserName's Fishing Spot` 형식을 사용합니다.
+- 낚시 게임 메시지, 버튼 입력, 결과 메시지는 모두 해당 스레드 안에서만 처리합니다.
+- 이렇게 하면 일반 채팅이 밀려도 낚시 UI가 섞이지 않고 유지됩니다.
+- 한 사용자는 동시에 하나의 낚시 스레드만 활성화할 수 있습니다.
+- `/fishing cast`는 자신의 낚시 스레드 안에서만 사용할 수 있습니다.
+- 성공이나 실패로 게임이 끝나더라도 스레드는 즉시 삭제하지 않습니다.
+- 같은 스레드 안에서 다시 `/fishing cast`를 입력해 연속 플레이할 수 있어야 합니다.
+- `/fishing end`를 실행했을 때만 세션을 정리하고 스레드를 삭제합니다.
+
+### 2. 조작 버튼
+
+사용자는 아래 네 가지 버튼 중 하나를 선택할 수 있습니다.
+
+- `⬅️` 왼쪽
+- `⏺️` 중앙
+- `➡️` 오른쪽
+- `🛌` 휴식
+
+### 3. 물고기 위치
+
+- 물고기는 텍스트가 아니라 이모지로 표시됩니다.
+- 물고기 이모지는 메시지의 시각적 중앙 라인에 위치해야 합니다.
+- 내부 상태상 물고기 위치는 왼쪽, 중앙, 오른쪽 중 하나를 가집니다.
+- 물고기는 한 라운드 동안 같은 위치에 일정 시간 머뭅니다.
+- 사용자는 그 라운드 안에서 방향 버튼을 미리 입력합니다.
+- 물고기가 해당 위치에 일정 시간 이상 머문 뒤 입력이 일치하면 성공 판정이 납니다.
+- 입력이 없거나 다른 방향이면 `타이밍 빗나감`으로 처리됩니다.
+
+### 4. 거리 게이지
+
+- 물고기를 얼마나 더 끌어와야 하는지를 나타내는 게이지입니다.
+- 시작값은 `100` 같은 양수로 설정합니다.
+- 방향을 맞춘 입력이 성공 판정되면 거리가 감소합니다.
+- 휴식을 선택하면 거리가 다시 증가합니다.
+- 거리가 `0`이 되면 낚시에 성공합니다.
+
+### 5. 낚시줄 끊어짐 게이지
+
+- 낚시줄이 얼마나 끊어질 위기에 가까운지를 나타내는 게이지입니다.
+- 방향을 맞춘 입력이 성공 판정되면 이 게이지가 증가합니다.
+- 타이밍을 놓치면 소량 증가합니다.
+- 휴식을 선택하면 이 게이지가 회복됩니다.
+- 게이지가 최대치에 도달하면 즉시 낚시에 실패합니다.
+
+### 6. 휴식 행동
+
+- `🛌` 휴식은 해당 라운드에서 즉시 적용됩니다.
+- 낚시줄 끊어짐 게이지를 회복합니다.
+- 대신 물고기와의 거리가 다시 증가합니다.
+- 즉, 휴식은 실패 위험을 낮추지만 진행도를 되돌리는 안전 선택지입니다.
+
+### 7. 틱 업데이트
+
+- 낚시 상태는 1초마다 갱신됩니다.
+- 메시지도 1초 주기로 갱신됩니다.
+- 이 갱신 루프는 아래 요소를 처리합니다.
+- 현재 라운드 경과 시간 계산
+- 입력 예약 상태 반영
+- 성공 / 타이밍 빗나감 판정
+- 다음 물고기 위치로 라운드 전환
+- 게이지 렌더링 갱신
+- 세션 종료 판정
+
+## UI / UX 요구사항
+
+### 실시간 메시지 구성
+
+낚시 메시지는 최소한 아래 요소를 포함해야 합니다.
+
+- 물고기 이모지로 표시되는 현재 위치
+- 거리 게이지
+- 낚시줄 끊어짐 게이지
+- 간단한 상태 텍스트
+- 현재 예약 입력
+- 다음 판정까지 남은 시간
+- 예: `입질 중`, `타이밍 빗나감`, `휴식 중`, `성공`, `실패`
+
+### 게이지 디자인
+
+항상 아래 두 개의 게이지가 동시에 보여야 합니다.
+
+1. 거리 게이지
+- 성공을 향해 감소하는 게이지
+- 휴식 시 다시 증가할 수 있음
+- 채워진 블록 / 빈 블록 형태로 표현 가능
+
+2. 낚시줄 끊어짐 게이지
+- 실패를 향해 증가하는 게이지
+- 거리 게이지와 시각적으로 구분되어야 함
+
+예시:
+
+```text
+위치:           ⬅️   🐟   ➡️
+입력:           ⏺️
+남은 시간:      2s
+거리:           ████████░░  20 / 100
+끊어짐:         ████░░░░░░  40 / 100
+```
+
+최종 렌더링은 더 다듬을 수 있지만, 핵심은 물고기 자체를 반드시 이모지로 유지하는 것입니다.
+
+### 조작 버튼
+
+버튼은 직관적이고 빠르게 눌릴 수 있어야 하므로, 이모지 중심으로 구성합니다.
+
+- `⬅️`
+- `⏺️`
+- `➡️`
+- `🛌`
+
+## 성공 / 실패 조건
+
+### 성공
+
+- 거리 게이지가 `0`이 됩니다.
+- 보상을 지급합니다.
+- 세션을 종료하고 버튼을 비활성화합니다.
+
+### 실패
+
+- 낚시줄 끊어짐 게이지가 최대치에 도달합니다.
+- 세션을 종료하고 버튼을 비활성화합니다.
+
+### 선택적 시간 제한
+
+- 일정 시간 동안 행동하지 않으면 실패하도록 설계할 수도 있습니다.
+- 다만 이 기능은 MVP에는 필수가 아니며, 템포가 느릴 때만 후속 단계에서 검토합니다.
+
+### 종료 명령
+
+- `/fishing end` 명령을 제공해 사용자가 직접 낚시 스레드를 종료할 수 있어야 합니다.
+- 종료 명령이 실행되면 진행 중인 낚시 세션이 있다면 즉시 정리됩니다.
+- 전용 스레드는 `/fishing end`에서만 삭제됩니다.
+- 성공/실패 후에는 버튼만 비활성화하고 스레드는 유지합니다.
+- 사용자는 같은 스레드 안에서 다시 `/fishing cast`를 입력해 새 게임을 시작할 수 있어야 합니다.
+
+## 경제 시스템 연동
+
+낚시는 기존 미니게임 경제를 보조하는 수단으로 설계합니다.
+
+### 권장 보상 모델
+
+- 낚시에 성공하면 `gold`를 지급합니다.
+- 지급된 `gold`는 현재 `refinement` 게임이 사용하는 경제 프로필에 반영합니다.
+- 이렇게 하면 낚시는 정련 게임을 보조하는 재화 수급형 미니게임이 됩니다.
+
+### 확장 가능성
+
+후속 버전에서는 아래 요소를 추가할 수 있습니다.
+
+- 물고기 희귀도
+- 물고기 크기(cm) 시스템
+- 개별 물고기 인벤토리
+- 물고기 도감 / 컬렉션
+- 미끼 종류
+- 낚싯대 및 업그레이드
+- 물고기 판매 시스템
+
+Phase 1에서는 직접 `gold`를 주는 방식이 가장 단순하고 호환성이 좋습니다.
+
+## 설정 모델
+
+낚시는 공용 미니게임 레지스트리에 등록되는 구조로 가야 합니다.
+
+### MiniGame Registry
+
+추가할 키:
+
+- `fishing`
+
+이를 통해 다음이 가능해집니다.
+
+- 길드별 활성화 / 비활성화
+- 전용 채널 제한
+- `/minigame`을 통한 상태 조회
+
+낚시의 경우 전용 채널 안에서 다시 개별 스레드를 생성하는 방식으로 운영합니다.
+
+## 기술 구조
+
+### 서비스
+
+권장 신규 서비스:
+
+- `FishingService`
+
+주요 책임:
+
+- 낚시 전용 스레드 생성 / 삭제
+- 세션 생성 / 종료
+- 사용자별 활성 낚시 세션 추적
+- 틱 업데이트 루프 관리
+- 물고기 위치 생성
+- 입력 예약 및 라운드 판정
+- 보상 정산
+
+### 인터랙션 처리
+
+권장 커스텀 ID prefix:
+
+- `fishing_`
+
+기존 구조와 일관성을 유지합니다.
+
+- `music_`
+- `refine_`
+
+### 영속 데이터
+
+권장 초기 모델:
+
+- `FishingProfile`
+- `userId`
+- `guildId`
+- `totalCatchCount`
+- `successCount`
+- `failCount`
+- `bestCatchReward`
+- `lastCastAt`
+- `createdAt`
+- `updatedAt`
+
+이 정도면 초반 통계 추적에 충분하고, 너무 이르게 인벤토리를 과설계하지 않을 수 있습니다.
+
+도감/크기 확장 시에는 아래 모델을 추가합니다.
+
+- `FishingCollectionEntry`
+- `userId`
+- `guildId`
+- `fishId`
+- `catchCount`
+- `bestRarity`
+- `bestSizeCm`
+- `lastCaughtAt`
+- `createdAt`
+- `updatedAt`
+
+이 모델은 유저가 어떤 물고기를 몇 번 잡았는지, 최고 레어도와 최고 크기가 무엇인지 추적하는 데 사용합니다.
+
+### 물고기 크기 시스템
+
+- 낚시 성공 시 물고기마다 `cm` 단위의 크기를 부여합니다.
+- 기본 크기 범위는 물고기별 데이터에서 관리합니다.
+- 최종 크기는 `물고기 기본 크기 범위 × 레어도 보정치`로 계산합니다.
+- 즉, 같은 물고기라도 레어도가 높을수록 더 큰 개체가 등장할 수 있습니다.
+- 성공 결과 메시지에는 잡은 물고기의 크기를 함께 표시합니다.
+- 도감에는 해당 물고기의 최고 크기를 기록합니다.
+
+### 도감 (Dex / Collection)
+
+- `/fishing dex` 명령을 통해 개인 도감을 조회할 수 있어야 합니다.
+- 도감에는 아래 정보를 보여줍니다.
+- 잡아본 물고기 목록
+- 각 물고기의 포획 횟수
+- 최고 레어도
+- 최고 크기(cm)
+- 마지막 포획 시각
+- 아직 잡지 못한 물고기는 후속 버전에서 실루엣/잠금 상태로 표시할 수 있습니다.
+
+### 세션 모델
+
+낚시 플레이 자체는 즉각적인 반응을 위해 메모리 세션 기반이 적합합니다.
+
+권장 런타임 필드:
+
+- `guildId`
+- `userId`
+- `threadId`
+- `messageId`
+- `fishPosition`
+- `selectedAction`
+- `phaseStartedAt`
+- `distance`
+- `lineTension`
+- `tickInterval`
+- `expiresAt`
+
+## 입력 판정 규칙
+
+권장 MVP 규칙은 아래와 같습니다.
+
+- 각 라운드마다 물고기는 하나의 위치에 일정 시간 머뭅니다.
+- 플레이어는 그 라운드에서 방향 입력을 미리 예약합니다.
+- 물고기가 해당 위치에 `특정 시간 이상` 머문 시점에 입력이 일치하면
+- 거리 감소
+- 낚시줄 끊어짐 게이지 증가
+- 성공 판정 후 다음 라운드로 이동
+- 라운드 시간이 끝날 때까지 올바른 입력이 없으면
+- `타이밍 빗나감`
+- 거리 감소 없음
+- 소량의 끊어짐 증가
+- 휴식을 선택하면
+- 낚시줄 끊어짐 게이지 감소
+- 대신 거리 증가
+- 휴식 적용 후 즉시 다음 라운드로 이동
+
+이 구조는 다음 긴장감을 만듭니다.
+
+- 방향을 잘 예약해 두면 안정적으로 거리 감소를 만들 수 있음
+- 너무 공격적으로 당기면 줄이 끊어질 위험이 커짐
+- 휴식은 실패를 막아주지만 물고기가 다시 멀어짐
+
+## 단계별 계획
+
+### Phase 1
+
+- `fishing`을 미니게임 레지스트리에 등록
+- `/fishing enter` 추가
+- `/fishing cast` 추가
+- `/fishing end` 추가
+- `/fishing enter` 실행 시 `UserName's Fishing Spot` 스레드 생성
+- `/fishing cast`는 전용 스레드 안에서만 허용
+- 메모리 기반 낚시 세션 루프 구현
+- 1초 주기 메시지 갱신
+- 입력 예약형 라운드 판정 구현
+- 두 개의 게이지 표시
+- 네 개의 이모지 조작 버튼 추가
+- 성공 시 `gold` 지급
+- 성공/실패 후 스레드 유지
+- `/fishing end` 실행 시 스레드 삭제
+
+### Phase 2
+
+- `/fishing status` 추가
+- `/fishing ranking` 추가
+- 사용자별 낚시 통계 추가
+- 낚시 프로필 영속화
+- 물고기 이동 패턴 개선
+- 보상 밸런스 조정
+- `/fishing dex` 추가
+- 물고기 크기(cm) 시스템 추가
+- 도감용 포획 기록 저장
+- 길드 내 최고 크기 기준 Top 10 랭킹 표시
+
+### Phase 3
+
+- 희귀도 체계 추가
+- 인벤토리 / 도감 고도화
+- 미끼 / 낚싯대 보정치 추가
+- 리더보드 지원
+- 미포획 물고기 잠금/실루엣 UI 추가
+
+## 검증 / 테스트
+
+### 수동 테스트 시나리오
+
+1. 허용된 채널에서 `/fishing enter` 실행
+2. `UserName's Fishing Spot` 스레드가 자동 생성되는지 확인
+3. 자신의 낚시 스레드 밖에서는 `/fishing cast`가 거부되는지 확인
+4. 낚시 관련 메시지가 스레드 안에서만 진행되는지 확인
+5. 실시간 메시지에 물고기 이모지와 두 개의 게이지가 보이는지 확인
+6. 방향 버튼을 미리 눌러 예약 입력이 반영되는지 확인
+7. 일정 시간 뒤 방향이 맞았을 때 거리 감소가 적용되는지 확인
+8. 타이밍을 놓치면 `타이밍 빗나감`으로 처리되는지 확인
+9. 휴식을 눌렀을 때 끊어짐 게이지가 회복되고 거리가 증가하는지 확인
+10. 거리 `0` 도달 시 성공 처리되는지 확인
+11. 끊어짐 게이지 최대 도달 시 실패 처리되는지 확인
+12. 세션 종료 후 버튼이 비활성화되고 스레드는 유지되는지 확인
+13. 같은 스레드 안에서 다시 `/fishing cast`가 가능한지 확인
+14. `/fishing end` 실행 시 스레드가 자동 삭제되는지 확인
+15. 보상이 정상 지급되는지 확인
+16. `/minigame` 설정 기반 채널 제한이 적용되는지 확인
+
+### 엣지 케이스
+
+- 같은 사용자가 중복으로 세션 시작
+- 스레드 삭제 권한이 없을 때 종료 처리
+- 세션 종료 후 오래된 버튼 클릭
+- 낚시 세션 중 봇 재시작
+- 인터랙션 응답 지연
+- 1초 주기 메시지 갱신 시 Discord rate limit 영향
+
+## 참고 사항
+
+- 1초 갱신 루프는 이 게임의 손맛을 좌우하므로 메시지 갱신 성능을 꼭 확인해야 합니다.
+- Discord 메시지는 게임 엔진이 아니므로, 순간 반응보다는 명확한 판정 윈도우가 더 중요합니다.
+- 최종 설계는 화려함보다 반응성, 명확성, 실패 상태의 가독성을 우선해야 합니다.

Docs/Plans/Setup_Wizard_Plan.md

@@ -71,7 +71,7 @@
 - **State Management (상태 관리)**:
   - 마법사는 ephemeral 메시지로 띄워지며, 세션 식별은 `customId` 릴레이 방식을 권장합니다.
   - 예시: `setup_action_next_2` (현재 Step 2, 다음으로 이동) 등 Stateless하게 관리하거나,
-  - 사용자/서버별 임시 Map/Redis에 `SetupSession` (진행 단계 등) 보관. (구현 편의상 `customId` payload에 스텝 인덱스를 담는 Stateless 방식 채택)
+  - 사용자/서버별 임시 Map 등에 `SetupSession` (진행 단계 등) 보관. (구현 편의상 `customId` payload에 스텝 인덱스를 담는 Stateless 방식 채택)
 - **i18n 통합**:
   - 버튼 레이블 및 Embed 내용은 모두 `t()` 함수를 거쳐야 합니다.
   - Step 1에서 언어가 변경되면, 즉시 그 언어 기준의 `t()`를 이용해 현재 뷰(View)를 갱신합니다.

Docs/Project_Structure.md

@@ -0,0 +1,44 @@
+# 프로젝트 구조 (Project Structure)
+
+본 문서는 Kord 프로젝트의 주요 디렉터리와 아키텍처 구조를 설명합니다.
+
+## 디렉터리 안내
+
+### `src/` - 주요 소스 코드
+
+본 봇의 모든 핵심 비즈니스 로직과 시스템 코드가 위치합니다.
+
+- **`client/`**: `KordClient` 등 디스코드 봇 클라이언트 초기화 및 상태를 관리합니다.
+- **`commands/`**: 디스코드 슬래시 명령어의 로직이 위치합니다.
+- **`core/`**: 어플리케이션의 핵심 인프라 구성을 담당합니다. (`db.ts`, `command.ts` 기반 베이스 클래스 등)
+- **`config/`**: 봇 구동 환경 및 전역 설정 관련 파일입니다.
+- **`events/`** & **`handlers/`**: 디스코드 이벤트(messageCreate, interactionCreate 등)의 처리 및 바인딩을 담당합니다.
+- **`i18n/`**: 다국어(한국어, 영어 등) 지원을 위한 로케일 데이터 및 번역 함수를 관리합니다.
+- **`interactions/`**: 버튼, 셀렉트 메뉴, 모달 등 컴포넌트 상호작용 로직입니다.
+- **`service/`** / **`services/`**: 각 도메인 별 비즈니스 로직 및 Prisma DB 읽기/쓰기 작업을 추상화한 서비스 계층입니다. (e.g. `FishingService`, `RefinementService`)
+- **`utils/`**: 공통으로 사용되는 유틸리티 및 헬퍼 함수들입니다.
+
+### `resource/` - 에셋 및 데이터 리소스
+
+- 미니게임 아트웍(낚시 물고기 이미지, 무기 이미지 등) 및 정적 JSON 데이터(카탈로그, 확률표 등)를 보관합니다.
+
+### `prisma/` - 데이터베이스 관리
+
+- **`schema.prisma`**: PostgreSQL 데이터베이스의 스키마 명세입니다.
+- **`migrations/`**: Prisma Migrate에 의해 자동 생성된 마이그레이션 이력입니다.
+- **`seed.ts`**: 초기 데이터베이스 시딩을 위한 스크립트입니다.
+
+### `Docs/` - 공식 문서
+
+기능 명세, 트러블슈팅, 작업 내역, 데이터베이스 스키마 및 규칙 등 관리용 문서를 포함합니다. [`Docs/index.md`](index.md)를 중심으로 카테고리가 분류되어 있습니다.
+
+### `tests/` - 테스트 코드
+
+Jest 프레임워크를 기반으로 한 단위 테스트(Unit Test) 로직이 위치합니다. 주 도메인이나 `core`, `services` 코드에 대한 검증을 수행합니다.
+
+---
+
+## 향후 모놀리식 분리 (Modular Architecture) 진행 사항
+
+최근 프로젝트 구조는 단일 스키마 구조에서 도메인/모듈 별로 패키지를 분리하기 위한 기초 작업이 진행되었습니다.
+루트 디렉터리에 위치한 `schema_base.prisma`, `schema_feature.prisma`, `schema_main.prisma` 및 `package_feature.json`, `package_main.json` 파일들은 향후 핵심(Core/Base) 로직과 기능(Feature) 모듈을 독립적으로 빌드/관리하기 위해 도입될 예정(Work-in-Progress)입니다.

Docs/Rules/security_guidelines.md

@@ -13,7 +13,7 @@
 #### 절대 금지 대상 예시:
 - 디스코드 봇 토큰 (Discord Bot Tokens)
 - 데이터베이스 비밀번호 및 접속 주소 (e.g. `postgresql://user:password@host/db`)
-- Redis 비밀번호, API 인증 키(Keys), 비밀 암호 해시, 사내용 중요 자격증명 리스트
+- 외부 서비스 비밀번호, API 인증 키(Keys), 비밀 암호 해시, 사내용 중요 자격증명 리스트
 
 #### 올바른 해결 방법
 1. **환경 변수 파일 (`.env`) 사용**:

Docs/WorkDone/2026-03-27_Project_Initial_Setup.md

@@ -7,7 +7,7 @@
 ### 1. 기술 스택 확정 및 초기화
 - **언어 및 런타임**: Node.js, TypeScript
 - **프레임워크**: discord.js (v14+)
-- **데이터베이스**: Prisma (PostgreSQL) + Redis (캐싱 및 동기화)
+- **데이터베이스**: Prisma (PostgreSQL)
 - **빌드 도구**: ts-node, tsx, tsc
 
 ### 2. 프로젝트 기본 구조 설계

Docs/WorkDone/2026-03-27_Voice_Channels_Implementation.md

@@ -38,6 +38,6 @@
 - **퇴장 시 채널 미삭제 및 유령 방 버그**:
   - *문제*: 채널 내에 음악봇 등 봇만 남았을 때 삭제 조건이 작동하지 않고, 권한 문제로 삭제가 실패했을 때 DB 무결성이 깨지는 버그.
   - *해결*: 휴먼 카운트(`humanCount`) 도입 및 삭제 롤백 검증 처리. 자세한 사항은 [handleLeave_ghost_channel.md](../Troubleshooting/handleLeave_ghost_channel.md) 참조.
-- **멀티 인스턴스 대응 및 봇 재부팅 복구 (Boot Recovery)**:
-  - *사유*: 봇 재시작, 크래시, 혹은 다중 노드(Multi-Instance) 환경에서 DB와 디스코드 실제 채널 상태가 어긋나게 될 경우를 방지.
-  - *해결*: `ioredis` 분산 락(Distributed Lock)과 결합된 `VoiceService.syncChannels` 메서드를 구현하여, 부팅 시 딱 하나의 인스턴스만 DB를 훑으며 삭제되어야 할 유령 방들을 크로스체크 및 안전하게 청소(Garbage Collection)하도록 반영.
+- **봇 재부팅 복구 (Boot Recovery)**:
+  - *사유*: 봇 재시작·크래시 등으로 DB와 디스코드 실제 채널 상태가 어긋나게 될 경우를 방지.
+  - *해결*: `VoiceService.syncChannels`로 부팅 시 DB를 기준으로 유령 방을 크로스체크 및 청소(Garbage Collection)하도록 반영. (다중 인스턴스 동시 실행 시 동일 작업이 겹칠 수 있으나 작업은 멱등에 가깝게 설계됨.)

Docs/WorkDone/2026-03-31_Fishing_MiniGame_Phase1_Completion.md

@@ -0,0 +1,64 @@
+# 2026-03-31 낚시 미니게임 Phase 1 완료
+
+## 개요
+
+낚시 미니게임의 Phase 1 범위를 완료했습니다. 이번 완료 단계에서는 전용 스레드 기반 플레이 흐름, 입력 예약형 판정, 물고기 데이터 기반 난이도/보상 시스템, 성공 시 아트 리소스 출력까지 포함해 실제 플레이 가능한 MVP를 마무리했습니다.
+
+## 완료 범위
+
+- `/fishing enter`, `/fishing cast`, `/fishing end` 명령 흐름 확정
+- `UserName's Fishing Spot` 형식의 전용 스레드 생성 및 재사용
+- 낚시 스레드 안에서만 `/fishing cast` 가능하도록 제한
+- 사용자당 1개 활성 낚시 세션 유지
+- `⬅️`, `⏺️`, `➡️`, `🛌` 이모지 버튼 조작
+- 거리 게이지 / 끊어짐 게이지 렌더링
+- 입력 예약형 판정 구조 적용
+- 휴식 시 끊어짐 회복 + 거리 증가 규칙 반영
+- 성공/실패 후 스레드 유지, `/fishing end`에서만 삭제되도록 흐름 개선
+- `resource/data/fishing/fish_catalog.json` 기반 물고기 데이터 연결
+- 물고기별 출현 확률, 골드 범위, 반응 시간, 위치 약점, 아트 경로 적용
+- 성공 시 물고기 PNG 첨부 및 결과 메시지 전송
+- 대상 물고기와 상세 판정 시간은 플레이 중 UI에서 비공개 처리
+- 메시지 갱신 빈도 축소 및 판정 유예 시간 추가로 반응성 개선
+
+## 주요 파일
+
+- `src/commands/fishing.ts`
+- `src/services/FishingService.ts`
+- `src/events/interactionCreate.ts`
+- `src/services/MiniGameRegistry.ts`
+- `src/services/RefinementService.ts`
+- `src/i18n/types.ts`
+- `src/i18n/locales/en.ts`
+- `src/i18n/locales/ko.ts`
+- `resource/data/fishing/fish_catalog.json`
+- `resource/art/fishing/*`
+- `tests/services/FishingService.test.ts`
+
+## 플레이 흐름
+
+1. 사용자가 허용된 텍스트 채널에서 `/fishing enter`
+2. 봇이 낚시 전용 스레드를 생성하거나 기존 스레드를 재사용
+3. 사용자가 자신의 낚시 스레드 안에서 `/fishing cast`
+4. 버튼 입력으로 거리와 끊어짐 게이지를 관리
+5. 성공 시 물고기 결과 메시지와 PNG 출력, 골드 지급
+6. 같은 스레드에서 다시 `/fishing cast`로 재도전 가능
+7. `/fishing end`로 스레드 종료 및 삭제
+
+## 밸런스 / UX 정리
+
+- 라운드 길이와 반응 시간은 Discord 버튼 지연을 고려해 완화했습니다.
+- 세션 틱은 더 촘촘하게 돌리되, 메시지 수정은 필요한 시점에만 수행하도록 조정했습니다.
+- 반복 플레이 피로를 줄이기 위해 물고기별 위치 약점과 거리 감소량은 JSON 데이터 기반 랜덤 범위를 사용합니다.
+
+## 검증
+
+- `yarn build`
+- `yarn test --runInBand`
+
+두 명령 모두 정상 통과했습니다.
+
+## 비고
+
+- 낚시 세션은 메모리 기반이므로 봇 재시작 시 유지되지 않습니다.
+- Phase 2에서는 통계 조회, 프로필 영속화, 도감/인벤토리 같은 확장 기능을 고려할 수 있습니다.

Docs/WorkDone/2026-03-31_Fishing_MiniGame_Phase1_Implementation.md

@@ -0,0 +1,44 @@
+# 2026-03-31 낚시 미니게임 Phase 1 구현
+
+## 개요
+
+낚시 미니게임의 1차 구현을 추가했습니다. 이번 단계에서는 전용 스레드 기반 세션, 실시간 버튼 조작, 거리/끊어짐 게이지, 성공 시 골드 지급, 종료 시 스레드 정리까지 MVP 범위를 구현했습니다.
+
+## 구현 내용
+
+- `fishing` 미니게임을 공용 미니게임 레지스트리에 등록
+- `/fishing cast` 명령 추가
+- `/fishing end` 명령 추가
+- 낚시 시작 시 `UserName's Fishing Spot` 형식의 전용 스레드 생성
+- 사용자당 1개 세션만 허용하는 메모리 기반 세션 관리 추가
+- `⬅️`, `⏺️`, `➡️`, `🛌` 버튼 조작 추가
+- 1초 주기 상태 갱신 루프 추가
+- 거리 게이지와 끊어짐 게이지 렌더링 추가
+- 중앙 라인에 물고기 이모지 위치 표시 추가
+- 방향 일치 시 거리 감소 및 끊어짐 게이지 증가 로직 구현
+- 휴식 선택 시 끊어짐 게이지 회복 로직 구현
+- 성공 시 `RefinementProfile.gold` 기준 골드 지급 연동
+- 성공/실패/강제 종료 시 버튼 비활성화 및 스레드 자동 정리 추가
+
+## 주요 파일
+
+- `src/commands/fishing.ts`
+- `src/services/FishingService.ts`
+- `src/events/interactionCreate.ts`
+- `src/services/MiniGameRegistry.ts`
+- `src/services/RefinementService.ts`
+- `src/i18n/types.ts`
+- `src/i18n/locales/en.ts`
+- `src/i18n/locales/ko.ts`
+- `tests/services/FishingService.test.ts`
+
+## 검증
+
+- `tsc`
+- `jest tests/services/FishingService.test.ts --runInBand`
+
+## 비고
+
+- Prisma Client는 최신 스키마 기준으로 다시 생성해 타입을 맞췄습니다.
+- `ko.ts`에 존재하던 일부 깨진 문자열은 빌드를 막는 구간 위주로 우선 복구했습니다.
+- 세션은 메모리 기반이므로 봇 재시작 시 진행 중 낚시 세션은 유지되지 않습니다.

Docs/WorkDone/2026-04-07_Fishing_Dex_And_Size_Implementation.md

@@ -0,0 +1,29 @@
+# 2026-04-07 Fishing Dex and Size Implementation
+
+## 요약
+
+낚시 미니게임에 물고기 크기(`cm`) 시스템과 도감(`/fishing dex`) 기능을 추가했다.
+
+## 구현 내용
+
+- 물고기별 기본 크기 범위를 `fish_catalog.json`에 추가
+- 레어도별 크기 보정치를 `fish_rarities.json`에 추가
+- 낚시 성공 시 최종 물고기 크기를 계산하여 결과 메시지에 표시
+- `FishingCollectionEntry` 모델 추가
+  - 물고기별 포획 수
+  - 최고 레어도
+  - 최고 크기
+  - 마지막 포획 시각
+- `/fishing dex` 서브커맨드 추가
+  - 유저별 물고기 도감 조회
+  - 포획 수, 최고 레어도, 최고 크기 표시
+- 성공 결과 메시지에 크기 필드 추가
+
+## 검증
+
+- `yarn prisma generate`
+- `yarn build`
+- `yarn test --runInBand`
+- `yarn prisma migrate deploy`
+
+모든 단계가 정상 통과했다.

Docs/WorkDone/2026-04-07_Fishing_MiniGame_Phase2_Implementation.md

@@ -0,0 +1,39 @@
+# 2026-04-07 Fishing Mini-Game Phase 2 Implementation
+
+## 요약
+
+낚시 미니게임의 Phase 2로 `FishingProfile` 기반 통계 영속화와 `/fishing status` 조회 기능을 추가했다.
+
+## 구현 내용
+
+- `FishingProfile` Prisma 모델 추가
+  - `userId`, `guildId` 복합 키
+  - 총 시도 수, 성공/실패 수
+  - 누적 획득 골드
+  - 최고 보상
+  - 레어도별 포획 수
+  - 마지막 낚시 시각
+- `FishingService`에 프로필 저장 로직 추가
+  - 성공 시 보상과 레어도별 포획 수 누적
+  - 실패 시 실패 횟수 누적
+  - 모든 세션 종료 시 총 시도 수와 마지막 낚시 시각 갱신
+- `/fishing status` 서브커맨드 추가
+  - 본인 또는 지정 유저의 낚시 통계 조회
+  - 총 시도, 성공률, 누적 골드, 최고 보상, 마지막 낚시 시각 표시
+  - 레어도별 포획 수를 별도 필드로 표시
+- 낚시 i18n 문자열 추가
+  - 통계 Embed 제목/필드명/빈 기록 메시지
+
+## 검증
+
+- `yarn prisma generate`
+- `yarn prisma migrate deploy`
+- `yarn build`
+- `yarn test --runInBand`
+
+모든 단계가 정상 통과했다.
+
+## 비고
+
+- `FishingProfile`은 현재 낚시 진행 통계 전용 모델이다.
+- 이후 랭킹, 도감, 업적, 장비 시스템은 이 프로필을 기반으로 확장할 수 있다.

Docs/WorkDone/2026-04-07_Fishing_Size_Ranking_Implementation.md

@@ -0,0 +1,26 @@
+# 2026-04-07: 낚시 크기 랭킹 구현
+
+## 개요
+
+낚시 시스템에 `/fishing ranking` 명령을 추가해, 서버 내 최고 물고기 크기 기록 상위 10개를 조회할 수 있도록 구현했습니다.
+
+랭킹은 `FishingCollectionEntry`에 저장된 각 유저의 물고기별 최고 크기 기록을 기준으로 정렬하며, 각 항목에는 아래 정보가 포함됩니다.
+
+- 유저
+- 물고기 종류
+- 최고 레어도
+- 최고 크기(cm)
+
+## 구현 내용
+
+- `/fishing ranking` 서브커맨드 추가
+- 길드 기준 최고 크기 기록 Top 10 조회 서비스 추가
+- 같은 크기일 경우 최고 레어도, 포획 횟수 순으로 정렬
+- 랭킹이 비어 있을 때의 안내 메시지 추가
+- 낚시 기획서에 랭킹 항목 반영
+
+## 사용자 확인 포인트
+
+- `/fishing ranking` 실행 시 서버 기준 상위 10개 기록이 표시되는지
+- 각 항목에 유저, 물고기, 레어도, 크기가 함께 보이는지
+- 기록이 없는 서버에서는 빈 상태 안내가 표시되는지

Docs/WorkDone/2026-04-20_Monorepo_Migration_And_gRPC_Test.md

@@ -0,0 +1,32 @@
+# 2026-04-20: 모노레포 전환 및 gRPC 통신 테스트 완료 (Monorepo & gRPC Test)
+
+대시보드 도입을 위한 프로젝트 구조 개편과 봇-대시보드 간의 실시간 통신 인프라를 구축하고 검증하였습니다.
+
+## 작업 내용 (Work Done)
+
+### 1. 프로젝트 모노레포(Monorepo) 화
+- **Turborepo & Yarn Workspaces** 도입: 프로젝트를 모듈화하여 관리하기 위해 모노레포 구조로 전환했습니다.
+  - `apps/bot`: 기존 디스코드 봇 로직 이관.
+  - `apps/dashboard`: Next.js 기반 웹 대시보드 신규 생성.
+  - `packages/db`: Prisma 스키마 및 DB 접근 로직을 공용 패키지로 분리.
+  - `packages/grpc-contracts`: gRPC 프로토콜 버퍼와 인터페이스 정의를 위한 공용 패키지 생성.
+
+### 2. 봇 샤딩 및 상태 관리 고도화
+- **ShardingManager 도입**: 봇 프로세스를 분할 관리하고 gRPC 서버를 부착하기 위해 최상위 매니저 레이어를 추가했습니다.
+- **ShardStatus 추적**: 각 Shard가 실행될 때 자신의 상태와 담당 길드 정보를 DB(`ShardStatus` 테이블)에 기록하도록 구현했습니다.
+
+### 3. gRPC 통신 프록시 서버 구축
+- **단일 포트 gRPC 서버**: `ShardingManager` 단에서 `50051` 포트로 gRPC 서버를 실행합니다.
+- **메시지 라우팅**: 대시보드로부터 요청이 들어오면 매니저가 `broadcastEval`을 통해 해당 길드를 담당하는 하위 Shard 프로세스로 요청을 전달(Proxy)합니다.
+
+### 4. 대시보드 gRPC 통신 테스트 완료
+- **테스트 환경 구성**: Next.js API Route를 통해 봇에게 `Ping`을 쏘고 `Pong` 응답을 받는 라이프사이클을 구현했습니다.
+- **UI 검증**: 대시보드 메인 페이지에서 버튼 클릭 시 봇으로부터 성공적으로 응답을 받아 `response`를 렌더링함을 확인했습니다.
+
+## 테스트 결과 (Results)
+
+- **연결 성공**: 대시보드 -> 매니저 -> (방송) -> 봇 워커 -> 매니저 -> 대시보드 흐름이 무차별적인 포트 개방 없이 단일 통로로 성공적으로 작동함.
+- **지연 시간**: 로컬 환경 기준 10ms 이내의 빠른 응답 속도를 확인.
+
+## 관련 문서
+- [대시보드 아키텍처 결정서](../Decisions/Dashboard_Architecture_gRPC.md)

Docs/WorkDone/2026-04-21_Infrastructure_Recovery_And_Stability.md

@@ -0,0 +1,29 @@
+# 인프라 치명적 오류 복구 및 안정화 (2026-04-21)
+
+## 개요
+이전 작업 과정에서 누락되었거나 허위로 보고된 인프라 결함(DB 스키마 불일치, 환경 변수 로드 실패, gRPC 경로 인식 오류)을 모두 복구하고, 이를 입증할 수 있는 검증 시스템을 구축했습니다.
+
+## 문제 원인 및 해결 내용
+
+### 1. DB 스키마 불일치 (ShardStatus 테이블 누락)
+- **증상**: 봇이 `ready` 상태가 될 때 `ShardStatus` 테이블을 업데이트하려다 `TableDoesNotExist` 에러가 발생하며 비정상 작동함.
+- **해결**: `prisma db push`를 실행하여 `ShardStatus` 테이블을 DB에 생성하고 동기화 상태를 확인했습니다.
+
+### 2. shard.ts 환경 변수 로드 실패
+- **증상**: `apps/bot/src/shard.ts`에서 모노레포 루트의 `.env`를 찾지 못하고 `DISCORD_TOKEN`이 `undefined`로 로드되어 샤드 생성에 실패함.
+- **해결**: `shard.ts`의 `dotenv` 로딩 로직을 수정하여 `apps/bot` 또는 프로젝트 루트 어디에서 실행하더라도 `.env`를 안정적으로 찾도록 개선했습니다.
+
+### 3. gRPC 프로토 파일 경로 인식 강화
+- **증상**: `packages/grpc-contracts`가 다양한 실행 환경(Next.js, tsx 직접 실행 등)에서 `kord.proto` 파일을 찾지 못하는 브리틀(Brittle)한 상태였음.
+- **해결**: `findProtoPath` 함수를 보강하여 5단계의 폴백 경로 탐색 및 실패 시 상세 로그 출력 로직을 도입했습니다.
+
+### 4. 통합 검증 시스템 (scripts/verify-recovery.ts)
+- **기능**: `.env` 로딩, DB 접속, 필수 테이블 존재 여부, gRPC 컨트랙트 유효성을 한 번에 체크합니다.
+- **결과**: `--- Verification Finished ---` 메시지와 함께 모든 인프라가 **정상(PASS)**임을 입증했습니다.
+
+## 의사 결정 (Decisions Made)
+- **Verification First**: 차후 유사한 신뢰 문제가 발생하지 않도록, 단순 코드 수정에 그치지 않고 독립적인 검증 스크립트를 작성하여 사용자에게 증거를 제시하도록 프로세스를 강화했습니다.
+- **Robust Path Resolution**: 모노레포 구조 특성상 실행 CWD가 가변적임을 고려하여, 하드코딩된 상대 경로 대신 다중 폴백 전략을 채택했습니다.
+
+## 향후 과제
+- `dev` 스크립트 실행 시 항상 `shard.ts`를 거치도록 통합하여 샤딩 환경의 일관성을 유지할 필요가 있음.

Docs/WorkDone/2026-04-21_README_Local_Connection_Info_Update.md

@@ -0,0 +1,18 @@
+# Work Done: README 로컬 접속 정보 업데이트 (README Local Connection Info Update)
+
+## 개요 (Overview)
+- **날짜**: 2026-04-21
+- **작업자**: Antigravity (AI Agent)
+- **목표**: `README.md`에 결여된 로컬 테스트용 접속 주소 및 포트 정보 추가
+
+## 변경 사항 (Changes)
+
+### [README.md](file:///Users/wemadeplay/workspace/stz/Kord/README.md)
+- "4. 로컬 접속 정보 (Local Connection Info)" 섹션 추가
+- 각 컴포넌트별 로컬 접속 정보 명시:
+    - **웹 대시보드 (Dashboard)**: `http://localhost:3000`
+    - **gRPC 프록시 서버 (Bot Proxy)**: `localhost:50051`
+    - **데이터베이스 (PostgreSQL)**: `localhost:5432`
+
+## 확인 방법 (Verification)
+- `README.md` 파일 내용 확인

Docs/WorkDone/2026-04-21_fix_dashboard_panic.md

@@ -0,0 +1,34 @@
+# Dashboard & Bot Stability Infrastructure Fix (2026-04-21)
+
+## 개요
+사용자가 대시보드 URL 접속 시 `Turbopack Panic` 에러를 겪는 문제를 해결하고, 봇 프로세스의 불안정성(IPC 채널 종료)을 개선했습니다.
+
+## 원인 분석
+1. **gRPC Contract 초기화 이슈**: 
+   - `grpc-contracts` 패키지 로드 시점에 동적으로 파일 시스템을 조회하여 `proto` 파일을 로드함.
+   - Next.js의 빌드/분석 단계에서 파일 시스템 접근 권한이나 경로 문제로 인해 crash 유발.
+2. **Turbopack 환경 호환성 이슈**:
+   - Turbopack이 내부 worker 프로세스를 스폰할 때 시스템 `$PATH`에서 `node` 바이너리를 찾지 못함 (`os error 2`).
+   - 이는 Turborepo의 환경 변수 제한 정책과 겹쳐 발생함.
+
+## 해결 방법
+1. **gRPC Lazy Loading 적용**:
+   - `packages/grpc-contracts/src/index.js`를 수정하여 실제 모듈 접근 시점에만 proto를 로드하도록 `getter` 패턴 적용.
+2. **gRPC 서버 개발 모드 통합**:
+   - `apps/bot/src/utils/grpcServer.ts`를 신설하여 공통 gRPC 서버 로직을 추출.
+   - 단일 실행 모드(`index.ts`)와 Sharding 모드(`shard.ts`) 모두에서 대시보드 통신을 위한 gRPC 서버가 기동되도록 수정.
+3. **Webpack Fallback 및 PATH 주입**:
+   - Turbopack의 하위 프로세스 스폰 이슈(`os error 2`)를 회피하기 위해 대시보드를 Webpack 모드(`next dev --webpack`)로 구동.
+   - `apps/dashboard/package.json`에서 명시적으로 Node.js 실행 경로를 `PATH`에 주입.
+4. **인프라 자동 복구**:
+   - `docker-compose`를 통해 PostgreSQL 컨테이너를 정상화하고 `Prisma` 스키마를 동기화.
+5. **좀비 프로세스 정리**:
+   - 포트 점유 이슈를 유발하던 구형 Node 프로세스들을 원천 정리.
+
+## 결과 확인
+- `scripts/verify-recovery.ts`를 통해 DB, gRPC, Bot 연동 전수 검토 완료 (ALL PASS).
+- `curl -I http://localhost:3000/`를 통해 대시보드 응답 확인.
+- 브라우저를 통한 대시보드 UI 정상 렌더링 확인.
+
+## 참고 사항
+- 현재 대시보드는 안정성을 위해 임시로 `3005` 포트에서 구동 확인을 마쳤으나, `3000`번 포트 점유가 해제되면 다시 `3000`번으로 서비스될 수 있도록 설정되어 있습니다.

Docs/WorkDone/2026-04-21_gRPC_Proto_Path_Resolution_Fix.md

@@ -0,0 +1,37 @@
+# gRPC Proto 파일 경로 인식 오류 수정 (2026-04-21)
+
+## 개요
+Next.js(`dashboard`) 환경에서 `@kord/grpc-contracts` 패키지를 통해 gRPC 서비스를 이용할 때, `kord.proto` 파일을 찾지 못해 발생하는 `ENOENT` 에러를 해결했습니다.
+
+## 문제 원인
+1. **__dirname의 가변성**: Next.js 서버 사이드 번들링 과정에서 Webpack이 `__dirname`을 변조하거나 가상 경로(`/ROOT/...`)로 치환하여 실제 파일 시스템의 `.proto` 파일 위치를 가리키지 못함.
+2. **정적 리소스 누락**: JS 파일 외의 `.proto` 파일이 빌드 결과물에 포함되지 않거나 모노레포의 심볼릭 링크 구조에서 경로 해석이 어긋남.
+
+## 수정 내역
+
+### 1. @kord/grpc-contracts 패키지 개선
+- `src/index.js` 내의 `PROTO_PATH` 결정 로직에 폴백 시스템 도입.
+- 기존 `__dirname` 기반 탐색이 실패할 경우, `process.cwd()`를 기준으로 한 프로젝트 루트 탐색 및 상대 경로 탐색(`../../packages/...`) 로직 추가.
+- 환경 변수 `KORD_PROTO_PATH`를 통한 명시적 경로 지정 지원.
+
+### 2. apps/dashboard 설정 업데이트
+- `next.config.ts`에 `transpilePackages: ["@kord/grpc-contracts"]` 설정 추가.
+- 이를 통해 Next.js가 해당 모노레포 패키지를 소스 레벨에서 직접 처리하여 경로 해석의 일관성을 확보함.
+
+### 3. gRPC 연결 설정 및 호환성 개선
+- `apps/dashboard/src/lib/grpc.ts`에서 기본 연결 주소를 `127.0.0.1`로 변경하여 IPv6 호환 이슈 해결.
+- **Node.js v22 호환성 해결**: `apps/bot/src/shard.ts`에서 샤딩 프로세스 생성 시 발생하는 `ERR_METHOD_NOT_IMPLEMENTED` 에러를 해결하기 위해 `execArgv`를 `--import tsx`로 업데이트함.
+- **구동 순서 최적화**: 봇 샤드 생성 완료 전에도 gRPC 서버가 즉시 응답할 수 있도록 시작 시퀀스를 조정함.
+
+## 테스트 결과 (에이전트 직접 검증 완료)
+- **독립 테스트 스크립트 실행 결과**:
+  - 파일: `apps/dashboard/src/verify_grpc.ts`
+  - 결과: `SUCCESS! Received response: { reply: 'Pong to Hello from verification script!' }`
+- **입증 내용**:
+  1. `@kord/grpc-contracts`를 통한 프로토 파일 로드 성공 (Path Resolution 해결).
+  2. 봇과 대시보드 패키지 간의 gRPC 통신 성공 (Connection 해결).
+  3. Node.js v22 환경에서의 봇 구동 안정성 확보.
+
+## 의사 결정 (Decisions Made)
+- Node.js v22의 ESM 로더 변경 사항에 대응하기 위해 `-r tsx` 대신 `--import tsx`를 사용하여 런타임 안정성을 확보함.
+- 봇의 라이프사이클에 관계없이 gRPC 서버를 조기에 활성화하여 서비스 가용성을 높임.

Docs/WorkDone/2026-04-22_ProcessCleanup.md

@@ -0,0 +1,16 @@
+# Process Cleanup (2026-04-22)
+
+## Description
+이전에 실행되었던 테스트 프로세스가 포트 3000을 점유하고 있어, 이를 확인하고 강제 종료(Kill) 처리하였습니다.
+
+## Actions Taken
+- `lsof -i :3000`을 통해 포트 3000(대시보드)을 사용 중인 PID 59044 확인 및 종료
+- `lsof -i :50051`을 통해 포트 50051(gRPC)을 사용 중인 PID 59045 확인 및 종료
+- `ps aux` 조회를 통해 남아있던 `turbo run dev` 프로세스(PID: 59029, 59028) 및 `tsx watch` 프로세스(PID: 59043) 확인 및 종료
+- `kill -9` 명령어로 모든 관련 프로세스를 강제 종료 처리
+- 포트 3000, 50051, 8080 및 관련 프로세스 상태를 재확인하여 완전 종료 여부 검증
+
+## Results
+- 포트 3000(Dashboard) 및 50051(gRPC)이 성공적으로 해제되었습니다.
+- 모든 관련 부모 프로세스(`turbo`, `tsx`)가 정리되었습니다.
+- 프로젝트 경로(`/Users/wemadeplay/workspace/stz/Kord`)에서 실행 중인 추가 유령 프로세스가 없음을 확인했습니다.

Docs/index.md

@@ -2,38 +2,46 @@
 
 이 루트 색인 문서는 프로젝트 내의 모든 구조화된 문서를 카테고리별로 모아 탐색을 돕기 위해 작성되었습니다.
 
+## 아키텍처 및 시스템 (Architecture & System)
+
+- [프로젝트 구조 (Project Structure)](Project_Structure.md)
+- [데이터베이스 스키마 구조 (Database Schema)](database-schema.md)
 
 ## 정책 및 규칙 (Rules)
 
 - [보안 가이드라인 (Security Rules)](Rules/security_guidelines.md)
 - [다국어 지원 개발 가이드라인 (i18n Development Guidelines)](Rules/i18n_guidelines.md)
 
-
 ## 기능 명세 (Features)
 
 - [임시 음성 채널 자동화 (Temp Voice Channels)](Features/temp_voice_channels.md)
-
+- [Graphify 설정 및 연동 가이드 (Graphify Setup Guide)](Features/Graphify_Setup_Guide.md)
 
 ## 기획서 (Plans)
 
+- [감사 채널 기획서 (Audit Channel Plan)](Plans/Audit_Channel_Plan.md)
+- [봇 상태 메시지 기획서 (Bot Presence Plan)](Plans/Bot_Presence_Plan.md)
 - [에러 안내 기능 기획서 (Error Guidance Plan)](Plans/Error_Guidance_Plan.md)
 - [다국어 지원 기획서 (i18n Plan)](Plans/i18n_Plan.md)
 - [서버 이벤트 일정 관리 기능 기획안 (Event Schedule Management Plan)](Plans/Event_Schedule_Management_Plan.md)
+- [기능 로드맵 (Feature Roadmap)](Plans/Feature_Roadmap.md)
 - [YouTube 음악 재생 기능 기획안 (YouTube Music Playback Plan)](Plans/YouTube_Music_Playback_Plan.md)
 - [재련 미니게임 기획서 (Refinement Mini-Game Plan)](Plans/MiniGame_Refinement_Plan.md)
-
+- [권한 진단 기획서 (Permission Audit Plan)](Plans/Permission_Audit_Plan.md)
+- [초기 설정 마법사 기획서 (Setup Wizard Plan)](Plans/Setup_Wizard_Plan.md)
+- [임시 음성 채널 기획서 (Temp Voice Channel Plan)](Plans/Temp_Voice_Channel_Plan.md)
+- [낚시 미니게임 기획안 (Fishing Mini-Game Plan)](Plans/Fishing_MiniGame_Plan.md)
 
 ## 아키텍처 및 정책 결정 (Decisions)
 
 - [구독 티어 시스템 설계 (Subscription Tiers)](Decisions/subscription_tiers.md)
-
+- [대시보드-봇 통신 아키텍처 (Dashboard gRPC Architecture)](Decisions/Dashboard_Architecture_gRPC.md)
 
 ## 트러블슈팅 (Troubleshooting)
 
 - [Voice Channel Missing Permissions (50013) 해결건](Troubleshooting/50013_Missing_Permissions.md)
 - [Temp Voice 유령 채널 미삭제 버그 해결건](Troubleshooting/handleLeave_ghost_channel.md)
 
-
 ## 진행/완료 내역 (Work Done)
 
 - [2026-03-27: 봇 상태 메시지 기능 구현 (Bot Presence Implementation)](WorkDone/2026-03-27_Presence_Implementation.md)
@@ -51,7 +59,18 @@
 - [2026-03-30: 서버 이벤트 시작 시점 공지 구현 (Event Schedule Start Announcement Implementation)](WorkDone/2026-03-30_Event_Schedule_Start_Announcement_Implementation.md)
 - [2026-03-30: 이벤트 리마인더 분 단위 옵션 구현 (Event Reminder Offsets Implementation)](WorkDone/2026-03-30_Event_Reminder_Offsets_Implementation.md)
 - [2026-03-30: 명령어 계층 구조 리팩토링 (Hierarchical Command Refactoring)](WorkDone/2026-03-30_HierarchicalRefactor.md)
-- [2026-03-30: YouTube 음악 재생 Phase 1 구현 (YouTube Music Playback Phase 1 Implementation)](WorkDone/2026-03-30_YouTube_Music_Playback_Phase1_Implementation.md)
-- [2026-03-31: YouTube 음악 재생 Phase 2 구현 (YouTube Music Playback Phase 2 Implementation)](WorkDone/2026-03-31_YouTube_Music_Playback_Phase2_Implementation.md)
-- [2026-03-31: YouTube 음악 재생 Phase 3 구현 (YouTube Music Playback Phase 3 Implementation)](WorkDone/2026-03-31_YouTube_Music_Playback_Phase3_Implementation.md)
+- [2026-03-30: YouTube 음악 재생 Phase 1 구현 (YouTube Music Playback Phase 1 Implementation)](WorkDone/2026-03-30_YouTube_Music_Playback_Phase1_Implementation.md)
+- [2026-03-31: YouTube 음악 재생 Phase 2 구현 (YouTube Music Playback Phase 2 Implementation)](WorkDone/2026-03-31_YouTube_Music_Playback_Phase2_Implementation.md)
+- [2026-03-31: YouTube 음악 재생 Phase 3 구현 (YouTube Music Playback Phase 3 Implementation)](WorkDone/2026-03-31_YouTube_Music_Playback_Phase3_Implementation.md)
 - [2026-03-30: 미니게임 시스템 및 재련 게임 구현 (Mini-Game System & Refinement Implementation)](WorkDone/2026-03-30_RefinementImplementation.md)
+- [2026-03-31: 낚시 미니게임 Phase 1 구현 (Fishing Mini-Game Phase 1 Implementation)](WorkDone/2026-03-31_Fishing_MiniGame_Phase1_Implementation.md)
+- [2026-03-31: 낚시 미니게임 Phase 1 완료 (Fishing Mini-Game Phase 1 Completion)](WorkDone/2026-03-31_Fishing_MiniGame_Phase1_Completion.md)
+- [2026-04-07: 낚시 미니게임 Phase 2 구현 (Fishing Mini-Game Phase 2 Implementation)](WorkDone/2026-04-07_Fishing_MiniGame_Phase2_Implementation.md)
+- [2026-04-07: 낚시 도감 및 크기 시스템 구현 (Fishing Dex and Size Implementation)](WorkDone/2026-04-07_Fishing_Dex_And_Size_Implementation.md)
+- [2026-04-07: 낚시 크기 랭킹 구현 (Fishing Size Ranking Implementation)](WorkDone/2026-04-07_Fishing_Size_Ranking_Implementation.md)
+- [2026-04-20: 모노레포 전환 및 gRPC 통신 테스트 완료 (Monorepo & gRPC Test)](WorkDone/2026-04-20_Monorepo_Migration_And_gRPC_Test.md)
+- [2026-04-21: README 로컬 접속 정보 업데이트 (README Local Connection Info Update)](WorkDone/2026-04-21_README_Local_Connection_Info_Update.md)
+- [2026-04-21: gRPC Proto 파일 경로 인식 오류 수정 (gRPC Proto Path Resolution Fix)](WorkDone/2026-04-21_gRPC_Proto_Path_Resolution_Fix.md)
+- [2026-04-21: 인프라 치명적 오류 복구 및 안정화 (Infrastructure Recovery & Stability)](WorkDone/2026-04-21_Infrastructure_Recovery_And_Stability.md)
+- [2026-04-21: 대시보드 Turbopack Panic 현상 해결 (Fix Dashboard Turbopack Panic)](WorkDone/2026-04-21_fix_dashboard_panic.md)
+- [2026-04-22: 테스트 프로세스 정리 (Process Cleanup)](WorkDone/2026-04-22_ProcessCleanup.md)

README.md

@@ -1,73 +1,81 @@
-# Kord
+# Kord (Monorepo)
 
-Kord는 Discord 서버 관리를 돕는 강력하고 유연한 다기능 봇입니다.
+Kord는 Discord 서버 관리를 돕는 강력하고 유연한 다기능 봇 및 전용 웹 대시보드 프로젝트입니다.
+현재 모노레포(Monorepo) 구조로 관리되고 있습니다.
 
-## 1. 개요 (Overview)
+## 1. 프로젝트 구조 (Structure)
 
-**Kord**는 효율적인 서버 운영을 위해 설계된 Discord 봇입니다. TypeScript와 Discord.js를 기반으로 구축되었으며, Prisma(PostgreSQL)를 활용하여 안정적이고 확장 가능한 아키텍처를 제공합니다. 임시 음성 채널 관리, 상세 감사 로그, 권한 진단 등의 핵심 기능을 통해 서버 관리자의 부담을 줄여줍니다.
+본 프로젝트는 **Turborepo**와 **Yarn Workspaces**를 사용합니다.
+
+- **`apps/bot`**: Discord.js 기반의 봇 본체 (ShardingManager 적용)
+- **`apps/dashboard`**: Next.js 기반의 봇 관리 웹 대시보드
+- **`packages/db`**: Prisma 스키마 및 데이터베이스 데이터 접근 레이어 (공용)
+- **`packages/grpc-contracts`**: 봇과 대시보드 간의 gRPC 통신 규약 (공용)
 
 ## 2. 요구사항 (Requirements)
 
-- **Runtime**: Node.js v20 이상
+- **Runtime**: Node.js v22 이상 (추천)
 - **Package Manager**: Yarn v4 (Berry)
 - **Database**: PostgreSQL (Prisma 사용)
-- **Discord**: Bot Token 및 Client ID (Slash Command 등록용)
+- **Discord**: Bot Token 및 Client ID
 
-## 3. 테스트 방법 (Test Methods)
+## 3. 시작하기 (Quick Start)
 
-본 프로젝트는 Jest를 사용하여 유닛 테스트 및 통합 테스트를 수행합니다.
-
-- **전체 테스트 실행**:
-
-  ```bash
-  yarn test
-  ```
-
-- **i18n 번역 누락 확인**:
-
-  ```bash
-  yarn check-i18n
-  ```
-
-## 4. 구동 방법 (Running Methods)
-
-### 로컬 개발 환경
+### 로컬 개발 환경 설정
 
 1. **의존성 설치**:
-
     ```bash
     yarn install
     ```
 
-2. **환경 변수 설정**: `.env.example` 파일을 복사하여 `.env` 파일을 생성하고 필수 값을 입력합니다.
-
-3. **데이터베이스 초기화**:
+2. **환경 변수 설정**: 루트 및 각 앱 디렉토리의 `.env` 설정을 완료합니다.
 
+3. **데이터베이스 및 코드 생성**:
     ```bash
-    npx prisma migrate dev
-    npx prisma generate
+    yarn run generate
     ```
 
-4. **개발 서버 실행**:
+### 실행 방법
 
+전체 프로젝트를 한꺼번에 실행하거나 개별 앱을 실행할 수 있습니다.
+
+- **모든 앱 실행 (Bot + Dashboard)**:
     ```bash
     yarn dev
     ```
 
-### 프로덕션 환경
+- **봇만 실행**:
+    ```bash
+    yarn workspace @kord/bot dev
+    ```
 
-1. **빌드**: `yarn build`
-2. **실행**: `yarn start`
-3. **Docker**: `docker-compose up -d`를 통해 전체 스택(Bot, DB)을 실행할 수 있습니다.
+- **대시보드만 실행**:
+    ```bash
+    yarn workspace dashboard dev
+    ```
 
-## 5. 기능 목록 (Feature List)
+## 5. 인프라 검증 (Infrastructure Verification)
 
-- **임시 음성 채널 (Voice)**: 생성기(Generator) 채널을 통해 동적인 음성 채널 생성 및 관리 기능을 제공합니다.
-- **감사 로그 (Audit Log)**: 서버 내 주요 이벤트를 카테고리별(VOICE, PERMISSION, SYSTEM 등)로 세분화하여 기록합니다.
-- **서버 설정 (Config)**: 따라하기(Mimic), 큰 이모지(Big Emoji) 등 봇의 기능을 서버별 환경에 맞게 토글하거나 설정할 수 있습니다.
-- **권한 감사 (Permission Audit)**: 봇의 정상 작동을 방해하는 권한 문제를 즉시 진단하고 해결 방법을 안내합니다.
-- **초기 설정 마법사 (Setup Wizard)**: 봇 도입 초기 기능을 한눈에 설정할 수 있는 직관적인 UI를 제공합니다.
-- **미니게임 시스템 (Mini-Games)**: 서버 내에서 즐길 수 있는 다양한 미니게임을 제공하며, 관리자가 게임별 활성화 및 전용 채널을 설정할 수 있습니다.
-- **재련 (Refinement)**: 무기를 강화하고 다른 유저와 전투하며 골드를 획득하는 성장형 미니게임입니다.
-- **피버 타임 (Fever Time)**: 서버 활동량을 자동으로 분석하여 가장 활발한 시간대에 재련 성공 확률 보너스를 제공합니다.
-- **다국어 지원 (i18n)**: 한국어와 영어를 포함한 다국어 환경을 지원합니다.
+인프라 설정(DB, gRPC, 환경 변수)이 올바른지 확인하려면 다음 스크립트를 실행합니다:
+```bash
+npx tsx scripts/verify-recovery.ts
+```
+
+## 6. 로컬 접속 정보 (Local Connection Info)
+
+로컬에서 개발 및 테스트 시 다음 주소를 사용합니다.
+
+- **웹 대시보드 (Dashboard)**: [http://localhost:3000](http://localhost:3000)
+- **gRPC 프록시 서버 (Bot Proxy)**: `localhost:50051` (대시보드와 봇 간 통신)
+- **데이터베이스 (PostgreSQL)**: `localhost:5432`
+
+## 5. 아키텍처 (Architecture)
+
+Kord는 **gRPC Proxy** 아키텍처를 사용하여 대시보드와 샤딩된 봇 인스턴스 간의 실시간 통신을 처리합니다. 자세한 내용은 관련 문서를 참조하세요.
+- [대시보드 통신 아키텍처 가이드](Docs/Decisions/Dashboard_Architecture_gRPC.md)
+
+## 5. 문서 (Documentation)
+
+모둔 상세 문서는 `Docs/` 디렉토리에 위치합니다.
+- [문서 전체 색인 (Docs Index)](Docs/index.md)
+- [로컬 가이드북 (SKILL.md)](SKILL.md)

SKILL.md

@@ -0,0 +1,855 @@
+---
+name: graphify
+description: any input (code, docs, papers, images) → knowledge graph → clustered communities → HTML + JSON + audit report
+trigger: /graphify
+---
+
+# /graphify
+
+Turn any folder of files into a navigable knowledge graph with community detection, an honest audit trail, and three outputs: interactive HTML, GraphRAG-ready JSON, and a plain-language GRAPH_REPORT.md.
+
+## Usage
+
+```
+/graphify                                             # full pipeline on current directory → Obsidian vault
+/graphify <path>                                      # full pipeline on specific path
+/graphify <path> --mode deep                          # thorough extraction, richer INFERRED edges
+/graphify <path> --update                             # incremental - re-extract only new/changed files
+/graphify <path> --cluster-only                       # rerun clustering on existing graph
+/graphify <path> --no-viz                             # skip visualization, just report + JSON
+/graphify <path> --html                               # (HTML is generated by default - this flag is a no-op)
+/graphify <path> --svg                                # also export graph.svg (embeds in Notion, GitHub)
+/graphify <path> --graphml                            # export graph.graphml (Gephi, yEd)
+/graphify <path> --neo4j                              # generate graphify-out/cypher.txt for Neo4j
+/graphify <path> --neo4j-push bolt://localhost:7687   # push directly to Neo4j
+/graphify <path> --mcp                                # start MCP stdio server for agent access
+/graphify <path> --watch                              # watch folder, auto-rebuild on code changes (no LLM needed)
+/graphify <path> --wiki                               # build agent-crawlable wiki (index.md + one article per community)
+/graphify <path> --obsidian --obsidian-dir ~/vaults/my-project  # write vault to custom path (e.g. existing vault)
+/graphify add <url>                                   # fetch URL, save to ./raw, update graph
+/graphify add <url> --author "Name"                   # tag who wrote it
+/graphify add <url> --contributor "Name"              # tag who added it to the corpus
+/graphify query "<question>"                          # BFS traversal - broad context
+/graphify query "<question>" --dfs                    # DFS - trace a specific path
+/graphify query "<question>" --budget 1500            # cap answer at N tokens
+/graphify path "AuthModule" "Database"                # shortest path between two concepts
+/graphify explain "SwinTransformer"                   # plain-language explanation of a node
+/graphify <path> --ollama                             # use local Ollama for semantic extraction
+/graphify <path> --ollama --model gemma4             # use specific Ollama model (default: llama3)
+```
+
+## What graphify is for
+
+graphify is built around Andrej Karpathy's /raw folder workflow: drop anything into a folder - papers, tweets, screenshots, code, notes - and get a structured knowledge graph that shows you what you didn't know was connected.
+
+Three things it does that Claude alone cannot:
+1. **Persistent graph** - relationships are stored in `graphify-out/graph.json` and survive across sessions. Ask questions weeks later without re-reading everything.
+2. **Honest audit trail** - every edge is tagged EXTRACTED, INFERRED, or AMBIGUOUS. You know what was found vs invented.
+3. **Cross-document surprise** - community detection finds connections between concepts in different files that you would never think to ask about directly.
+
+Use it for:
+- A codebase you're new to (understand architecture before touching anything)
+- A reading list (papers + tweets + notes → one navigable graph)
+- A research corpus (citation graph + concept graph in one)
+- Your personal /raw folder (drop everything in, let it grow, query it)
+
+## What You Must Do When Invoked
+
+If no path was given, use `.` (current directory). Do not ask the user for a path.
+
+Follow these steps in order. Do not skip steps.
+
+### Step 1 - Ensure graphify is installed
+
+```bash
+# Detect the correct Python interpreter (handles pipx, venv, system installs)
+GRAPHIFY_BIN=$(which graphify 2>/dev/null)
+if [ -n "$GRAPHIFY_BIN" ]; then
+    PYTHON=$(head -1 "$GRAPHIFY_BIN" | tr -d '#!')
+else
+    PYTHON="python3"
+fi
+$PYTHON -c "import graphify" 2>/dev/null || pip install graphifyy -q --break-system-packages 2>&1 | tail -3
+# Write interpreter path for all subsequent steps
+$PYTHON -c "import sys; open('.graphify_python', 'w').write(sys.executable)"
+
+# Check Ollama connectivity
+OLLAMA_UP=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:11434/api/tags 2>/dev/null)
+if [ "$OLLAMA_UP" = "200" ]; then
+    echo "Ollama: CONNECTED"
+    $PYTHON -c "import json; print(json.dumps([m['name'] for m in json.loads(open('.ollama_tags.json').read()).get('models', [])]))" > .ollama_models.json 2>/dev/null || (curl -s http://localhost:11434/api/tags > .ollama_tags.json && $PYTHON -c "import json; print(json.dumps([m['name'] for m in json.loads(open('.ollama_tags.json').read()).get('models', [])]))" > .ollama_models.json && rm .ollama_tags.json)
+else
+    echo "Ollama: DISCONNECTED"
+    rm -f .ollama_models.json
+fi
+```
+
+If the import succeeds, print nothing and move straight to Step 2.
+
+**In every subsequent bash block, replace `python3` with `$(cat .graphify_python)` to use the correct interpreter.**
+
+### Step 2 - Detect files
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.detect import detect
+from pathlib import Path
+result = detect(Path('INPUT_PATH'))
+print(json.dumps(result))
+" > .graphify_detect.json
+```
+
+Replace INPUT_PATH with the actual path the user provided. Do NOT cat or print the JSON - read it silently and present a clean summary instead:
+
+```
+Corpus: X files · ~Y words
+  code:     N files (.py .ts .go ...)
+  docs:     N files (.md .txt ...)
+  papers:   N files (.pdf ...)
+  images:   N files
+```
+
+Then act on it:
+- If `total_files` is 0: stop with "No supported files found in [path]."
+- If `skipped_sensitive` is non-empty: mention file count skipped, not the file names.
+- If `total_words` > 2,000,000 OR `total_files` > 200: show the warning and the top 5 subdirectories by file count, then ask which subfolder to run on. Wait for the user's answer before proceeding.
+- Otherwise: proceed directly to Step 3 - no need to ask anything.
+
+### Step 3 - Extract entities and relationships
+
+**Before starting:** note whether `--mode deep` was given. You must pass `DEEP_MODE=true` to every subagent in Step B2 if it was. Track this from the original invocation - do not lose it.
+
+This step has two parts: **structural extraction** (deterministic, free) and **semantic extraction** (Claude, costs tokens).
+
+**Run Part A (AST) and Part B (semantic) in parallel. Dispatch all semantic subagents AND start AST extraction in the same message. Both can run simultaneously since they operate on different file types. Merge results in Part C as before.**
+
+Note: Parallelizing AST + semantic saves 5-15s on large corpora. AST is deterministic and fast; start it while subagents are processing docs/papers.
+
+#### Part A - Structural extraction for code files
+
+For any code files detected, run AST extraction in parallel with Part B subagents:
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.extract import collect_files, extract
+from pathlib import Path
+import json
+
+code_files = []
+detect = json.loads(Path('.graphify_detect.json').read_text())
+for f in detect.get('files', {}).get('code', []):
+    code_files.extend(collect_files(Path(f)) if Path(f).is_dir() else [Path(f)])
+
+if code_files:
+    result = extract(code_files)
+    Path('.graphify_ast.json').write_text(json.dumps(result, indent=2))
+    print(f'AST: {len(result[\"nodes\"])} nodes, {len(result[\"edges\"])} edges')
+else:
+    Path('.graphify_ast.json').write_text(json.dumps({'nodes':[],'edges':[],'input_tokens':0,'output_tokens':0}))
+    print('No code files - skipping AST extraction')
+"
+```
+
+#### Part B - Semantic extraction (parallel subagents or local LLM)
+
+**Fast path:** If detection found zero docs, papers, and images (code-only corpus), skip Part B entirely and go straight to Part C. AST handles code - there is nothing for semantic subagents to do.
+
+**Ollama Choice:** If Ollama is CONNECTED (check `.ollama_models.json`) AND `--ollama` was given:
+Run semantic extraction locally for each chunk of files.
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.semantic_llm import extract_semantic
+from pathlib import Path
+
+uncached = Path('.graphify_uncached.txt').read_text().splitlines()
+# Split into chunks of 15 files (local models are slower)
+chunks = [uncached[i:i + 15] for i in range(0, len(uncached), 15)]
+all_results = {'nodes': [], 'edges': [], 'hyperedges': [], 'input_tokens': 0, 'output_tokens': 0}
+
+model = 'MODEL_NAME' # Use --model value or 'llama3' or first found in .ollama_models.json
+deep = DEEP_MODE_VAR # True if --mode deep
+
+for i, chunk in enumerate(chunks):
+    print(f'Local Extraction: chunk {i+1}/{len(chunks)} ({len(chunk)} files)...')
+    res = extract_semantic(chunk, model=model, deep_mode=deep)
+    all_results['nodes'].extend(res.get('nodes', []))
+    all_results['edges'].extend(res.get('edges', []))
+    all_results['hyperedges'].extend(res.get('hyperedges', []))
+
+Path('.graphify_semantic_new.json').write_text(json.dumps(all_results, indent=2))
+"
+```
+
+**Otherwise (Cloud Model - DEFAULT):**
+**MANDATORY: You MUST use the Agent tool here. Reading files yourself one-by-one is forbidden - it is 5-10x slower. If you do not use the Agent tool you are doing this wrong.**
+
+Before dispatching subagents, print a timing estimate:
+- Load `total_words` and file counts from `.graphify_detect.json`
+- Estimate agents needed: `ceil(uncached_non_code_files / 22)` (chunk size is 20-25)
+- Estimate time: ~45s per agent batch (they run in parallel, so total ≈ 45s × ceil(agents/parallel_limit))
+- Print: "Semantic extraction: ~N files → X agents, estimated ~Ys"
+
+**Step B0 - Check extraction cache first**
+
+Before dispatching any subagents, check which files already have cached extraction results:
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.cache import check_semantic_cache
+from pathlib import Path
+
+detect = json.loads(Path('.graphify_detect.json').read_text())
+all_files = [f for files in detect['files'].values() for f in files]
+
+cached_nodes, cached_edges, cached_hyperedges, uncached = check_semantic_cache(all_files)
+
+if cached_nodes or cached_edges or cached_hyperedges:
+    Path('.graphify_cached.json').write_text(json.dumps({'nodes': cached_nodes, 'edges': cached_edges, 'hyperedges': cached_hyperedges}))
+Path('.graphify_uncached.txt').write_text('\n'.join(uncached))
+print(f'Cache: {len(all_files)-len(uncached)} files hit, {len(uncached)} files need extraction')
+"
+```
+
+Only dispatch subagents for files listed in `.graphify_uncached.txt`. If all files are cached, skip to Part C directly.
+
+**Step B1 - Split into chunks**
+
+Load files from `.graphify_uncached.txt`. Split into chunks of 20-25 files each. Each image gets its own chunk (vision needs separate context).
+
+**Step B2 - Dispatch ALL subagents in a single message**
+
+Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose.
+
+Concrete example for 3 chunks:
+```
+[Agent tool call 1: files 1-15]
+[Agent tool call 2: files 16-30]  
+[Agent tool call 3: files 31-45]
+```
+All three in one message. Not three separate messages.
+
+Each subagent receives this exact prompt (substitute FILE_LIST, CHUNK_NUM, TOTAL_CHUNKS, and DEEP_MODE):
+
+```
+You are a graphify extraction subagent. Read the files listed and extract a knowledge graph fragment.
+Output ONLY valid JSON matching the schema below - no explanation, no markdown fences, no preamble.
+
+Files (chunk CHUNK_NUM of TOTAL_CHUNKS):
+FILE_LIST
+
+Rules:
+- EXTRACTED: relationship explicit in source (import, call, citation, "see §3.2")
+- INFERRED: reasonable inference (shared data structure, implied dependency)
+- AMBIGUOUS: uncertain - flag for review, do not omit
+
+Code files: focus on semantic edges AST cannot find (call relationships, shared data, arch patterns).
+  Do not re-extract imports - AST already has those.
+Doc/paper files: extract named concepts, entities, citations. Also extract rationale — sections that explain WHY a decision was made, trade-offs chosen, or design intent. These become nodes with `rationale_for` edges pointing to the concept they explain.
+Image files: use vision to understand what the image IS - do not just OCR.
+  UI screenshot: layout patterns, design decisions, key elements, purpose.
+  Chart: metric, trend/insight, data source.
+  Tweet/post: claim as node, author, concepts mentioned.
+  Diagram: components and connections.
+  Research figure: what it demonstrates, method, result.
+  Handwritten/whiteboard: ideas and arrows, mark uncertain readings AMBIGUOUS.
+
+DEEP_MODE (if --mode deep was given): be aggressive with INFERRED edges - indirect deps,
+  shared assumptions, latent couplings. Mark uncertain ones AMBIGUOUS instead of omitting.
+
+Semantic similarity: if two concepts in this chunk solve the same problem or represent the same idea without any structural link (no import, no call, no citation), add a `semantically_similar_to` edge marked INFERRED with a confidence_score reflecting how similar they are (0.6-0.95). Examples:
+- Two functions that both validate user input but never call each other
+- A class in code and a concept in a paper that describe the same algorithm
+- Two error types that handle the same failure mode differently
+Only add these when the similarity is genuinely non-obvious and cross-cutting. Do not add them for trivially similar things.
+
+Hyperedges: if 3 or more nodes clearly participate together in a shared concept, flow, or pattern that is not captured by pairwise edges alone, add a hyperedge to a top-level `hyperedges` array. Examples:
+- All classes that implement a common protocol or interface
+- All functions in an authentication flow (even if they don't all call each other)
+- All concepts from a paper section that form one coherent idea
+Use sparingly — only when the group relationship adds information beyond the pairwise edges. Maximum 3 hyperedges per chunk.
+
+If a file has YAML frontmatter (--- ... ---), copy source_url, captured_at, author,
+  contributor onto every node from that file.
+
+confidence_score is REQUIRED on every edge - never omit it, never use 0.5 as a default:
+- EXTRACTED edges: confidence_score = 1.0 always
+- INFERRED edges: reason about each edge individually.
+  Direct structural evidence (shared data structure, clear dependency): 0.8-0.9.
+  Reasonable inference with some uncertainty: 0.6-0.7.
+  Weak or speculative: 0.4-0.5. Most edges should be 0.6-0.9, not 0.5.
+- AMBIGUOUS edges: 0.1-0.3
+
+Output exactly this JSON (no other text):
+{"nodes":[{"id":"filestem_entityname","label":"Human Readable Name","file_type":"code|document|paper|image","source_file":"relative/path","source_location":null,"source_url":null,"captured_at":null,"author":null,"contributor":null}],"edges":[{"source":"node_id","target":"node_id","relation":"calls|implements|references|cites|conceptually_related_to|shares_data_with|semantically_similar_to|rationale_for","confidence":"EXTRACTED|INFERRED|AMBIGUOUS","confidence_score":1.0,"source_file":"relative/path","source_location":null,"weight":1.0}],"hyperedges":[{"id":"snake_case_id","label":"Human Readable Label","nodes":["node_id1","node_id2","node_id3"],"relation":"participate_in|implement|form","confidence":"EXTRACTED|INFERRED","confidence_score":0.75,"source_file":"relative/path"}],"input_tokens":0,"output_tokens":0}
+```
+
+**Step B3 - Collect, cache, and merge**
+
+Wait for all subagents. For each result:
+- If a subagent returned valid JSON with `nodes` and `edges`, include it and save each file's nodes/edges to the cache
+- If a subagent failed or returned invalid JSON, print a warning and skip that chunk - do not abort
+
+If more than half the chunks failed, stop and tell the user.
+
+Save new results to cache:
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.cache import save_semantic_cache
+from pathlib import Path
+
+new = json.loads(Path('.graphify_semantic_new.json').read_text()) if Path('.graphify_semantic_new.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]}
+saved = save_semantic_cache(new.get('nodes', []), new.get('edges', []), new.get('hyperedges', []))
+print(f'Cached {saved} files')
+"
+```
+
+Merge cached + new results into `.graphify_semantic.json`:
+```bash
+$(cat .graphify_python) -c "
+import json
+from pathlib import Path
+
+cached = json.loads(Path('.graphify_cached.json').read_text()) if Path('.graphify_cached.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]}
+new = json.loads(Path('.graphify_semantic_new.json').read_text()) if Path('.graphify_semantic_new.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]}
+
+all_nodes = cached['nodes'] + new.get('nodes', [])
+all_edges = cached['edges'] + new.get('edges', [])
+all_hyperedges = cached.get('hyperedges', []) + new.get('hyperedges', [])
+seen = set()
+deduped = []
+for n in all_nodes:
+    if n['id'] not in seen:
+        seen.add(n['id'])
+        deduped.append(n)
+
+merged = {
+    'nodes': deduped,
+    'edges': all_edges,
+    'hyperedges': all_hyperedges,
+    'input_tokens': new.get('input_tokens', 0),
+    'output_tokens': new.get('output_tokens', 0),
+}
+Path('.graphify_semantic.json').write_text(json.dumps(merged, indent=2))
+print(f'Extraction complete - {len(deduped)} nodes, {len(all_edges)} edges ({len(cached[\"nodes\"])} from cache, {len(new.get(\"nodes\",[]))} new)')
+"
+```
+Clean up temp files: `rm -f .graphify_cached.json .graphify_uncached.txt .graphify_semantic_new.json`
+
+#### Part C - Merge AST + semantic into final extraction
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from pathlib import Path
+
+ast = json.loads(Path('.graphify_ast.json').read_text())
+sem = json.loads(Path('.graphify_semantic.json').read_text())
+
+# Merge: AST nodes first, semantic nodes deduplicated by id
+seen = {n['id'] for n in ast['nodes']}
+merged_nodes = list(ast['nodes'])
+for n in sem['nodes']:
+    if n['id'] not in seen:
+        merged_nodes.append(n)
+        seen.add(n['id'])
+
+merged_edges = ast['edges'] + sem['edges']
+merged_hyperedges = sem.get('hyperedges', [])
+merged = {
+    'nodes': merged_nodes,
+    'edges': merged_edges,
+    'hyperedges': merged_hyperedges,
+    'input_tokens': sem.get('input_tokens', 0),
+    'output_tokens': sem.get('output_tokens', 0),
+}
+Path('.graphify_extract.json').write_text(json.dumps(merged, indent=2))
+total = len(merged_nodes)
+edges = len(merged_edges)
+print(f'Merged: {total} nodes, {edges} edges ({len(ast[\"nodes\"])} AST + {len(sem[\"nodes\"])} semantic)')
+"
+```
+
+### Step 4 - Build graph, cluster, analyze, generate outputs
+
+```bash
+mkdir -p graphify-out
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.cluster import cluster, score_all
+from graphify.analyze import god_nodes, surprising_connections, suggest_questions
+from graphify.report import generate
+from graphify.export import to_json
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+detection  = json.loads(Path('.graphify_detect.json').read_text())
+
+G = build_from_json(extraction)
+communities = cluster(G)
+cohesion = score_all(G, communities)
+tokens = {'input': extraction.get('input_tokens', 0), 'output': extraction.get('output_tokens', 0)}
+gods = god_nodes(G)
+surprises = surprising_connections(G, communities)
+labels = {cid: 'Community ' + str(cid) for cid in communities}
+# Placeholder questions - regenerated with real labels in Step 5
+questions = suggest_questions(G, communities, labels)
+
+report = generate(G, communities, cohesion, labels, gods, surprises, detection, tokens, 'INPUT_PATH', suggested_questions=questions)
+Path('graphify-out/GRAPH_REPORT.md').write_text(report)
+to_json(G, communities, 'graphify-out/graph.json')
+
+analysis = {
+    'communities': {str(k): v for k, v in communities.items()},
+    'cohesion': {str(k): v for k, v in cohesion.items()},
+    'gods': gods,
+    'surprises': surprises,
+    'questions': questions,
+}
+Path('.graphify_analysis.json').write_text(json.dumps(analysis, indent=2))
+if G.number_of_nodes() == 0:
+    print('ERROR: Graph is empty - extraction produced no nodes.')
+    print('Possible causes: all files were skipped, binary-only corpus, or extraction failed.')
+    raise SystemExit(1)
+print(f'Graph: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges, {len(communities)} communities')
+"
+```
+
+If this step prints `ERROR: Graph is empty`, stop and tell the user what happened - do not proceed to labeling or visualization.
+
+Replace INPUT_PATH with the actual path.
+
+### Step 5 - Label communities
+
+Read `.graphify_analysis.json`. For each community key, look at its node labels and write a 2-5 word plain-language name (e.g. "Attention Mechanism", "Training Pipeline", "Data Loading").
+
+Then regenerate the report and save the labels for the visualizer:
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.cluster import score_all
+from graphify.analyze import god_nodes, surprising_connections, suggest_questions
+from graphify.report import generate
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+detection  = json.loads(Path('.graphify_detect.json').read_text())
+analysis   = json.loads(Path('.graphify_analysis.json').read_text())
+
+G = build_from_json(extraction)
+communities = {int(k): v for k, v in analysis['communities'].items()}
+cohesion = {int(k): v for k, v in analysis['cohesion'].items()}
+tokens = {'input': extraction.get('input_tokens', 0), 'output': extraction.get('output_tokens', 0)}
+
+# LABELS - replace these with the names you chose above
+labels = LABELS_DICT
+
+# Regenerate questions with real community labels (labels affect question phrasing)
+questions = suggest_questions(G, communities, labels)
+
+report = generate(G, communities, cohesion, labels, analysis['gods'], analysis['surprises'], detection, tokens, 'INPUT_PATH', suggested_questions=questions)
+Path('graphify-out/GRAPH_REPORT.md').write_text(report)
+Path('.graphify_labels.json').write_text(json.dumps({str(k): v for k, v in labels.items()}))
+print('Report updated with community labels')
+"
+```
+
+Replace `LABELS_DICT` with the actual dict you constructed (e.g. `{0: "Attention Mechanism", 1: "Training Pipeline"}`).
+Replace INPUT_PATH with the actual path.
+
+### Step 6 - Generate Obsidian vault (opt-in) + HTML
+
+**Generate HTML always** (unless `--no-viz`). **Obsidian vault only if `--obsidian` was explicitly given** — skip it otherwise, it generates one file per node.
+
+If `--obsidian` was given:
+
+- If `--obsidian-dir <path>` was also given, use that path as the vault directory. Otherwise default to `graphify-out/obsidian`.
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.export import to_obsidian, to_canvas
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+analysis   = json.loads(Path('.graphify_analysis.json').read_text())
+labels_raw = json.loads(Path('.graphify_labels.json').read_text()) if Path('.graphify_labels.json').exists() else {}
+
+G = build_from_json(extraction)
+communities = {int(k): v for k, v in analysis['communities'].items()}
+cohesion = {int(k): v for k, v in analysis['cohesion'].items()}
+labels = {int(k): v for k, v in labels_raw.items()}
+
+obsidian_dir = 'OBSIDIAN_DIR'  # replace with --obsidian-dir value, or 'graphify-out/obsidian' if not given
+
+n = to_obsidian(G, communities, obsidian_dir, community_labels=labels or None, cohesion=cohesion)
+print(f'Obsidian vault: {n} notes in {obsidian_dir}/')
+
+to_canvas(G, communities, f'{obsidian_dir}/graph.canvas', community_labels=labels or None)
+print(f'Canvas: {obsidian_dir}/graph.canvas - open in Obsidian for structured community layout')
+print()
+print(f'Open {obsidian_dir}/ as a vault in Obsidian.')
+print('  Graph view   - nodes colored by community (set automatically)')
+print('  graph.canvas - structured layout with communities as groups')
+print('  _COMMUNITY_* - overview notes with cohesion scores and dataview queries')
+"
+```
+
+Generate the HTML graph (always, unless `--no-viz`):
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.export import to_html
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+analysis   = json.loads(Path('.graphify_analysis.json').read_text())
+labels_raw = json.loads(Path('.graphify_labels.json').read_text()) if Path('.graphify_labels.json').exists() else {}
+
+G = build_from_json(extraction)
+communities = {int(k): v for k, v in analysis['communities'].items()}
+labels = {int(k): v for k, v in labels_raw.items()}
+
+if G.number_of_nodes() > 5000:
+    print(f'Graph has {G.number_of_nodes()} nodes - too large for HTML viz. Use Obsidian vault instead.')
+else:
+    to_html(G, communities, 'graphify-out/graph.html', community_labels=labels or None)
+    print('graph.html written - open in any browser, no server needed')
+"
+```
+
+### Step 7 - Neo4j export (only if --neo4j or --neo4j-push flag)
+
+**If `--neo4j`** - generate a Cypher file for manual import:
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.export import to_cypher
+from pathlib import Path
+
+G = build_from_json(json.loads(Path('.graphify_extract.json').read_text()))
+to_cypher(G, 'graphify-out/cypher.txt')
+print('cypher.txt written - import with: cypher-shell < graphify-out/cypher.txt')
+"
+```
+
+**If `--neo4j-push <uri>`** - push directly to a running Neo4j instance. Ask the user for credentials if not provided:
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.cluster import cluster
+from graphify.export import push_to_neo4j
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+analysis   = json.loads(Path('.graphify_analysis.json').read_text())
+G = build_from_json(extraction)
+communities = {int(k): v for k, v in analysis['communities'].items()}
+
+result = push_to_neo4j(G, uri='NEO4J_URI', user='NEO4J_USER', password='NEO4J_PASSWORD', communities=communities)
+print(f'Pushed to Neo4j: {result[\"nodes\"]} nodes, {result[\"edges\"]} edges')
+"
+```
+
+Replace `NEO4J_URI`, `NEO4J_USER`, `NEO4J_PASSWORD` with actual values. Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates.
+
+### Step 7b - SVG export (only if --svg flag)
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.export import to_svg
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+analysis   = json.loads(Path('.graphify_analysis.json').read_text())
+labels_raw = json.loads(Path('.graphify_labels.json').read_text()) if Path('.graphify_labels.json').exists() else {}
+
+G = build_from_json(extraction)
+communities = {int(k): v for k, v in analysis['communities'].items()}
+labels = {int(k): v for k, v in labels_raw.items()}
+
+to_svg(G, communities, 'graphify-out/graph.svg', community_labels=labels or None)
+print('graph.svg written - embeds in Obsidian, Notion, GitHub READMEs')
+"
+```
+
+### Step 7c - GraphML export (only if --graphml flag)
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.build import build_from_json
+from graphify.export import to_graphml
+from pathlib import Path
+
+extraction = json.loads(Path('.graphify_extract.json').read_text())
+analysis   = json.loads(Path('.graphify_analysis.json').read_text())
+
+G = build_from_json(extraction)
+communities = {int(k): v for k, v in analysis['communities'].items()}
+
+to_graphml(G, communities, 'graphify-out/graph.graphml')
+print('graph.graphml written - open in Gephi, yEd, or any GraphML tool')
+"
+```
+
+### Step 7d - MCP server (only if --mcp flag)
+
+```bash
+python3 -m graphify.serve graphify-out/graph.json
+```
+
+This starts a stdio MCP server that exposes tools: `query_graph`, `get_node`, `get_neighbors`, `get_community`, `god_nodes`, `graph_stats`, `shortest_path`. Add to Claude Desktop or any MCP-compatible agent orchestrator so other agents can query the graph live.
+
+To configure in Claude Desktop, add to `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "graphify": {
+      "command": "python3",
+      "args": ["-m", "graphify.serve", "/absolute/path/to/graphify-out/graph.json"]
+    }
+  }
+}
+```
+
+### Step 8 - Token reduction benchmark (only if total_words > 5000)
+
+If `total_words` from `.graphify_detect.json` is greater than 5,000, run:
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.benchmark import run_benchmark, print_benchmark
+from pathlib import Path
+
+detection = json.loads(Path('.graphify_detect.json').read_text())
+result = run_benchmark('graphify-out/graph.json', corpus_words=detection['total_words'])
+print_benchmark(result)
+"
+```
+
+Print the output directly in chat. If `total_words <= 5000`, skip silently - the graph value is structural clarity, not token compression, for small corpora.
+
+---
+
+### Step 9 - Save manifest, update cost tracker, clean up, and report
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from pathlib import Path
+from datetime import datetime, timezone
+from graphify.detect import save_manifest
+
+# Save manifest for --update
+detect = json.loads(Path('.graphify_detect.json').read_text())
+save_manifest(detect['files'])
+
+# Update cumulative cost tracker
+extract = json.loads(Path('.graphify_extract.json').read_text())
+input_tok = extract.get('input_tokens', 0)
+output_tok = extract.get('output_tokens', 0)
+
+cost_path = Path('graphify-out/cost.json')
+if cost_path.exists():
+    cost = json.loads(cost_path.read_text())
+else:
+    cost = {'runs': [], 'total_input_tokens': 0, 'total_output_tokens': 0}
+
+cost['runs'].append({
+    'date': datetime.now(timezone.utc).isoformat(),
+    'input_tokens': input_tok,
+    'output_tokens': output_tok,
+    'files': detect.get('total_files', 0),
+})
+cost['total_input_tokens'] += input_tok
+cost['total_output_tokens'] += output_tok
+cost_path.write_text(json.dumps(cost, indent=2))
+
+print(f'This run: {input_tok:,} input tokens, {output_tok:,} output tokens')
+print(f'All time: {cost[\"total_input_tokens\"]:,} input, {cost[\"total_output_tokens\"]:,} output ({len(cost[\"runs\"])} runs)')
+"
+rm -f .graphify_detect.json .graphify_extract.json .graphify_ast.json .graphify_semantic.json .graphify_analysis.json .graphify_labels.json .graphify_python
+rm -f graphify-out/.needs_update 2>/dev/null || true
+```
+
+Tell the user (omit the obsidian line unless --obsidian was given):
+```
+Graph complete. Outputs in PATH_TO_DIR/graphify-out/
+
+  graph.html            - interactive graph, open in browser
+  GRAPH_REPORT.md       - audit report
+  graph.json            - raw graph data
+  obsidian/             - Obsidian vault (only if --obsidian was given)
+```
+
+Replace PATH_TO_DIR with the actual absolute path of the directory that was processed.
+
+Then paste these sections from GRAPH_REPORT.md directly into the chat:
+- God Nodes
+- Surprising Connections
+- Suggested Questions
+
+Do NOT paste the full report - just those three sections. Keep it concise.
+
+Then immediately offer to explore. Pick the single most interesting suggested question from the report - the one that crosses the most community boundaries or has the most surprising bridge node - and ask:
+
+> "The most interesting question this graph can answer: **[question]**. Want me to trace it?"
+
+If the user says yes, run `/graphify query "[question]"` on the graph and walk them through the answer using the graph structure - which nodes connect, which community boundaries get crossed, what the path reveals. Keep going as long as they want to explore. Each answer should end with a natural follow-up ("this connects to X - want to go deeper?") so the session feels like navigation, not a one-shot report.
+
+The graph is the map. Your job after the pipeline is to be the guide.
+
+---
+
+## For --update (incremental re-extraction)
+
+Use when you've added or modified files since the last run. Only re-extracts changed files - saves tokens and time.
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.detect import detect_incremental, save_manifest
+from pathlib import Path
+
+result = detect_incremental(Path('INPUT_PATH'))
+new_total = result.get('new_total', 0)
+print(json.dumps(result, indent=2))
+Path('.graphify_incremental.json').write_text(json.dumps(result))
+if new_total == 0:
+    print('No files changed since last run. Nothing to update.')
+    raise SystemExit(0)
+print(f'{new_total} new/changed file(s) to re-extract.')
+"
+```
+
+If new files exist, first check whether all changed files are code files:
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from pathlib import Path
+
+result = json.loads(open('.graphify_incremental.json').read()) if Path('.graphify_incremental.json').exists() else {}
+code_exts = {'.py','.ts','.js','.go','.rs','.java','.cpp','.c','.rb','.swift','.kt','.cs','.scala','.php','.cc','.cxx','.hpp','.h','.kts','.lua','.toc'}
+new_files = result.get('new_files', {})
+all_changed = [f for files in new_files.values() for f in files]
+code_only = all(Path(f).suffix.lower() in code_exts for f in all_changed)
+print('code_only:', code_only)
+"
+```
+
+If `code_only` is True: print `[graphify update] Code-only changes detected - skipping semantic extraction (no LLM needed)`, run only Step 3A (AST) on the changed files, skip Step 3B entirely (no subagents), then go straight to merge and Steps 4–8.
+
+If `code_only` is False (any changed file is a doc/paper/image): run the full Steps 3A–3C pipeline as normal.
+
+Then:
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.build import build_from_json
+from graphify.export import to_json
+from networkx.readwrite import json_graph
+import networkx as nx
+from pathlib import Path
+
+# Load existing graph
+existing_data = json.loads(Path('graphify-out/graph.json').read_text())
+G_existing = json_graph.node_link_graph(existing_data, edges='links')
+
+# Load new extraction
+new_extraction = json.loads(Path('.graphify_extract.json').read_text())
+G_new = build_from_json(new_extraction)
+
+# Merge: new nodes/edges into existing graph
+G_existing.update(G_new)
+print(f'Merged: {G_existing.number_of_nodes()} nodes, {G_existing.number_of_edges()} edges')
+" 
+```
+
+Then run Steps 4–8 on the merged graph as normal.
+
+After Step 4, show the graph diff:
+
+```bash
+$(cat .graphify_python) -c "
+import json
+from graphify.analyze import graph_diff
+from graphify.build import build_from_json
+from networkx.readwrite import json_graph
+import networkx as nx
+from pathlib import Path
+
+# Load old graph (before update) from backup written before merge
+old_data = json.loads(Path('.graphify_old.json').read_text()) if Path('.graphify_old.json').exists() else None
+new_extract = json.loads(Path('.graphify_extract.json').read_text())
+G_new = build_from_json(new_extract)
+
+if old_data:
+    G_old = json_graph.node_link_graph(old_data, edges='links')
+    diff = graph_diff(G_old, G_new)
+    print(diff['summary'])
+    if diff['new_nodes']:
+        print('New nodes:', ', '.join(n['label'] for n in diff['new_nodes'][:5]))
+    if diff['new_edges']:
+        print('New edges:', len(diff['new_edges']))
+"
+```
+
+Before the merge step, save the old graph: `cp graphify-out/graph.json .graphify_old.json`
+Clean up after: `rm -f .graphify_old.json`
+
+---
+
+## For --cluster-only
+
+Skip Steps 1–3. Load the existing graph from `graphify-out/graph.json` and re-run clustering:
+
+```bash
+$(cat .graphify_python) -c "
+import sys, json
+from graphify.cluster import cluster, score_all
+from graphify.analyze import god_nodes, surprising_connections
+from graphify.report import generate
+from graphify.export import to_json
+from networkx.readwrite import json_graph
+import networkx as nx
+from pathlib import Path
+
+data = json.loads(Path('graphify-out/graph.json').read_text())
+G = json_graph.node_link_graph(data, edges='links')
+
+detection = {'total_files': 0, 'total_words': 99999, 'needs_graph': True, 'warning': None, 'files': {}}
+
+communities = cluster(G)
+cohesion = score_all(G, communities)
+gods = god_nodes(G)
+surprises = surprising_connections(G, communities)
+labels = {cid: 'Community ' + str(cid) for cid in communities}
+report = generate(G, communities, cohesion, labels, gods, surprises, detection, {'input':0,'output':0}, 'INPUT_PATH')
+Path('graphify-out/GRAPH_REPORT.md').write_text(report)
+to_json(G, communities, 'graphify-out/graph.json')
+print(f'Re-clustered: {len(communities)} communities')
+"
+```
+
+Then proceed to Step 5 (Labeling) as normal.

apps/bot/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@kord/bot",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "jest",
+    "check-i18n": "tsx scripts/check-i18n-tests.ts"
+  },
+  "dependencies": {
+    "@discordjs/opus": "^0.10.0",
+    "@discordjs/voice": "^0.19.2",
+    "@grpc/grpc-js": "^1.14.3",
+    "@kord/db": "workspace:*",
+    "@kord/grpc-contracts": "workspace:*",
+    "discord.js": "^14.25.1",
+    "dotenv": "^17.3.1",
+    "ffmpeg-static": "^5.3.0",
+    "log4js": "^6.9.1",
+    "prism-media": "^1.3.5",
+    "sharp": "^0.34.5",
+    "youtubei.js": "^17.0.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.5.0",
+    "jest": "^30.3.0",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0"
+  }
+}

apps/bot/scratch_debug_env.js

@@ -0,0 +1,10 @@
+const path = require('path');
+console.log('CWD:', process.cwd());
+console.log('__dirname:', __dirname);
+console.log('.env path:', path.resolve(process.cwd(), '.env'));
+const fs = require('fs');
+console.log('.env exists in CWD?', fs.existsSync(path.resolve(process.cwd(), '.env')));
+console.log('.env exists in root?', fs.existsSync(path.resolve(process.cwd(), '../../.env')));
+
+require('dotenv').config({ path: path.resolve(process.cwd(), '../../.env') });
+console.log('DATABASE_URL from ../../.env:', process.env.DATABASE_URL);

apps/bot/scripts/setup-kord-user-log-file.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# Run ON THE SERVER as the same user that runs kord (e.g. psa), after: ssh psa@server
+# Switches kord user service from journal-only to append stdout/stderr under LOG_DIR/kord.log
+# LOG_DIR is read from $KORD_HOME/.env (LOG_DIR=...) when present, else $KORD_HOME/logs.
+
+set -euo pipefail
+
+KORD_HOME="${KORD_HOME:-$HOME/kord}"
+ENV_FILE="${KORD_ENV_FILE:-$KORD_HOME/.env}"
+UNIT="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user/kord.service"
+
+# Last LOG_DIR= line from .env; strip quotes and ~ ; relative paths are under KORD_HOME
+resolve_log_dir() {
+  local default="${KORD_HOME}/logs" line raw
+  [[ -f "$ENV_FILE" ]] || { echo "$default"; return; }
+  line="$(grep -E '^[[:space:]]*LOG_DIR[[:space:]]*=' "$ENV_FILE" | tail -n1 || true)"
+  [[ -z "$line" ]] && { echo "$default"; return; }
+  raw="${line#*=}"
+  raw="$(printf '%s' "$raw" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' -e $'s/\r$//')"
+  if [[ "$raw" =~ ^\".*\"$ ]]; then raw="${raw#\"}"; raw="${raw%\"}"; fi
+  if [[ "$raw" =~ ^\'.*\'$ ]]; then raw="${raw#\'}"; raw="${raw%\'}"; fi
+  raw="${raw//\~/$HOME}"
+  [[ -z "$raw" ]] && { echo "$default"; return; }
+  if [[ "$raw" = /* ]]; then
+    echo "$raw"
+  else
+    echo "${KORD_HOME}/${raw#./}"
+  fi
+}
+
+LOG_DIR="$(resolve_log_dir)"
+LOG_FILE="${LOG_DIR}/kord.log"
+
+mkdir -p "$LOG_DIR"
+
+if [[ ! -f "$UNIT" ]]; then
+  echo "Unit not found: $UNIT" >&2
+  exit 1
+fi
+
+cp -a "$UNIT" "${UNIT}.bak.$(date +%Y%m%d%H%M%S)"
+
+# Point journal or any previous append paths at the log file derived from .env LOG_DIR
+sed -i \
+  -e "s|^StandardOutput=journal|StandardOutput=append:${LOG_FILE}|" \
+  -e "s|^StandardError=journal|StandardError=append:${LOG_FILE}|" \
+  "$UNIT"
+sed -i \
+  -e "s|^StandardOutput=append:.*|StandardOutput=append:${LOG_FILE}|" \
+  -e "s|^StandardError=append:.*|StandardError=append:${LOG_FILE}|" \
+  "$UNIT"
+
+# systemd opens StandardOutput=append before ExecStart; missing parent dir → status 209/STDOUT
+sed -i '/^ExecStartPre=-\/usr\/bin\/mkdir -p /d' "$UNIT"
+tmp="$(mktemp)"
+inserted=0
+while IFS= read -r line || [[ -n "$line" ]]; do
+  if [[ "$line" =~ ^ExecStart= ]] && [[ "$inserted" -eq 0 ]]; then
+    printf '%s\n' "ExecStartPre=-/usr/bin/mkdir -p ${LOG_DIR}"
+    inserted=1
+  fi
+  printf '%s\n' "$line"
+done <"$UNIT" >"$tmp"
+mv "$tmp" "$UNIT"
+
+systemctl --user daemon-reload
+systemctl --user restart kord
+
+sleep 2
+systemctl --user --no-pager status kord || true
+
+echo "--- Last lines of $LOG_FILE (if any) ---"
+if [[ -f "$LOG_FILE" ]]; then
+  tail -n 20 "$LOG_FILE"
+else
+  echo "(file not created yet; check status above)"
+fi
+
+echo
+echo "LOG_DIR=$LOG_DIR"
+echo "Follow logs: tail -f $LOG_FILE"

apps/bot/src/client/KordClient.ts

@@ -5,6 +5,8 @@ import { loadCommands } from '../handlers/CommandLoader';
 import { loadEvents } from '../handlers/EventLoader';
 import { handleGlobalExceptions } from '../utils/errorHandler';
 import { connectDB } from '../database';
+import { FeverService } from '../services/FeverService';
+
 
 export class KordClient extends Client {
   public commands: Collection<string, any> = new Collection();
@@ -16,8 +18,10 @@ export class KordClient extends Client {
         GatewayIntentBits.GuildVoiceStates,
         GatewayIntentBits.GuildMessages,
         GatewayIntentBits.MessageContent,
+        GatewayIntentBits.GuildMembers,
         GatewayIntentBits.GuildInvites,
       ],
+
       partials: [Partials.Message, Partials.Channel, Partials.GuildMember],
     });
   }

apps/bot/src/commands/audit.ts

@@ -118,9 +118,8 @@ export default {
 
         if (action === 'set') {
           const channel = interaction.options.getChannel('channel') as TextChannel;
-          if (!channel) return interaction.reply({ content: '❌ `channel` 옵션을 선택해주세요.', ephemeral: true });
+          if (!channel) return interaction.editReply({ content: '❌ `channel` 옵션을 선택해주세요.' });
 
-          await interaction.deferReply({ ephemeral: true });
           const botMember = guild.members.me;
           if (!botMember) return;
           const perms = channel.permissionsFor(botMember);
@@ -141,13 +140,11 @@ export default {
         }
 
         if (action === 'clear') {
-          await interaction.deferReply({ ephemeral: true });
           await auditLogService.clearChannel(guild.id);
           return interaction.editReply({ content: `✅ 감사 채널 설정이 해제되었습니다.` });
         }
 
         if (action === 'status') {
-          await interaction.deferReply({ ephemeral: true });
           const config = await auditLogService.getChannel(guild.id);
           if (!config) return interaction.editReply({ content: `설정된 감사 채널이 없습니다. 먼저 \`/audit channel action:set\` 명령어로 채널을 설정해주세요.` });
 
@@ -168,10 +165,9 @@ export default {
           const enable = interaction.options.getBoolean('enable');
 
           if (!category || enable === null) {
-            return interaction.reply({ content: '❌ `category` 및 `enable` 옵션을 모두 입력해주세요.', ephemeral: true });
+            return interaction.editReply({ content: '❌ `category` 및 `enable` 옵션을 모두 입력해주세요.' });
           }
 
-          await interaction.deferReply({ ephemeral: true });
           const config = await auditLogService.getChannel(guild.id);
           if (!config) return interaction.editReply({ content: `설정된 감사 채널이 없습니다. 먼저 \`/audit channel action:set\` 명령어로 채널을 설정해주세요.` });
 
@@ -185,7 +181,6 @@ export default {
         const action = interaction.options.getString('action', true);
 
         if (action === 'permissions') {
-          await interaction.deferReply({ ephemeral: true });
           const results = await PermissionAuditService.auditGuild(guild);
           if (results.length === 0) return interaction.editReply({ content: t(locale, 'commands.permissionAudit.noResults') });
 
@@ -230,8 +225,7 @@ export default {
       }
     } catch (error) {
       console.error('Error in audit command', error);
-      const reply = interaction.deferred ? interaction.editReply : interaction.reply;
-      return (reply as any)({ content: '명령 실행 중 오류가 발생했습니다.', ephemeral: true });
+      return interaction.editReply({ content: '명령 실행 중 오류가 발생했습니다.' });
     }
   },
 };

apps/bot/src/commands/autorole.ts

@@ -0,0 +1,74 @@
+import { 
+  SlashCommandBuilder, 
+  ChatInputCommandInteraction, 
+  PermissionFlagsBits, 
+  EmbedBuilder, 
+  Colors, 
+  ActionRowBuilder, 
+  ButtonBuilder, 
+  ButtonStyle,
+  RoleSelectMenuBuilder,
+  ComponentType
+} from 'discord.js';
+import { Command, CommandTrait } from '../core/command';
+import { autoRoleService } from '../services/AutoRoleService';
+import { t, SupportedLocale } from '../i18n';
+
+class AutoRoleCommand extends Command {
+  protected override readonly trait = CommandTrait.General;
+  protected override guildOnly = true;
+
+  protected override define() {
+    return new SlashCommandBuilder()
+      .setName('autorole')
+      .setDescription('Configure automatic role assignment upon joining.')
+      .setDescriptionLocalizations({
+        ko: '입장 시 역할을 자동으로 부여하는 기능을 설정합니다.',
+      })
+      .setDefaultMemberPermissions(PermissionFlagsBits.Administrator);
+  }
+
+  protected override async handle(interaction: ChatInputCommandInteraction, locale: SupportedLocale) {
+    const guild = interaction.guild!;
+    const dashboard = await generateAutoRoleDashboard(guild, locale);
+    await interaction.editReply({
+      ...dashboard
+    });
+  }
+}
+
+export async function generateAutoRoleDashboard(guild: import('discord.js').Guild, locale: SupportedLocale) {
+  const config = await autoRoleService.getConfig(guild.id);
+
+  const embed = new EmbedBuilder()
+    .setTitle(t(locale, 'commands.autorole.statusTitle'))
+    .setColor(Colors.Blue)
+    .setDescription(t(locale, 'commands.autorole.description') || '유저 및 봇이 서버에 접속할 때 자동으로 부여할 기본 역할을 선택하세요. 역할을 선택하면 즉시 활성화됩니다.');
+
+  const userSelect = new RoleSelectMenuBuilder()
+    .setCustomId('autorole_select_user')
+    .setPlaceholder(t(locale, 'commands.autorole.userRolePlaceholder'))
+    .setMaxValues(10);
+  if (config?.userRoleIds && config.userRoleIds.length > 0) {
+    userSelect.addDefaultRoles(config.userRoleIds);
+  }
+
+  const rowUserRole = new ActionRowBuilder<RoleSelectMenuBuilder>().addComponents(userSelect);
+
+  const botSelect = new RoleSelectMenuBuilder()
+    .setCustomId('autorole_select_bot')
+    .setPlaceholder(t(locale, 'commands.autorole.botRolePlaceholder'))
+    .setMaxValues(10);
+  if (config?.botRoleIds && config.botRoleIds.length > 0) {
+    botSelect.addDefaultRoles(config.botRoleIds);
+  }
+
+  const rowBotRole = new ActionRowBuilder<RoleSelectMenuBuilder>().addComponents(botSelect);
+
+  return {
+    embeds: [embed],
+    components: [rowUserRole, rowBotRole]
+  };
+}
+
+export default new AutoRoleCommand().toModule();

apps/bot/src/commands/config.ts

@@ -76,14 +76,13 @@ export default {
       if (action === 'language') {
         const newLocale = interaction.options.getString('locale') as SupportedLocale;
         if (!newLocale) {
-          return interaction.reply({ 
+          return interaction.editReply({ 
             content: '❌ `locale` 옵션을 선택해주세요.', 
-            ephemeral: true 
           });
         }
         
         if (!SUPPORTED_LOCALES.includes(newLocale)) {
-          return interaction.reply({ content: `Unsupported locale: ${newLocale}`, ephemeral: true });
+          return interaction.editReply({ content: `Unsupported locale: ${newLocale}` });
         }
 
         await prisma.guildConfig.upsert({
@@ -92,9 +91,8 @@ export default {
           create: { guildId: interaction.guildId, locale: newLocale },
         });
 
-        return interaction.reply({
+        return interaction.editReply({
           content: t(newLocale, 'commands.language.serverSet', { locale: newLocale === 'ko' ? '한국어' : 'English' }),
-          ephemeral: true,
         });
       }
     }
@@ -132,7 +130,7 @@ export default {
         .setTitle(t(locale, 'commands.config.title'))
         .setDescription(`${label}: **${state}**`);
 
-      return interaction.reply({ embeds: [embed], ephemeral: true });
+      return interaction.editReply({ embeds: [embed] });
     }
   },
 };

apps/bot/src/commands/event.ts

@@ -201,26 +201,23 @@ export default {
 
       const startsAt = parseSeoulDateTime(date, time);
       if (!startsAt) {
-        await interaction.reply({
+        await interaction.editReply({
           content: `${t(locale, 'commands.event.invalidDateTime')}\n${t(locale, 'commands.event.invalidDateTimeResolution')}`,
-          ephemeral: true,
         });
         return;
       }
 
       if (startsAt.getTime() <= Date.now()) {
-        await interaction.reply({
+        await interaction.editReply({
           content: `${t(locale, 'commands.event.invalidPastDateTime')}\n${t(locale, 'commands.event.invalidPastDateTimeResolution')}`,
-          ephemeral: true,
         });
         return;
       }
 
       const reminderOffsets = parseReminderOffsets(reminderRaw);
       if (!reminderOffsets) {
-        await interaction.reply({
+        await interaction.editReply({
           content: `${t(locale, 'commands.event.invalidReminderOffsets')}\n${t(locale, 'commands.event.invalidReminderOffsetsResolution')}`,
-          ephemeral: true,
         });
         return;
       }
@@ -252,7 +249,7 @@ export default {
         )
         .setTimestamp();
 
-      await interaction.reply({ embeds: [embed], ephemeral: true });
+      await interaction.editReply({ embeds: [embed] });
       return;
     }
 
@@ -268,9 +265,8 @@ export default {
       });
 
       if (events.length === 0) {
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.event.listEmpty'),
-          ephemeral: true,
         });
         return;
       }
@@ -295,7 +291,7 @@ export default {
         });
       }
 
-      await interaction.reply({ embeds: [embed], ephemeral: true });
+      await interaction.editReply({ embeds: [embed] });
       return;
     }
 
@@ -311,9 +307,8 @@ export default {
       });
 
       if (!event) {
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.event.cancelNotFound', { id }),
-          ephemeral: true,
         });
         return;
       }
@@ -323,9 +318,8 @@ export default {
         data: { status: 'CANCELLED' },
       });
 
-      await interaction.reply({
+      await interaction.editReply({
         content: t(locale, 'commands.event.cancelSuccess', { id }),
-        ephemeral: true,
       });
       return;
     }
@@ -340,34 +334,30 @@ export default {
       });
 
       if (!event) {
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.event.cancelNotFound', { id }),
-          ephemeral: true,
         });
         return;
       }
 
       if (!event.announcementChannelId) {
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.event.announceNotAvailable'),
-          ephemeral: true,
         });
         return;
       }
 
       try {
         await EventService.announceEvent(interaction.guild!, event.id);
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.event.announceSuccess', {
             id,
             channel: `<#${event.announcementChannelId}>`,
           }),
-          ephemeral: true,
         });
       } catch {
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.event.announceNotAvailable'),
-          ephemeral: true,
         });
       }
     }

apps/bot/src/commands/fishing.ts

@@ -0,0 +1,291 @@
+import {
+  ChannelType,
+  ChatInputCommandInteraction,
+  EmbedBuilder,
+  SlashCommandBuilder,
+} from 'discord.js';
+import { prisma } from '../database';
+import { SupportedLocale, t } from '../i18n';
+import { FishingService } from '../services/FishingService';
+
+export default {
+  data: new SlashCommandBuilder()
+    .setName('fishing')
+    .setDescription('Play the fishing mini-game.')
+    .setDescriptionLocalizations({
+      ko: '낚시 미니게임을 플레이합니다.',
+    })
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName('enter')
+        .setDescription('Create or reopen your fishing thread.')
+        .setDescriptionLocalizations({
+          ko: '낚시 전용 스레드를 생성하거나 다시 엽니다.',
+        }),
+    )
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName('cast')
+        .setDescription('Start a fishing session inside your fishing thread.')
+        .setDescriptionLocalizations({
+          ko: '자신의 낚시 스레드 안에서 낚시 세션을 시작합니다.',
+        }),
+    )
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName('end')
+        .setDescription('End your active fishing session and delete the thread.')
+        .setDescriptionLocalizations({
+          ko: '진행 중인 낚시 세션을 종료하고 스레드를 삭제합니다.',
+        }),
+    )
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName('status')
+        .setDescription('View fishing statistics.')
+        .setDescriptionLocalizations({
+          ko: '낚시 통계를 확인합니다.',
+        })
+        .addUserOption((option) =>
+          option
+            .setName('user')
+            .setDescription('User to view')
+            .setDescriptionLocalizations({
+              ko: '조회할 유저',
+            }),
+        ),
+    )
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName('dex')
+        .setDescription('View your fishing collection book.')
+        .setDescriptionLocalizations({
+          ko: '낚시 도감을 확인합니다.',
+        })
+        .addUserOption((option) =>
+          option
+            .setName('user')
+            .setDescription('User to view')
+            .setDescriptionLocalizations({
+              ko: '조회할 유저',
+            }),
+        ),
+    )
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName('ranking')
+        .setDescription('View the biggest fish size ranking in this server.')
+        .setDescriptionLocalizations({
+          ko: '이 서버의 물고기 크기 랭킹을 확인합니다.',
+        }),
+    ),
+
+  async execute(interaction: ChatInputCommandInteraction, locale: SupportedLocale) {
+    if (!interaction.guildId) return;
+
+    const config = await prisma.miniGameConfig.findUnique({
+      where: { guildId_gameKey: { guildId: interaction.guildId, gameKey: 'fishing' } },
+    });
+    const subcommand = interaction.options.getSubcommand();
+
+    if (subcommand === 'enter') {
+      if (!config || !config.enabled) {
+        await interaction.editReply({
+          content: t(locale, 'commands.fishing.disabled'),
+        });
+        return;
+      }
+
+      if (config.channelId && config.channelId !== interaction.channelId) {
+        await interaction.editReply({
+          content: t(locale, 'commands.fishing.restrictedChannel', {
+            channel: `<#${config.channelId}>`,
+          }),
+        });
+        return;
+      }
+
+      if (!interaction.channel || interaction.channel.type !== ChannelType.GuildText) {
+        await interaction.editReply({
+          content: t(locale, 'commands.fishing.enterTextChannelOnly'),
+        });
+        return;
+      }
+
+      const result = await FishingService.enterThread(interaction);
+      await interaction.editReply({
+        content: result.existed
+          ? t(locale, 'commands.fishing.enterExistingThread', { thread: `<#${result.thread.id}>` })
+          : t(locale, 'commands.fishing.enterCreated', { thread: `<#${result.thread.id}>` }),
+      });
+      return;
+    }
+
+    if (subcommand === 'cast') {
+      if (!config || !config.enabled) {
+        await interaction.editReply({
+          content: t(locale, 'commands.fishing.disabled'),
+        });
+        return;
+      }
+
+      if (!FishingService.isOwnedFishingThread(interaction.channel, interaction.user.username)) {
+        await interaction.editReply({
+          content: t(locale, 'commands.fishing.castThreadOnly'),
+        });
+        return;
+      }
+
+      const result = await FishingService.startSessionInThread(interaction, locale);
+      await interaction.editReply({
+        content: result.existed
+          ? t(locale, 'commands.fishing.startExistingSession', { thread: `<#${result.thread.id}>` })
+          : t(locale, 'commands.fishing.startCreated', { thread: `<#${result.thread.id}>` }),
+      });
+      return;
+    }
+
+    if (subcommand === 'end') {
+      const ended = await FishingService.endThreadByUser(interaction, locale);
+      if (!ended) {
+        await interaction.editReply({
+          content: t(locale, 'commands.fishing.noActiveSession'),
+        });
+        return;
+      }
+
+      await interaction.editReply({
+        content: t(locale, 'commands.fishing.endDeleted'),
+      });
+      return;
+    }
+
+    if (subcommand === 'status') {
+      const targetUser = interaction.options.getUser('user') ?? interaction.user;
+      const profile = await FishingService.getProfile(targetUser.id, interaction.guildId);
+
+      const totalCasts = profile?.totalCastCount ?? 0;
+      const successCount = profile?.successCount ?? 0;
+      const failCount = profile?.failCount ?? 0;
+      const totalGoldEarned = profile?.totalGoldEarned ?? 0;
+      const bestCatchReward = profile?.bestCatchReward ?? 0;
+      const successRate = totalCasts > 0 ? ((successCount / totalCasts) * 100).toFixed(1) : '0.0';
+      const rarityBreakdown = [
+        `⚪ ${profile?.commonCatchCount ?? 0}`,
+        `🟢 ${profile?.uncommonCatchCount ?? 0}`,
+        `🔵 ${profile?.rareCatchCount ?? 0}`,
+        `🟣 ${profile?.epicCatchCount ?? 0}`,
+        `🟠 ${profile?.legendaryCatchCount ?? 0}`,
+      ].join('\n');
+
+      const embed = new EmbedBuilder()
+        .setColor(0x3b82f6)
+        .setTitle(t(locale, 'commands.fishing.profileTitle', { user: targetUser.username }))
+        .setThumbnail(targetUser.displayAvatarURL())
+        .addFields(
+          {
+            name: t(locale, 'commands.fishing.totalCasts'),
+            value: String(totalCasts),
+            inline: true,
+          },
+          {
+            name: t(locale, 'commands.fishing.successRate'),
+            value: `${successRate}% (${successCount}/${successCount + failCount})`,
+            inline: true,
+          },
+          {
+            name: t(locale, 'commands.fishing.totalGoldEarned'),
+            value: `${totalGoldEarned} G`,
+            inline: true,
+          },
+          {
+            name: t(locale, 'commands.fishing.bestCatchReward'),
+            value: `${bestCatchReward} G`,
+            inline: true,
+          },
+          {
+            name: t(locale, 'commands.fishing.lastCastAt'),
+            value: profile?.lastCastAt
+              ? `<t:${Math.floor(profile.lastCastAt.getTime() / 1000)}:R>`
+              : t(locale, 'commands.fishing.noRecord'),
+            inline: true,
+          },
+          {
+            name: t(locale, 'commands.fishing.rarityBreakdown'),
+            value: rarityBreakdown,
+            inline: false,
+          },
+        );
+
+      if (!profile) {
+        embed.setDescription(t(locale, 'commands.fishing.profileEmpty'));
+      }
+
+      await interaction.editReply({ embeds: [embed] });
+      return;
+    }
+
+    if (subcommand === 'dex') {
+      const targetUser = interaction.options.getUser('user') ?? interaction.user;
+      const collection = await FishingService.getCollection(targetUser.id, interaction.guildId);
+
+      const embed = new EmbedBuilder()
+        .setColor(0x14b8a6)
+        .setTitle(t(locale, 'commands.fishing.dexTitle', { user: targetUser.username }))
+        .setThumbnail(targetUser.displayAvatarURL());
+
+      if (!collection.length) {
+        embed.setDescription(t(locale, 'commands.fishing.dexEmpty'));
+        await interaction.editReply({ embeds: [embed] });
+        return;
+      }
+
+      for (const entry of collection.slice(0, 10)) {
+        const fishName = FishingService.getFishDisplayName(entry.fishId);
+        const rarityName = FishingService.getRarityDisplayNameById(entry.bestRarityId, locale);
+        embed.addFields({
+          name: fishName,
+          value: [
+            `${t(locale, 'commands.fishing.catchCount')}: ${entry.catchCount}`,
+            `${t(locale, 'commands.fishing.bestRarity')}: ${rarityName}`,
+            `${t(locale, 'commands.fishing.bestSize')}: ${entry.bestSizeCm.toFixed(1)} cm`,
+          ].join('\n'),
+          inline: true,
+        });
+      }
+
+      await interaction.editReply({ embeds: [embed] });
+      return;
+    }
+
+    if (subcommand === 'ranking') {
+      const ranking = await FishingService.getSizeRanking(interaction.guildId);
+
+      const embed = new EmbedBuilder()
+        .setColor(0xf59e0b)
+        .setTitle(t(locale, 'commands.fishing.rankingTitle'));
+
+      if (!ranking.length) {
+        embed.setDescription(t(locale, 'commands.fishing.rankingEmpty'));
+        await interaction.editReply({ embeds: [embed] });
+        return;
+      }
+
+      for (const [index, entry] of ranking.entries()) {
+        const fishName = FishingService.getFishDisplayName(entry.fishId);
+        const rarityName = FishingService.getRarityDisplayNameById(entry.bestRarityId, locale);
+        embed.addFields({
+          name: `#${index + 1} <@${entry.userId}>`,
+          value: [
+            `${t(locale, 'commands.fishing.targetFish')}: ${fishName}`,
+            `${t(locale, 'commands.fishing.rarity')}: ${rarityName}`,
+            `${t(locale, 'commands.fishing.size')}: ${entry.bestSizeCm.toFixed(1)} cm`,
+          ].join('\n'),
+          inline: false,
+        });
+      }
+
+      await interaction.editReply({ embeds: [embed] });
+    }
+  },
+};

apps/bot/src/commands/language.ts

@@ -27,7 +27,7 @@ export default {
 
     // Validate locale (safety check)
     if (!SUPPORTED_LOCALES.includes(newLocale)) {
-      await interaction.reply({ content: `Unsupported locale: ${newLocale}`, ephemeral: true });
+      await interaction.editReply({ content: `Unsupported locale: ${newLocale}` });
       return;
     }
 
@@ -38,9 +38,8 @@ export default {
     });
 
     // Respond in the NEWLY selected locale
-    await interaction.reply({
+    await interaction.editReply({
       content: t(newLocale, 'commands.language.userSet', { locale: newLocale === 'ko' ? '한국어' : 'English' }),
-      ephemeral: true,
     });
   },
 };

apps/bot/src/commands/minigame.ts

@@ -81,7 +81,7 @@ export default {
         .setTitle('🎮 미니게임 설정 변경')
         .setDescription(`${game.name} 미니게임이 **${state}**되었습니다.`);
 
-      return interaction.reply({ embeds: [embed], ephemeral: true });
+      return interaction.editReply({ embeds: [embed] });
     }
 
     if (subcommand === 'status') {
@@ -106,7 +106,7 @@ export default {
         });
       });
 
-      return interaction.reply({ embeds: [embed], ephemeral: true });
+      return interaction.editReply({ embeds: [embed] });
     }
 
     if (subcommand === 'channel') {
@@ -127,7 +127,7 @@ export default {
         .setTitle('🎮 미니게임 채널 설정')
         .setDescription(`${game.name} 미니게임 전용 채널이 **${channelMsg}**로 설정되었습니다.`);
 
-      return interaction.reply({ embeds: [embed], ephemeral: true });
+      return interaction.editReply({ embeds: [embed] });
     }
   },
 };

apps/bot/src/commands/music.ts

@@ -1,4 +1,4 @@
-import { ChatInputCommandInteraction, GuildMember, SlashCommandBuilder } from 'discord.js';
+import { ChatInputCommandInteraction, GuildMember, SlashCommandBuilder } from 'discord.js';
 import { SupportedLocale, t } from '../i18n';
 import { MusicService } from '../services/MusicService';
 import { logger } from '../utils/logger';
@@ -26,7 +26,7 @@ async function respond(
     return;
   }
 
-  await interaction.reply({ content, ephemeral });
+  await interaction.editReply({ content });
 }
 
 export default {
@@ -136,33 +136,28 @@ export default {
         const url = interaction.options.getString('url');
 
         if ((!query && !url) || (query && url)) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'addMutuallyExclusive'),
-            ephemeral: true,
           });
           return;
         }
 
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const textChannel = interaction.channel as any;
         if (!textChannel?.send) {
-          await interaction.reply({
+          await interaction.editReply({
             content: t(locale, 'errors.E3003.userMessage'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.deferReply();
-
         const result = query
           ? await MusicService.addFromQuery(member, textChannel, query, locale)
           : await MusicService.addFromUrl(member, textChannel, url!, locale);
@@ -191,7 +186,7 @@ export default {
       }
 
       if (subcommand === 'queue') {
-        await interaction.reply({
+        await interaction.editReply({
           embeds: [MusicService.getQueueEmbed(interaction.guildId!, locale)],
         });
         return;
@@ -200,18 +195,16 @@ export default {
       if (subcommand === 'remove') {
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const activeVoiceChannelId = MusicService.getActiveVoiceChannelId(interaction.guildId!);
         if (activeVoiceChannelId && activeVoiceChannelId !== member.voice.channelId) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'differentVoiceChannel'),
-            ephemeral: true,
           });
           return;
         }
@@ -219,14 +212,13 @@ export default {
         const index = interaction.options.getInteger('index', true);
         const removed = await MusicService.remove(interaction.guildId!, index);
         if (!removed) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'noActiveSession'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.reply({
+        await interaction.editReply({
           content: t(locale, 'commands.music.queueRemoved', {
             title: removed.title,
           }),
@@ -237,160 +229,145 @@ export default {
       if (subcommand === 'pause') {
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const activeVoiceChannelId = MusicService.getActiveVoiceChannelId(interaction.guildId!);
         if (activeVoiceChannelId && activeVoiceChannelId !== member.voice.channelId) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'differentVoiceChannel'),
-            ephemeral: true,
           });
           return;
         }
 
         const paused = await MusicService.pause(interaction.guildId!, locale);
         if (!paused) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'noActiveSession'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.reply({ content: t(locale, 'commands.music.pauseSuccess') });
+        await interaction.editReply({ content: t(locale, 'commands.music.pauseSuccess') });
         return;
       }
 
       if (subcommand === 'resume') {
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const activeVoiceChannelId = MusicService.getActiveVoiceChannelId(interaction.guildId!);
         if (activeVoiceChannelId && activeVoiceChannelId !== member.voice.channelId) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'differentVoiceChannel'),
-            ephemeral: true,
           });
           return;
         }
 
         const resumed = await MusicService.resume(interaction.guildId!, locale);
         if (!resumed) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'noActiveSession'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.reply({ content: t(locale, 'commands.music.resumeSuccess') });
+        await interaction.editReply({ content: t(locale, 'commands.music.resumeSuccess') });
         return;
       }
 
       if (subcommand === 'skip') {
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const activeVoiceChannelId = MusicService.getActiveVoiceChannelId(interaction.guildId!);
         if (activeVoiceChannelId && activeVoiceChannelId !== member.voice.channelId) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'differentVoiceChannel'),
-            ephemeral: true,
           });
           return;
         }
 
         const skipped = await MusicService.skip(interaction.guildId!);
         if (!skipped) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'noActiveSession'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.reply({ content: t(locale, 'commands.music.skipSuccess') });
+        await interaction.editReply({ content: t(locale, 'commands.music.skipSuccess') });
         return;
       }
 
       if (subcommand === 'stop') {
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const activeVoiceChannelId = MusicService.getActiveVoiceChannelId(interaction.guildId!);
         if (activeVoiceChannelId && activeVoiceChannelId !== member.voice.channelId) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'differentVoiceChannel'),
-            ephemeral: true,
           });
           return;
         }
 
         const stopped = await MusicService.stop(interaction.guildId!, locale);
         if (!stopped) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'noActiveSession'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.reply({ content: t(locale, 'commands.music.stopSuccess') });
+        await interaction.editReply({ content: t(locale, 'commands.music.stopSuccess') });
         return;
       }
 
       if (subcommand === 'leave') {
         const member = interaction.member as GuildMember;
         if (!member.voice.channel) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'notInVoice'),
-            ephemeral: true,
           });
           return;
         }
 
         const activeVoiceChannelId = MusicService.getActiveVoiceChannelId(interaction.guildId!);
         if (activeVoiceChannelId && activeVoiceChannelId !== member.voice.channelId) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'differentVoiceChannel'),
-            ephemeral: true,
           });
           return;
         }
 
         const left = await MusicService.leave(interaction.guildId!, locale);
         if (!left) {
-          await interaction.reply({
+          await interaction.editReply({
             content: buildErrorMessage(locale, 'noActiveSession'),
-            ephemeral: true,
           });
           return;
         }
 
-        await interaction.reply({ content: t(locale, 'commands.music.leaveSuccess') });
+        await interaction.editReply({ content: t(locale, 'commands.music.leaveSuccess') });
       }
     } catch (error) {
       logger.error('Error in music command:', error);
@@ -417,15 +394,7 @@ export default {
         return;
       }
 
-      if (interaction.replied || interaction.deferred) {
-        await respond(interaction, t(locale, 'errors.E3003.userMessage'), true);
-        return;
-      }
-
-      await interaction.reply({
-        content: t(locale, 'errors.E3003.userMessage'),
-        ephemeral: true,
-      });
+      await respond(interaction, t(locale, 'errors.E3003.userMessage'), true);
     }
   },
 };

apps/bot/src/commands/refine.ts

@@ -97,11 +97,11 @@ export default {
     });
 
     if (!config || !config.enabled) {
-      return interaction.reply({ content: '❌ 이 서버에서는 재련 미니게임이 비활성화되어 있습니다.', ephemeral: true });
+      return interaction.editReply({ content: '❌ 이 서버에서는 재련 미니게임이 비활성화되어 있습니다.' });
     }
 
     if (config.channelId && config.channelId !== interaction.channelId) {
-      return interaction.reply({ content: `❌ 재련 미니게임은 <#${config.channelId}> 채널에서만 이용 가능합니다.`, ephemeral: true });
+      return interaction.editReply({ content: `❌ 재련 미니게임은 <#${config.channelId}> 채널에서만 이용 가능합니다.` });
     }
 
     const subcommand = interaction.options.getSubcommand();
@@ -132,9 +132,9 @@ export default {
 
         const row = new ActionRowBuilder<ButtonBuilder>().addComponents(retryBtn);
 
-        return interaction.reply({ embeds: [embed], components: [row] });
+        return interaction.editReply({ embeds: [embed], components: [row] });
       } catch (err: any) {
-        return interaction.reply({ content: `❌ 오류: ${err.message}`, ephemeral: true });
+        return interaction.editReply({ content: `❌ 오류: ${err.message}` });
       }
     }
 
@@ -142,10 +142,10 @@ export default {
     if (subcommand === 'battle') {
       const targetUser = interaction.options.getUser('target', true);
       if (targetUser.id === interaction.user.id) {
-        return interaction.reply({ content: '❌ 자신을 공격할 수 없습니다.', ephemeral: true });
+        return interaction.editReply({ content: '❌ 자신을 공격할 수 없습니다.' });
       }
       if (targetUser.bot) {
-        return interaction.reply({ content: '❌ 봇과 전투할 수 없습니다.', ephemeral: true });
+        return interaction.editReply({ content: '❌ 봇과 전투할 수 없습니다.' });
       }
 
       try {
@@ -170,9 +170,9 @@ export default {
           if (result.attackerDurability <= 0) embed.setFooter({ text: '⚠️ [경고] 무기가 전투 불능이 되었습니다. 내구도 0에서 다시 공격하면 파괴됩니다!' });
         }
 
-        return interaction.reply({ embeds: [embed] });
+        return interaction.editReply({ embeds: [embed] });
       } catch (err: any) {
-        return interaction.reply({ content: `❌ 오류: ${err.message}`, ephemeral: true });
+        return interaction.editReply({ content: `❌ 오류: ${err.message}` });
       }
     }
 
@@ -180,9 +180,9 @@ export default {
     if (subcommand === 'checkin') {
       try {
         const res = await RefinementService.checkIn(interaction.user.id, interaction.guildId);
-        return interaction.reply({ content: `✅ 출석 완료! **${res.goldAdded} G**를 수령했습니다. (총: ${res.totalGold} G)`, ephemeral: true });
+        return interaction.editReply({ content: `✅ 출석 완료! **${res.goldAdded} G**를 수령했습니다. (총: ${res.totalGold} G)` });
       } catch (err: any) {
-        return interaction.reply({ content: `❌ 오류: ${err.message}`, ephemeral: true });
+        return interaction.editReply({ content: `❌ 오류: ${err.message}` });
       }
     }
 
@@ -208,7 +208,7 @@ export default {
           { name: '전투', value: `승리: ${profile.battleWin} | 패배: ${profile.battleLoss}`, inline: false }
         );
 
-      return interaction.reply({ embeds: [embed] });
+      return interaction.editReply({ embeds: [embed] });
     }
 
     // --- RANKING ---
@@ -243,16 +243,16 @@ export default {
       }).join('\n') || '데이터가 없습니다.';
 
       embed.setDescription(listStr);
-      return interaction.reply({ embeds: [embed] });
+      return interaction.editReply({ embeds: [embed] });
     }
 
     // --- SELL ---
     if (subcommand === 'sell') {
       try {
         const res = await RefinementService.sellWeapon(interaction.user.id, interaction.guildId);
-        return interaction.reply({ content: `💰 **${res.level}단계** 무기를 판매하고 **${res.price} G**를 받았습니다. (총: ${res.gold} G)`, ephemeral: true });
+        return interaction.editReply({ content: `💰 **${res.level}단계** 무기를 판매하고 **${res.price} G**를 받았습니다. (총: ${res.gold} G)` });
       } catch (err: any) {
-        return interaction.reply({ content: `❌ 오류: ${err.message}`, ephemeral: true });
+        return interaction.editReply({ content: `❌ 오류: ${err.message}` });
       }
     }
 
@@ -271,7 +271,7 @@ export default {
           { name: '🔥 피버 타임', value: '서버가 가장 활발한 시간대에 재련 성공 확률이 10% 증가합니다!' }
         );
 
-      return interaction.reply({ embeds: [embed] });
+      return interaction.editReply({ embeds: [embed] });
     }
   },
 };

apps/bot/src/commands/setup.ts

@@ -19,10 +19,9 @@ export default {
     if (!interaction.guildId) return;
 
     const { embed, components } = await SetupWizardRenderer.renderStep(0, interaction, locale);
-    return interaction.reply({
+    return interaction.editReply({
       embeds: [embed],
       components,
-      ephemeral: true,
     });
   },
 };

apps/bot/src/commands/voice.ts

@@ -88,22 +88,21 @@ export default {
 
         if (action === 'set') {
           const channel = interaction.options.getChannel('channel');
-          if (!channel) return interaction.reply({ content: '❌ `channel` 옵션을 선택해주세요.', ephemeral: true });
+          if (!channel) return interaction.editReply({ content: '❌ `channel` 옵션을 선택해주세요.' });
 
           await prisma.voiceGenerator.upsert({
             where: { channelId: channel.id },
             update: { categoryId: category?.id || null, guildId },
             create: { channelId: channel.id, guildId, categoryId: category?.id || null }
           });
-          return interaction.reply({
+          return interaction.editReply({
             content: t(locale, 'commands.voiceSetup.setSuccess', { channel: `${channel}` }),
-            ephemeral: true
           });
         }
 
         if (action === 'create') {
           const name = interaction.options.getString('name');
-          if (!name) return interaction.reply({ content: '❌ `name` 옵션을 입력해주세요.', ephemeral: true });
+          if (!name) return interaction.editReply({ content: '❌ `name` 옵션을 입력해주세요.' });
 
           const newChannel = await interaction.guild!.channels.create({
             name,
@@ -113,9 +112,8 @@ export default {
           await prisma.voiceGenerator.create({
             data: { channelId: newChannel.id, guildId, categoryId: category?.id || null }
           });
-          return interaction.reply({
+          return interaction.editReply({
             content: t(locale, 'commands.voiceSetup.createSuccess', { channel: `${newChannel}` }),
-            ephemeral: true
           });
         }
       }
@@ -126,31 +124,29 @@ export default {
 
         if (action === 'name') {
           const template = interaction.options.getString('template');
-          if (!template) return interaction.reply({ content: '❌ `template` 옵션을 입력해주세요.', ephemeral: true });
+          if (!template) return interaction.editReply({ content: '❌ `template` 옵션을 입력해주세요.' });
 
           await prisma.voiceGuildConfig.upsert({
             where: { guildId },
             update: { defaultNameTemplate: template },
             create: { guildId, defaultNameTemplate: template }
           });
-          return interaction.reply({
+          return interaction.editReply({
             content: t(locale, 'commands.voiceConfig.setSuccess'),
-            ephemeral: true
           });
         }
 
         if (action === 'limit') {
           const limit = interaction.options.getInteger('limit');
-          if (limit === null) return interaction.reply({ content: '❌ `limit` 옵션을 입력해주세요.', ephemeral: true });
+          if (limit === null) return interaction.editReply({ content: '❌ `limit` 옵션을 입력해주세요.' });
 
           await prisma.voiceGuildConfig.upsert({
             where: { guildId },
             update: { defaultUserLimit: limit },
             create: { guildId, defaultUserLimit: limit }
           });
-          return interaction.reply({
+          return interaction.editReply({
             content: t(locale, 'commands.voiceConfig.setSuccess'),
-            ephemeral: true
           });
         }
 
@@ -171,14 +167,13 @@ export default {
                 inline: true 
               }
             );
-          return interaction.reply({ embeds: [embed], ephemeral: true });
+          return interaction.editReply({ embeds: [embed] });
         }
       }
     } catch (error) {
       logger.error('Error in voice command', error);
-      return interaction.reply({
+      return interaction.editReply({
         content: t(locale, 'errors.E3003.userMessage'),
-        ephemeral: true
       });
     }
   },

apps/bot/src/config/env.ts

@@ -0,0 +1,40 @@
+import { config } from 'dotenv';
+import { existsSync } from 'fs';
+import { hostname } from 'os';
+import { resolve } from 'path';
+
+const getEnvPath = () => {
+  if (process.env.DOTENV_CONFIG_PATH) return process.env.DOTENV_CONFIG_PATH;
+  
+  const localEnv = resolve(process.cwd(), '.env');
+  if (existsSync(localEnv)) return localEnv;
+
+  const rootEnv = resolve(process.cwd(), '../../.env');
+  if (existsSync(rootEnv)) return rootEnv;
+
+  return localEnv;
+};
+
+config({ path: getEnvPath() });
+
+const generateInstanceId = () => {
+  return process.env.INSTANCE_ID || hostname() || `kord-${Math.random().toString(36).substring(2, 7)}`;
+};
+
+export const env = {
+  NODE_ENV: process.env.NODE_ENV || 'development',
+  DISCORD_TOKEN: process.env.DISCORD_TOKEN || '',
+  DISCORD_CLIENT_ID: process.env.DISCORD_CLIENT_ID || '',
+  DATABASE_URL: process.env.DATABASE_URL || '',
+  VOICE_WAITING_ROOM_ID: process.env.VOICE_WAITING_ROOM_ID || '',
+  VOICE_CATEGORY_ID: process.env.VOICE_CATEGORY_ID || '',
+  /** log4js level: trace | debug | info | warn | error | fatal */
+  LOG_LEVEL: process.env.LOG_LEVEL || 'info',
+  /**
+   * Directory for log4js `kord.log` (created at startup). Relative paths resolve from `process.cwd()`.
+   * For Jenkins or wipe-and-redeploy flows, set an absolute path **outside** the deploy tree (e.g. `/var/lib/kord/logs`)
+   * so logs survive redeploys and match `StandardOutput=append` in systemd if you point it at the same file.
+   */
+  LOG_DIR: process.env.LOG_DIR || 'logs',
+  INSTANCE_ID: generateInstanceId(),
+};

apps/bot/src/core/command.ts

@@ -0,0 +1,232 @@
+import {
+  SlashCommandBuilder,
+  SlashCommandOptionsOnlyBuilder,
+  SlashCommandSubcommandsOnlyBuilder,
+  ChatInputCommandInteraction,
+} from 'discord.js';
+
+/** Values returned from {@link SlashCommandBuilder} after chaining options or subcommands only. */
+export type SlashCommandData =
+  | SlashCommandBuilder
+  | SlashCommandOptionsOnlyBuilder
+  | SlashCommandSubcommandsOnlyBuilder;
+import { prisma } from '../database';
+import { SupportedLocale } from '../i18n';
+import { SubscriptionTier } from '@prisma/client';
+
+/**
+ * 명령의 도메인·특성 구분입니다.
+ *
+ * - 같은 특성끼리 묶어 help 표시, 권한 정책, 기능 플래그, 통계 등에 활용할 수 있습니다.
+ * - `Command`를 쓰지 않는 기존 명령 모듈에는 값이 없을 수 있습니다.
+ */
+export enum CommandTrait {
+  /** 음악 재생·대기열 등 */
+  Music = 'music',
+  /** 미니게임 */
+  Minigame = 'minigame',
+  /** 방송 연동·알림 등 */
+  Broadcast = 'broadcast',
+  /** 위에 해당하지 않는 일반 명령(설정·감사·음성 등) */
+  General = 'general',
+}
+
+/** {@link CommandTrait.General}을 제외한 특성은 `guild_payment` 플래그가 필요합니다. */
+export function traitRequiresPayment(trait: CommandTrait): boolean {
+  return (
+    trait === CommandTrait.Music || trait === CommandTrait.Minigame || trait === CommandTrait.Broadcast
+  );
+}
+
+/**
+ * 유료 특성 명령에 대해 길드 결제 플래그를 확인합니다.
+ *
+ * @returns 통과 시 `true`. 이미 `reply`로 응답한 경우 `false`.
+ */
+export async function ensureGuildPaidForTrait(
+  interaction: ChatInputCommandInteraction,
+  trait: CommandTrait,
+): Promise<boolean> {
+  if (!traitRequiresPayment(trait)) {
+    return true;
+  }
+
+  const guildId = interaction.guildId;
+  if (!guildId) {
+    const content = '이 명령은 서버에서만 사용할 수 있습니다.';
+    if (interaction.deferred || interaction.replied) {
+      await interaction.editReply({ content });
+    } else {
+      await interaction.reply({ content, ephemeral: true });
+    }
+    return false;
+  }
+
+  // Payment flags were replaced by subscription tiers.
+  // A guild is considered "paid" if it has an owner whose subscription tier is above FREE.
+  const ownership = await prisma.guildOwnership.findUnique({
+    where: { guildId },
+    include: { owner: true },
+  });
+
+  const paid = ownership?.owner?.tier != null && ownership.owner.tier !== SubscriptionTier.FREE;
+
+  if (!paid) {
+    const content = '결제가 되지않았습니다';
+    if (interaction.deferred || interaction.replied) {
+      await interaction.editReply({ content });
+    } else {
+      await interaction.reply({ content, ephemeral: true });
+    }
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * 슬래시 명령을 `CommandLoader`에 넘길 때 쓰는 모듈 형태입니다.
+ *
+ * `src/handlers/CommandLoader.ts`는 각 명령 파일의 `default` export가
+ * `data`(슬래시 정의)와 `execute`(실행 함수) 속성을 가지는지 검사한 뒤,
+ * `client.commands.set(command.data.name, command)`로 등록합니다.
+ * 따라서 이 타입은 디스코드에 올리는 빌더와, 실제 처리 진입점을 한 묶음으로 맞춥니다.
+ *
+ * `trait`은 {@link Command.toModule}을 통해 붙이며, 특성 필터링 시 사용합니다.
+ */
+export type CommandModule = {
+  data: SlashCommandData;
+  execute: (interaction: ChatInputCommandInteraction, locale: SupportedLocale) => Promise<void>;
+  trait?: CommandTrait;
+};
+
+/**
+ * 슬래시 명령용 추상 베이스 클래스입니다.
+ *
+ * **사용 흐름**
+ * 1. 이 클래스를 상속한 뒤 {@link trait}에 {@link CommandTrait} 중 하나를 지정합니다.
+ * 2. {@link define}에서 `SlashCommandBuilder`로 이름·설명·옵션·권한 등을 구성합니다.
+ * 3. {@link handle}에서 실제 비즈니스 로직(답장·DB·서비스 호출)을 작성합니다.
+ * 4. `export default new MyCommand().toModule()`처럼 `toModule()` 결과를 기본 내보내기 하면
+ *    기존 `commands/*.ts`와 동일하게 로더에 잡힙니다(`trait` 메타데이터 포함).
+ *
+ * **실행 순서** (`interactionCreate` → 본 클래스의 `execute`)
+ * 1. `guildOnly === true`이면 DM 등 길드가 아닌 경우 즉시 안내 메시지 후 종료합니다.
+ * 2. {@link CommandTrait.Music} / {@link CommandTrait.Minigame} / {@link CommandTrait.Broadcast}인 경우
+ *    `guild_payment` 테이블을 조회해 해당 플래그가 `true`일 때만 진행합니다. (행 없음·`false` → 「결제가 되지않았습니다」)
+ * 3. {@link beforeHandle}이 `false`를 반환하면(이미 응답을 보낸 경우 등) {@link handle}은 호출되지 않습니다.
+ * 4. 그렇지 않으면 {@link handle}을 실행합니다.
+ *
+ * `events/interactionCreate.ts`는 로케일을 resolve한 뒤 `command.execute(interaction, locale)`만 호출하므로,
+ * 명령 파일마다 반복되던 길드-only 같은 공통 처리는 이 클래스에 모을 수 있습니다.
+ */
+export abstract class Command {
+  private cachedData: SlashCommandData | null = null;
+
+  /**
+   * 이 명령의 도메인 특성입니다. 서브클래스에서 반드시 한 값으로 고정하세요.
+   *
+   * 예: 음악 명령 → {@link CommandTrait.Music}, 미니게임 → {@link CommandTrait.Minigame},
+   * 방송 → {@link CommandTrait.Broadcast}, 그 외 → {@link CommandTrait.General}.
+   */
+  protected abstract readonly trait: CommandTrait;
+
+  /**
+   * `true`이면 **서버(길드) 안에서만** 명령이 동작합니다.
+   *
+   * DM이나 길드 컨텍스트가 없는 상호작용에서는 {@link handle}에 들어가기 전에
+   * 영문 안내를 다른 사용자에게는 보이지 않는(ephemeral) 형태로 보내고 return 합니다.
+   * 서버 전용 명령(채널·역할·길드 설정 등)에 켜 두면 됩니다.
+   */
+  protected guildOnly = false;
+
+  /**
+   * 디스코드에 등록할 슬래시 명령 빌더입니다.
+   *
+   * 최초 접근 시 {@link define}을 한 번만 호출해 결과를 캐시합니다.
+   * 같은 인스턴스에서 `data`를 여러 번 읽어도 빌더는 한 번만 만들어집니다.
+   */
+  get data(): SlashCommandData {
+    if (!this.cachedData) {
+      this.cachedData = this.define();
+    }
+    return this.cachedData;
+  }
+
+  /**
+   * 슬래시 명령의 정의(이름, 설명, 로컬라이즈, 서브커맨드, 옵션, `setDefaultMemberPermissions` 등)를
+   * `SlashCommandBuilder`로 구성해 반환합니다.
+   */
+  protected abstract define(): SlashCommandData;
+
+  /**
+   * 공통 가드를 통과한 뒤 실행되는 본 처리입니다.
+   *
+   * `interaction`은 채팅 입력 슬래시이고, `locale`은 사용자/길드 설정을 반영해 resolve된 값입니다.
+   */
+  protected abstract handle(
+    interaction: ChatInputCommandInteraction,
+    locale: SupportedLocale,
+  ): Promise<void>;
+
+  /**
+   * {@link handle} 직전에 한 번 호출되는 선택적 훅입니다.
+   *
+   * 권한 검사, rate limit, 잘못된 옵션 조합에 대한 조기 응답 등 **여러 명령에서 공통으로 쓸 선행 로직**을
+   * 넣기 좋습니다.
+   *
+   * @returns `true`이면 그대로 {@link handle}으로 진행합니다.
+   *          `false`이면 **이미 `reply`/`deferReply` 등으로 응답을 끝낸 것으로 간주**하고
+   *          `handle`은 호출하지 않습니다.
+   */
+  protected async beforeHandle(
+    _interaction: ChatInputCommandInteraction,
+    _locale: SupportedLocale,
+  ): Promise<boolean> {
+    return true;
+  }
+
+  /**
+   * 로더/디스코드가 호출하는 진입점입니다.
+   *
+   * 길드-only 검사 → 유료 특성 시 {@link ensureGuildPaidForTrait} → `beforeHandle` → `handle` 순으로 위임합니다.
+   * 일반적으로 서브클래스에서 이 메서드를 직접 오버라이드할 필요는 없습니다.
+   */
+  async execute(
+    interaction: ChatInputCommandInteraction,
+    locale: SupportedLocale,
+  ): Promise<void> {
+    if (this.guildOnly && !interaction.inGuild()) {
+      const content = 'This command can only be used in a server.';
+      if (interaction.deferred || interaction.replied) {
+        await interaction.editReply({ content });
+      } else {
+        await interaction.reply({ content, ephemeral: true });
+      }
+      return;
+    }
+
+    if (!(await ensureGuildPaidForTrait(interaction, this.trait))) {
+      return;
+    }
+
+    if (!(await this.beforeHandle(interaction, locale))) {
+      return;
+    }
+
+    await this.handle(interaction, locale);
+  }
+
+  /**
+   * `CommandModule` 형태로 묶어 `default export`에 넘깁니다.
+   *
+   * `execute`는 이 인스턴스에 바인딩되므로, 서브클래스에서 `this`를 쓰는 메서드도 그대로 동작합니다.
+   */
+  toModule(): CommandModule {
+    return {
+      data: this.data,
+      execute: (interaction, locale) => this.execute(interaction, locale),
+      trait: this.trait,
+    };
+  }
+}

apps/bot/src/core/db.ts

@@ -0,0 +1,49 @@
+import { Prisma, PrismaClient } from '@prisma/client';
+import { prisma } from '../database';
+
+export type DbClient = PrismaClient;
+export type TxClient = Prisma.TransactionClient;
+
+function isRootClient(client: DbClient | TxClient): client is DbClient {
+  return typeof (client as DbClient).$transaction === 'function';
+}
+
+/**
+ * Runs `fn` inside a DB transaction.
+ *
+ * - If `fn` throws/rejects, **all operations are rolled back**.
+ * - Prefer this over array-based transactions when you need multiple steps
+ *   (reads + conditional writes) to be atomic.
+ */
+export async function transaction<T>(
+  fn: (tx: TxClient) => Promise<T>,
+  options?: {
+    maxWait?: number;
+    timeout?: number;
+    isolationLevel?: Prisma.TransactionIsolationLevel;
+  },
+): Promise<T> {
+  return prisma.$transaction(fn, options);
+}
+
+/**
+ * Utility to support both "already in a transaction" and "start a new one".
+ *
+ * If `client` is a root PrismaClient, it starts a transaction.
+ * If `client` is already a TransactionClient, it reuses it.
+ */
+export async function withTransaction<T>(
+  client: DbClient | TxClient,
+  fn: (tx: TxClient) => Promise<T>,
+  options?: {
+    maxWait?: number;
+    timeout?: number;
+    isolationLevel?: Prisma.TransactionIsolationLevel;
+  },
+): Promise<T> {
+  if (isRootClient(client)) {
+    return client.$transaction(fn, options);
+  }
+  return fn(client);
+}
+

apps/bot/src/database/index.ts

@@ -0,0 +1,59 @@
+import type { PoolConfig } from 'pg';
+import { Pool } from 'pg';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { PrismaClient } from '@prisma/client';
+import { env } from '../config/env';
+import { logger } from '../utils/logger';
+
+/**
+ * `?schema=` in DATABASE_URL is a Prisma URL extension. node-postgres does not apply it,
+ * so connections default to `search_path=public`. PrismaPg also needs an explicit schema
+ * option in some setups (see prisma/prisma#28611).
+ */
+function createPgPoolConfig(connectionString: string): { poolConfig: PoolConfig; prismaSchema?: string } {
+  if (!connectionString) {
+    return { poolConfig: { connectionString: '' } };
+  }
+  try {
+    const url = new URL(connectionString);
+    const schema = url.searchParams.get('schema')?.trim();
+    const poolConfig: PoolConfig = { connectionString };
+    if (schema) {
+      const escaped = schema.replace(/"/g, '""');
+      poolConfig.options = `-c search_path="${escaped}"`;
+    }
+    return { poolConfig, prismaSchema: schema || undefined };
+  } catch {
+    return { poolConfig: { connectionString } };
+  }
+}
+
+const { poolConfig, prismaSchema } = createPgPoolConfig(env.DATABASE_URL);
+const pool = new Pool(poolConfig);
+const adapter = prismaSchema ? new PrismaPg(pool, { schema: prismaSchema }) : new PrismaPg(pool);
+
+export const prisma = new PrismaClient({
+  adapter,
+  log: ['warn', 'error'],
+});
+
+export const connectDB = async () => {
+  if (!env.DATABASE_URL) {
+    logger.error('DATABASE_URL is not set. Please check your .env file.');
+    process.exit(1);
+  }
+
+  try {
+    // Adapter-based client connects when first used, 
+    // but we can test the pool connection here.
+    const client = await pool.connect();
+    client.release();
+    logger.info('Connected to PostgreSQL successfully via Driver Adapter.');
+  } catch (error) {
+    logger.error('Failed to connect to PostgreSQL:', error);
+    if (error instanceof Error && error.message.includes('password')) {
+      logger.error('Database authentication failed. Please check your DATABASE_URL password.');
+    }
+    process.exit(1);
+  }
+};

apps/bot/src/events/guildCreate.ts

@@ -1,12 +1,10 @@
 import { Events, Guild } from 'discord.js';
-import { InviteService } from '../services/InviteService';
 import { PresenceService } from '../services/PresenceService';
 
 export default {
   name: Events.GuildCreate,
   once: false,
   async execute(guild: Guild) {
-    await InviteService.cacheGuildInvites(guild);
     PresenceService.updatePresence(guild.client);
   },
 };

apps/bot/src/events/guildMemberAdd.ts

@@ -1,10 +1,10 @@
 import { Events, GuildMember } from 'discord.js';
-import { InviteService } from '../services/InviteService';
+import { autoRoleService } from '../services/AutoRoleService';
 
 export default {
   name: Events.GuildMemberAdd,
   once: false,
   async execute(member: GuildMember) {
-    await InviteService.handleMemberAdd(member);
+    await autoRoleService.handleMemberJoin(member);
   },
 };

apps/bot/src/events/interactionCreate.ts

@@ -18,6 +18,8 @@ export default {
       const command = client.commands.get(interaction.commandName);
       if (!command) return;
 
+      // Acknowledge before locale DB reads so Discord's ~3s interaction window is never missed.
+      await interaction.deferReply({ ephemeral: true });
       const locale = await getInteractionLocale(interaction);
       await withErrorHandler(interaction, async () => {
         await command.execute(interaction, locale);
@@ -29,6 +31,13 @@ export default {
         await MusicService.handleControlInteraction(interaction, locale);
       }, locale);
     }
+    else if (interaction.isButton() && interaction.customId.startsWith('fishing_')) {
+      const { FishingService } = require('../services/FishingService');
+      const locale = await getInteractionLocale(interaction);
+      await withErrorHandler(interaction, async () => {
+        await FishingService.handleButton(interaction, locale);
+      }, locale);
+    }
     else if (interaction.isMessageComponent() && interaction.customId.startsWith('setup_')) {
       const locale = await getInteractionLocale(interaction);
       await withErrorHandler(interaction, async () => {
@@ -136,6 +145,40 @@ export default {
         }, locale);
       }
     }
+    else if (interaction.isButton() && interaction.customId.startsWith('autorole_')) {
+      const locale = await getInteractionLocale(interaction);
+      const { autoRoleService } = require('../services/AutoRoleService');
+      await withErrorHandler(interaction, async () => {
+        // 타임아웃 방지를 위해 즉시 승인
+        await interaction.deferUpdate();
+        
+        // 나머지 버튼 처리 (현재 사용 안함)
+      }, locale);
+    }
+    else if (interaction.isRoleSelectMenu() && interaction.customId.startsWith('autorole_select_')) {
+      const locale = await getInteractionLocale(interaction);
+      const { autoRoleService } = require('../services/AutoRoleService');
+      await withErrorHandler(interaction, async () => {
+        // 타임아웃 방지를 위해 즉시 승인
+        await interaction.deferUpdate();
+
+        const guild = interaction.guild!;
+        const isBot = interaction.customId.includes('bot');
+        const roleIds = interaction.values;
+        
+        await autoRoleService.updateConfig(guild.id, {
+          [isBot ? 'botRoleIds' : 'userRoleIds']: roleIds
+        });
+
+        const { generateAutoRoleDashboard } = require('../commands/autorole');
+        const dashboard = await generateAutoRoleDashboard(guild, locale);
+
+        await interaction.editReply({ 
+          content: '', 
+          ...dashboard
+        });
+      }, locale);
+    }
     else if (interaction.isModalSubmit()) {
       const customId = interaction.customId;
       if (customId.startsWith('modal_vc_')) {

apps/bot/src/events/ready.ts

@@ -1,37 +1,36 @@
 import { Events } from 'discord.js';
 import { KordClient } from '../client/KordClient';
 import { logger } from '../utils/logger';
-import { InviteService } from '../services/InviteService';
 import { VoiceService } from '../services/VoiceService';
 import { PresenceService } from '../services/PresenceService';
 import { EventService } from '../services/EventService';
 import { auditLogService } from '../services/AuditLogService';
-import { tryAcquireLock } from '../cache';
-import { env } from '../config/env';
 
+
+import { env } from '../config/env';
+import { PrismaShardStatusRepository } from '@kord/db';
+import { prisma } from '../database';
 export default {
   name: Events.ClientReady,
   once: true,
   async execute(client: KordClient) {
     logger.info(`Ready! Logged in as ${client.user?.tag}`);
-    await InviteService.cacheAllInvites(client);
     await VoiceService.syncChannels(client);
     PresenceService.startActivePresence(client);
     EventService.startReminderLoop(client);
 
-    try {
-      const lockKey = 'commands:sync:lock';
-      // EX 300 = 5 minutes lock. Only one instance needs to do this per boot cycle.
-      const acquired = await tryAcquireLock(lockKey, 300);
+    const shardId = client.shard?.ids[0] ?? 0;
+    const guildIds = Array.from(client.guilds.cache.keys());
+    const shardRepo = new PrismaShardStatusRepository(prisma);
+    await shardRepo.upsertStatus(shardId, 'READY', guildIds)
+      .catch((e: Error) => logger.error('Failed to update shard status:', e));
 
-      if (acquired) {
-        const commandsData = Array.from(client.commands.values()).map(c => c.data.toJSON());
-        await client.application?.commands.set(commandsData);
-        logger.info(`Successfully registered ${commandsData.length} global application commands.`);
-      } else {
-        logger.info('Global commands registration skipped (already handled by another instance).');
-      }
+    try {
+      const commandsData = Array.from(client.commands.values()).map(c => c.data.toJSON());
+      await client.application?.commands.set(commandsData);
+      logger.info(`Successfully registered ${commandsData.length} global application commands.`);
     } catch (e) {
+
       logger.error('Failed to register global commands', e);
     }
 

apps/bot/src/i18n/localeHelper.ts

@@ -23,21 +23,20 @@ export async function getInteractionLocale(interaction: Interaction): Promise<Su
   let guildLocale: string | null = null;
 
   try {
-    // Fetch user locale preference
-    const userPref = await prisma.userLocale.findUnique({
-      where: { userId: interaction.user.id },
-      select: { locale: true },
-    });
-    userLocale = userPref?.locale ?? null;
-
-    // Fetch guild locale preference
-    if (interaction.guildId) {
-      const guildConfig = await prisma.guildConfig.findUnique({
-        where: { guildId: interaction.guildId },
+    const [userPref, guildConfig] = await Promise.all([
+      prisma.userLocale.findUnique({
+        where: { userId: interaction.user.id },
         select: { locale: true },
-      });
-      guildLocale = guildConfig?.locale ?? null;
-    }
+      }),
+      interaction.guildId
+        ? prisma.guildConfig.findUnique({
+            where: { guildId: interaction.guildId },
+            select: { locale: true },
+          })
+        : Promise.resolve(null),
+    ]);
+    userLocale = userPref?.locale ?? null;
+    guildLocale = guildConfig?.locale ?? null;
   } catch {
     // If DB lookup fails, fall through to Discord locale / default
   }
@@ -61,21 +60,22 @@ export async function getContextLocale(
   let guildLocale: string | null = null;
 
   try {
-    if (userId) {
-      const userPref = await prisma.userLocale.findUnique({
-        where: { userId },
-        select: { locale: true },
-      });
-      userLocale = userPref?.locale ?? null;
-    }
-
-    if (guildId) {
-      const guildConfig = await prisma.guildConfig.findUnique({
-        where: { guildId },
-        select: { locale: true },
-      });
-      guildLocale = guildConfig?.locale ?? null;
-    }
+    const [userPref, guildConfig] = await Promise.all([
+      userId
+        ? prisma.userLocale.findUnique({
+            where: { userId },
+            select: { locale: true },
+          })
+        : Promise.resolve(null),
+      guildId
+        ? prisma.guildConfig.findUnique({
+            where: { guildId },
+            select: { locale: true },
+          })
+        : Promise.resolve(null),
+    ]);
+    userLocale = userPref?.locale ?? null;
+    guildLocale = guildConfig?.locale ?? null;
   } catch {
     // Fall through to default
   }

apps/bot/src/i18n/locales/en.ts

@@ -1,11 +1,11 @@
 import { TranslationSchema } from '../types';
 
 /**
- * English translations — the DEFAULT and FALLBACK locale.
+ * English translations ??the DEFAULT and FALLBACK locale.
  * All keys MUST be present here. Other locales can omit keys to fallback to English.
  */
 export const en: TranslationSchema = {
-  // ── Error Messages ──────────────────────────────────────
+  // ?€?€ Error Messages ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   errors: {
     E1001: {
       userMessage: 'The user limit value is invalid.',
@@ -71,7 +71,7 @@ export const en: TranslationSchema = {
     },
   },
 
-  // ── Error Category Titles ───────────────────────────────
+  // ?€?€ Error Category Titles ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   errorTitles: {
     USER_INPUT: 'Please check your input',
     PERMISSION: 'Insufficient permissions',
@@ -79,17 +79,17 @@ export const en: TranslationSchema = {
     DISCORD_API: 'Temporary issue',
   },
 
-  // ── Error Embed Field Labels ────────────────────────────
+  // ?€?€ Error Embed Field Labels ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   errorFields: {
     resolution: '💡 How to resolve',
   },
 
-  // ── Voice Channel ───────────────────────────────────────
+  // ?€?€ Voice Channel ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   voice: {
     channelReady: '{{owner}}, your temporary channel is ready! Use the dropdown menu below to manage it.',
     defaultRoomName: "{{username}}'s Room",
     controlPanel: {
-      placeholder: '⚙️ Manage Channel Settings',
+      placeholder: '?숋툘 Manage Channel Settings',
       rename: 'Rename Channel',
       limit: 'Set User Limit',
       lock: 'Lock / Unlock',
@@ -111,7 +111,7 @@ export const en: TranslationSchema = {
     },
   },
 
-  // ── Commands ────────────────────────────────────────────
+  // ?€?€ Commands ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   commands: {
     voiceSetup: {
       description: 'Setup a generator voice channel for temporary channels.',
@@ -191,6 +191,26 @@ export const en: TranslationSchema = {
         status: 'Status',
       },
     },
+    autorole: {
+      description: 'Configure automatic role assignment upon joining.',
+      statusTitle: 'Auto Role Configuration Status',
+      userRoleLabel: 'User Role',
+      botRoleLabel: 'Bot Role',
+      statusLabel: 'User Auto Assignment',
+      botStatusLabel: 'Bot Auto Assignment',
+      userRolePlaceholder: 'Select default user role',
+      botRolePlaceholder: 'Select default bot role',
+      toggleUserEnable: '🟢 Enable User AutoRole',
+      toggleUserDisable: '🔴 Disable User AutoRole',
+      toggleBotEnable: '🟢 Enable Bot AutoRole',
+      toggleBotDisable: '🔴 Disable Bot AutoRole',
+      notSet: 'Not Set',
+      enabled: 'Enabled',
+      disabled: 'Disabled',
+      updateSuccess: 'Auto role settings have been updated.',
+      permissionsError: 'Failed to assign role due to low bot hierarchy or missing permissions.',
+      suspendNotice: 'Auto role assignment has been suspended due to insufficient permissions. Please check the bot\'s permissions and role hierarchy.',
+    },
     music: {
       description: 'Play YouTube audio in voice channels.',
       addDescription: 'Search YouTube or add a video URL to the queue.',
@@ -251,11 +271,68 @@ export const en: TranslationSchema = {
       statusPaused: 'Paused',
       unknownDuration: 'Unknown',
       buttons: {
-        pause: '⏸ Pause',
-        resume: '▶ Resume',
-        skip: '⏭ Skip',
-        stop: '⏹ Stop',
-        leave: '👋 Leave',
+        pause: '??Pause',
+        resume: '??Resume',
+        skip: '??Skip',
+        stop: '??Stop',
+        leave: '?몝 Leave',
+      },
+    },
+    fishing: {
+      description: 'Play the fishing mini-game.',
+      enterDescription: 'Create or reopen your fishing thread.',
+      castDescription: 'Start a fishing session inside your fishing thread.',
+      endDescription: 'End your fishing thread and delete it.',
+      statusDescription: 'View fishing statistics.',
+      dexDescription: 'View your fishing collection book.',
+      rankingDescription: 'View the biggest fish size ranking in this server.',
+      disabled: 'The fishing mini-game is disabled in this server.',
+      restrictedChannel: 'Fishing can only be started in {{channel}}.',
+      enterTextChannelOnly: 'Fishing threads can only be opened from a regular text channel.',
+      enterExistingThread: 'Your fishing thread is already available in {{thread}}.',
+      enterCreated: 'Your fishing thread has been created in {{thread}}.',
+      castThreadOnly: 'You can only use /fishing cast inside your own fishing thread.',
+      startExistingSession: 'You already have an active fishing session in {{thread}}.',
+      startCreated: 'Your fishing session has started in {{thread}}.',
+      noActiveSession: 'There is no fishing session or thread to close.',
+      ownerOnly: 'Only the owner of this fishing session can use these controls.',
+      wrongThread: 'This fishing control can only be used inside your fishing thread.',
+      endDeleted: 'Your fishing thread has been closed and is being deleted.',
+      profileTitle: '{{user}} Fishing Profile',
+      profileEmpty: 'There is no fishing record yet.',
+      dexTitle: '{{user}} Fishing Dex',
+      dexEmpty: 'There are no discovered fish yet.',
+      rankingTitle: 'Fishing Size Ranking',
+      rankingEmpty: 'There are no fishing records in this server yet.',
+      titleActive: 'Fishing Session',
+      titleEnded: 'Fishing Session Ended',
+      status: 'Status',
+      rarity: 'Rarity',
+      size: 'Size',
+      catchCount: 'Catch Count',
+      bestRarity: 'Best Rarity',
+      bestSize: 'Best Size',
+      targetFish: 'Target Fish',
+      distance: 'Distance',
+      tension: 'Line Tension',
+      reward: 'Reward',
+      successRate: 'Success Rate',
+      totalCasts: 'Total Casts',
+      totalGoldEarned: 'Total Gold',
+      bestCatchReward: 'Best Reward',
+      rarityBreakdown: 'Rarity Breakdown',
+      lastCastAt: 'Last Cast',
+      noRecord: 'No record',
+      threadHint: 'Use /fishing cast to play again, or /fishing end to delete the thread.',
+      catchResultTitle: 'Big Catch!',
+      catchResultBody: 'You caught a **{{rarity}} {{fish}}** measuring **{{sizeCm}} cm** and earned **{{reward}} G**.',
+      states: {
+        hooked: 'Hooked',
+        resting: 'Resting',
+        tense: 'Pulling',
+        missed: 'Missed',
+        success: 'Caught',
+        failed: 'Line Snapped',
       },
     },
     permissionAudit: {
@@ -263,75 +340,72 @@ export const en: TranslationSchema = {
       channel: 'Channel',
       noResults: 'No features to audit. The bot may not be configured yet.',
       summaryLabel: 'Summary',
-      summaryOk: '✅ All checks passed. No issues found.',
-      summaryIssue: '❌ {{fail}} failure(s) · ⚠️ {{warn}} warning(s) detected.',
+      summaryOk: '??All checks passed. No issues found.',
+      summaryIssue: '??{{fail}} failure(s) 쨌 ?좑툘 {{warn}} warning(s) detected.',
       hierarchyWarning: "Bot role (pos: {{botPos}}) must be above '{{role}}' (pos: {{targetPos}}) to manage it.",
       features: {
         BASIC: 'Basic Bot Functionality',
         VOICE_GLOBAL: 'Voice Channels (Global)',
         VOICE_GENERATOR_CHANNEL: 'Voice Generator Channel',
         VOICE_GENERATOR_CATEGORY: 'Voice Generator Category',
-        INVITE_TRACKING: 'Invite Tracking',
-        INVITE_ROLE_HIERARCHY: 'Invite Role Assignment (Hierarchy)',
         MIMIC_WEBHOOK: 'Message Mimic (Webhook)',
       },
     },
     setup: {
       description: 'Run the setup wizard to configure the bot step by step.',
       step0: { 
-        title: '✨ Bot Setup Wizard', 
-        desc: 'Welcome! This wizard will help you configure the following 4 features:\n\n1️⃣ **Language Settings**\n2️⃣ **Permission Check**\n3️⃣ **Audit Channel Setup**\n4️⃣ **Temporary Voice Channel Setup**', 
+        title: '??Bot Setup Wizard', 
+        desc: 'Welcome! This wizard will help you configure the following 4 features:\n\n1截뤴깵 **Language Settings**\n2截뤴깵 **Permission Check**\n3截뤴깵 **Audit Channel Setup**\n4截뤴깵 **Temporary Voice Channel Setup**', 
         startBtn: 'Start Setup' 
       },
       step1: { 
-        title: '1️⃣ Language Settings', 
+        title: '1截뤴깵 Language Settings', 
         desc: 'Set the default language for the bot in this server. (Current: **{{locale}}**)', 
         placeholder: 'Select a language', 
         nextBtn: 'Next Step', 
         skipBtn: 'Skip' 
       },
       step2: { 
-        title: '2️⃣ Permission Check', 
-        descOk: '✅ **All required permissions are granted.**', 
-        descFail: '⚠️ **Some permissions are missing.**\nPlease check the results and grant the necessary permissions to the bot role.', 
+        title: '2截뤴깵 Permission Check', 
+        descOk: '??**All required permissions are granted.**', 
+        descFail: '?좑툘 **Some permissions are missing.**\nPlease check the results and grant the necessary permissions to the bot role.', 
         recheckBtn: 'Re-check', 
         nextBtn: 'Next Step' 
       },
       step3: { 
-        title: '3️⃣ Audit Channel Setup', 
+        title: '3截뤴깵 Audit Channel Setup', 
         desc: 'Select a channel to receive bot events and error logs.', 
         placeholder: 'Select Audit Channel', 
         disableBtn: 'Disable Audit Logs', 
         nextBtn: 'Next Step' 
       },
       step4: {
-        title: '3-1️⃣ Audit Log Categories',
+        title: '3-1截뤴깵 Audit Log Categories',
         desc: 'Select which log categories to receive. **Green** buttons are enabled, **Red** buttons are disabled.',
         nextBtn: 'Next Step',
       },
       step5: { 
-        title: '4️⃣ Temporary Voice Channel Setup', 
+        title: '4截뤴깵 Temporary Voice Channel Setup', 
         desc: 'Select the "Generator Channel" for temporary voice channels.\nYou can choose an existing channel or have the bot **auto-create** a new category and channel.', 
         placeholder: 'Select Generator Channel', 
-        autoBtn: '🚀 Auto Create', 
+        autoBtn: '?? Auto Create', 
         skipBtn: 'Disable Temp Voice', 
         nextBtn: 'Finish Setup' 
       },
       step6: { 
-        title: '🎉 Setup Summary', 
+        title: '?럦 Setup Summary', 
         desc: '**1. Language**: {{lang}}\n**2. Audit Channel**: {{audit}}\n**3. Audit Categories**: {{categories}}\n**4. Temp Voice**: {{voice}}', 
         finishBtn: 'Done' 
       },
-      finished: '✅ The setup wizard has been finished.',
-      expired: '⏳ The session has expired. Please run `/setup` again.',
+      finished: '??The setup wizard has been finished.',
+      expired: '??The session has expired. Please run `/setup` again.',
       defaultCategoryName: 'Voice Channels',
-      defaultGeneratorName: '➕ Create Channel',
+      defaultGeneratorName: '??Create Channel',
       auditCategories: {
         SYSTEM: 'System',
         BOOT: 'Boot',
         VOICE: 'Voice',
         PERMISSION: 'Permission',
-        INVITE: 'Invite',
       },
     },
     config: {
@@ -350,7 +424,7 @@ export const en: TranslationSchema = {
     },
   },
 
-  // ── Modals ──────────────────────────────────────────────
+  // ?€?€ Modals ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   modals: {
     renameTitle: 'Rename Voice Channel',
     renameLabel: 'New Channel Name',
@@ -358,14 +432,14 @@ export const en: TranslationSchema = {
     limitLabel: 'User Limit (0 for unlimited, 1-99)',
   },
 
-  // ── Select Menu Placeholders ────────────────────────────
+  // ?€?€ Select Menu Placeholders ?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€?€
   selects: {
     kickUser: 'Select a user to kick',
     banUser: 'Select a user to ban/hide',
     transferOwner: 'Select a user to transfer ownership to',
   },
 
-  // ── Presence (Bot Status) ──
+  // ?€?€ Presence (Bot Status) ?€?€
   presence: {
     servers: 'Monitoring {{guildCount}} servers',
     help: 'Check out the /help command',
@@ -373,3 +447,6 @@ export const en: TranslationSchema = {
     version: 'Kord v1.0.0',
   },
 };
+
+
+

apps/bot/src/i18n/locales/ko.ts

@@ -0,0 +1,470 @@
+import { TranslationSchema } from '../types';
+
+/**
+ * 한국어 번역. en.ts와 키 구조가 1:1로 대응해야 합니다.
+ */
+export const ko: TranslationSchema = {
+  // ── 에러 메시지 ─────────────────────────────────────────
+  errors: {
+    E1001: {
+      userMessage: '사용자 제한 값이 올바르지 않습니다.',
+      resolution: '0에서 99 사이의 숫자를 입력해 주세요. (0 = 무제한)',
+    },
+    E1002: {
+      userMessage: '채널 이름 형식이 올바르지 않습니다.',
+      resolution: '올바른 채널 이름을 입력해 주세요. (최대 100자)',
+    },
+    E1003: {
+      userMessage: '자기 자신에게는 이 작업을 수행할 수 없습니다.',
+    },
+    E1004: {
+      userMessage: '선택한 사용자가 음성 채널에 없습니다.',
+      resolution: '작업 전에 해당 사용자가 채널에 있는지 확인해 주세요.',
+    },
+
+    E2001: {
+      userMessage: '봇에게 채널을 관리할 권한이 부족합니다.',
+      resolution: '서버 관리자에게 봇에게 「채널 관리」 권한을 부여해 달라고 요청해 주세요.',
+    },
+    E2002: {
+      userMessage: '봇에게 음성 채널 관련 권한이 부족합니다.',
+      resolution:
+        '서버 관리자에게 봇에게 「채널 관리」, 「역할 관리」, 「멤버 이동」 권한을 부여해 달라고 요청해 주세요.',
+    },
+    E2003: {
+      userMessage: '이 명령을 사용할 권한이 없습니다.',
+      resolution: '이 명령은 관리자 권한이 필요합니다.',
+    },
+    E2004: {
+      userMessage: '채널 소유자만 이 컨트롤을 사용할 수 있습니다.',
+    },
+    E2005: {
+      userMessage: '활성화된 임시 음성 채널에 있어야 이 기능을 사용할 수 있습니다.',
+      resolution: '임시 음성 채널에 참가한 뒤 다시 시도해 주세요.',
+    },
+    E3001: {
+      userMessage: '요청을 처리하는 중 내부 오류가 발생했습니다.',
+      resolution: '잠시 후 다시 시도해 주세요. 문제가 계속되면 봇 관리자에게 문의해 주세요.',
+    },
+    E3002: {
+      userMessage: '요청을 처리하는 중 내부 오류가 발생했습니다.',
+      resolution: '잠시 후 다시 시도해 주세요.',
+    },
+    E3003: {
+      userMessage: '명령을 실행하는 중 오류가 발생했습니다.',
+      resolution: '다시 시도해 주세요. 문제가 계속되면 봇 관리자에게 문의해 주세요.',
+    },
+    E3999: {
+      userMessage: '예상치 못한 오류가 발생했습니다.',
+      resolution: '잠시 후 다시 시도해 주세요. 문제가 계속되면 봇 관리자에게 문의해 주세요.',
+    },
+    E4001: {
+      userMessage: 'Discord에 의해 요청이 제한되었습니다.',
+      resolution: '잠시 기다린 뒤 다시 시도해 주세요.',
+    },
+    E4002: {
+      userMessage: '권한 부족으로 Discord가 작업을 거부했습니다.',
+      resolution: '서버 관리자에게 봇의 역할 및 채널 권한을 확인해 달라고 요청해 주세요.',
+    },
+    E4003: {
+      userMessage: 'Discord 측 일시적인 문제가 발생했습니다.',
+      resolution:
+        '잠시 후 다시 시도해 주세요. 문제가 계속되면 https://discordstatus.com 에서 상태를 확인해 주세요.',
+    },
+  },
+
+  errorTitles: {
+    USER_INPUT: '입력을 확인해주세요',
+    PERMISSION: '권한이 부족합니다',
+    BOT_INTERNAL: '내부 오류가 발생했습니다.',
+    DISCORD_API: '일시적인 문제입니다.',
+
+  },
+
+  errorFields: {
+    resolution: '💡 해결 방법',
+  },
+
+  // ── 음성 채널 ───────────────────────────────────────────
+
+  voice: {
+    channelReady: '{{owner}}, 임시 채널이 준비되었습니다! 아래 드롭다운 메뉴로 관리하세요.',
+    defaultRoomName: '{{username}}의 방',
+    controlPanel: {
+      placeholder: '⚙️ 채널 설정 관리',
+      rename: '채널 이름 변경',
+      limit: '인원 제한 설정',
+      lock: '채널 잠금 / 해제',
+      kick: '유저 내보내기',
+      ban: '유저 차단 / 숨기기',
+      transfer: '소유권 이전',
+    },
+
+    responses: {
+      channelLocked: '채널이 잠겼습니다! 초대된 멤버만 참여할 수 있습니다.',
+      channelUnlocked: '채널 잠금이 해제되었습니다! 누구나 참여할 수 있습니다.',
+      channelRenamed: '채널 이름이 **{{name}}**(으)로 변경되었습니다!',
+      limitSet: '인원 제한이 **{{limit}}**명으로 설정되었습니다!',
+      limitUnlimited: '무제한',
+      kicked: '{{user}} 님을 채널에서 내보냈습니다.',
+      banned: '{{user}} 님에게 채널이 보이지 않도록 차단했습니다.',
+      transferPrompt: '채널의 새 소유자가 될 사용자를 선택하세요.',
+      transferDone: '소유권이 {{user}} 님에게 이전되었습니다.',
+      banPrompt: '차단하면 해당 사용자에게 채널이 보이지 않게 됩니다.',
+    },
+  },
+
+  commands: {
+    voiceSetup: {
+      description: '임시 음성 채널을 위한 생성기 채널을 설정합니다.',
+      setDescription: '기존 음성 채널을 생성기로 설정합니다.',
+      createDescription: '새 음성 채널을 만들고 생성기로 설정합니다.',
+      channelOptionDescription: '생성기로 사용할 음성 채널',
+      categoryOptionDescription: '(선택) 임시 채널이 생성될 카테고리',
+      nameOptionDescription: '새 생성기 음성 채널 이름',
+      setSuccess: '{{channel}}을(를) 음성 생성기 채널로 설정했습니다!',
+      createSuccess: '{{channel}}을(를) 음성 생성기 채널로 생성·설정했습니다!',
+    },
+
+    voiceConfig: {
+      description: '서버의 임시 음성 채널 설정을 관리합니다.',
+      setNameTitle: '기본 이름 템플릿 설정',
+      setNameDesc: '임시 채널 생성 시 사용할 기본 이름 형식을 설정합니다. (사용자명: {{username}})',
+      setLimitTitle: '기본 인원 제한 설정',
+      setLimitDesc: '임시 채널 생성 시 적용할 기본 인원 제한을 설정합니다.',
+      statusTitle: '현재 서버 음성 설정',
+      templateLabel: '이름 템플릿',
+      limitLabel: '기본 인원 제한',
+      setSuccess: '서버 임시 채널 설정이 업데이트되었습니다.',
+
+      limitValue: '{{limit}}명 (0 = 무제한)',
+    },
+    language: {
+      description: '봇의 언어를 설정합니다.',
+      scopeDescription: '본인에게만 또는 서버 전체에 적용',
+      localeDescription: '사용할 언어',
+      scopeUser: '나만 적용',
+      scopeServer: '서버 전체 (관리자 전용)',
+      userSet: '개인 언어가 **{{locale}}**(으)로 설정되었습니다.',
+      serverSet: '서버 언어가 **{{locale}}**(으)로 설정되었습니다.',
+      serverPermissionDenied: '서버 언어 변경은 서버 관리자만 할 수 있습니다.',
+
+    },
+    event: {
+      description: '서버 이벤트 일정을 관리합니다.',
+      createDescription: '새 서버 이벤트를 생성합니다.',
+      listDescription: '예정된 서버 이벤트 목록을 조회합니다.',
+      cancelDescription: '예약된 서버 이벤트를 취소합니다.',
+      announceDescription: '이벤트 공지 Embed를 다시 게시합니다.',
+      titleDescription: '이벤트 제목',
+      dateDescription: 'YYYY-MM-DD 형식의 날짜',
+      timeDescription: 'HH:mm 형식의 시간 (24시간제, Asia/Seoul 기준)',
+      descriptionOptionDescription: '선택 사항인 이벤트 설명',
+      channelDescription: '선택 사항인 공지 채널',
+      reminderDescription: '리마인더 메시지 사용 여부',
+      remindersDescription: '분 단위 리마인더 목록, 예: 0,10,60',
+      idDescription: '취소할 이벤트 ID',
+      createSuccessTitle: '이벤트 생성 완료',
+      createSuccessBody: '**{{title}}** 이벤트가 예약되었습니다.',
+      listTitle: '예정된 이벤트 목록',
+      listEmpty: '예정된 이벤트가 없습니다.',
+      listItemValue:
+        '**시작 시각:** {{startsAt}}\n**상대 시간:** {{relative}}\n**상태:** {{status}}\n**리마인더:** {{reminder}}\n**채널:** {{channel}}',
+      cancelSuccess: '`{{id}}` 이벤트가 취소되었습니다.',
+      cancelNotFound: 'ID가 `{{id}}`인 예약 이벤트를 찾을 수 없습니다.',
+
+      announceSuccess: '`{{id}}` 이벤트를 {{channel}} 채널에 공지했습니다.',
+      announceNotAvailable: '이 이벤트에는 사용할 수 있는 공지 채널이 설정되어 있지 않습니다.',
+      startAnnouncementTitle: '이벤트 시작',
+      startAnnouncementLead: '이 이벤트가 지금 시작됩니다.',
+      invalidDateTime: '이벤트 날짜 또는 시간 형식이 올바르지 않습니다.',
+      invalidDateTimeResolution: '날짜는 `YYYY-MM-DD`, 시간은 `HH:mm` 24시간 형식으로 입력해 주세요.',
+      invalidReminderOffsets: '리마인더 간격 입력 형식이 올바르지 않습니다.',
+      invalidReminderOffsetsResolution:
+        '`0,10,60`처럼 0 이상의 분을 쉼표로 구분해 입력해 주세요. 비우면 자동 공지를 사용하지 않습니다.',
+      invalidPastDateTime: '과거 시각으로는 이벤트를 예약할 수 없습니다.',
+      invalidPastDateTimeResolution: '미래 시각을 선택한 뒤 다시 시도해 주세요.',
+
+      statusScheduled: '예약됨',
+      statusCancelled: '취소됨',
+      statusCompleted: '완료됨',
+      reminderOn: '사용',
+      reminderOff: '사용 안 함',
+      reminderNone: '자동 공지 없음',
+      announcementChannelNone: '미설정',
+      fields: {
+        eventId: '이벤트 ID',
+        startsAt: '시작 시각',
+        reminder: '리마인더',
+        announcementChannel: '공지 채널',
+        status: '상태',
+      },
+    },
+    autorole: {
+      description: '입장 시 역할을 자동으로 부여하는 기능을 설정합니다.',
+      statusTitle: '자동 역할 부여 설정 상태',
+      userRoleLabel: '일반 유저 역할',
+      botRoleLabel: '봇 역할',
+      statusLabel: '유저 자동 부여',
+      botStatusLabel: '봇 자동 부여',
+      userRolePlaceholder: '유저 기본 역할을 선택하세요',
+      botRolePlaceholder: '봇 기본 역할을 선택하세요',
+      toggleUserEnable: '🟢 유저 자동부여 켜기',
+      toggleUserDisable: '🔴 유저 자동부여 끄기',
+      toggleBotEnable: '🟢 봇 자동부여 켜기',
+      toggleBotDisable: '🔴 봇 자동부여 끄기',
+      notSet: '미설정',
+      enabled: '활성',
+      disabled: '비활성',
+      updateSuccess: '자동 역할 설정이 업데이트되었습니다.',
+      permissionsError: '봇의 역할 순위가 낮거나 권한이 부족하여 역할을 부여할 수 없습니다.',
+      suspendNotice: '권한 부족으로 인해 자동 역할 부여 기능이 일시 중지되었습니다. 봇의 권한과 역할 순위를 확인해 주세요.',
+    },
+    music: {
+      description: '음성 채널에서 YouTube 오디오를 재생합니다.',
+      addDescription: 'YouTube를 검색하거나 영상 URL을 재생 목록에 추가합니다.',
+      queueDescription: '현재 음악 재생 목록을 표시합니다.',
+      removeDescription: '대기열에서 곡을 삭제합니다.',
+      pauseDescription: '현재 재생 중인 곡을 일시정지합니다.',
+      resumeDescription: '일시정지된 곡의 재생을 다시 시작합니다.',
+      skipDescription: '현재 재생 중인 곡을 건너뜁니다.',
+      stopDescription: '재생을 중지하고 대기열을 비웁니다.',
+      leaveDescription: '봇을 음성 채널에서 내보냅니다.',
+      queryDescription: 'YouTube 검색어',
+      urlDescription: 'YouTube 영상 URL',
+      indexDescription: '대기열에서 삭제할 인덱스',
+      addMutuallyExclusive: '검색어와 YouTube URL 중 하나만 선택하세요.',
+      addMutuallyExclusiveResolution: '`query` 또는 `url` 중 정확히 하나만 입력하세요.',
+      notInVoice: '음악 명령을 사용하려면 음성 채널에 있어야 합니다.',
+      notInVoiceResolution: '먼저 음성 채널에 참가한 뒤 다시 시도하세요.',
+      differentVoiceChannel: '다른 음성 채널에서 이미 음악이 재생 중입니다.',
+      differentVoiceChannelResolution: '봇과 같은 음성 채널에 들어가거나, 현재 세션이 끝날 때까지 기다리세요.',
+      noSearchResults: '해당 검색어로 YouTube 결과를 찾지 못했습니다.',
+      noSearchResultsResolution: '검색어를 구체적으로 바꾸거나 YouTube URL을 직접 지정하세요.',
+      invalidUrl: '제공한 YouTube URL이 올바르지 않습니다.',
+      invalidUrlResolution: '일반적인 `youtube.com` 또는 `youtu.be` 영상 링크를 사용하세요.',
+      noActiveSession: '이 서버에 활성 음악 세션이 없습니다.',
+      noActiveSessionResolution: '먼저 곡을 추가해 재생을 시작하세요.',
+      queueAddedNowPlaying: '**{{title}}**을(를) 추가하고 {{channel}}에서 재생을 시작했습니다.',
+      queueAddedLater: '**{{title}}**을(를) 대기열에 추가했습니다. 순번: `#{{position}}`.',
+      playlistAddedNowPlaying: '플레이리스트에서 **{{count}}**곡을 추가하고 {{channel}}에서 재생을 시작했습니다.',
+      playlistAddedLater: '플레이리스트에서 **{{count}}**곡을 대기열에 추가했습니다.',
+      queueTitle: '음악 대기열',
+      queueEmpty: '대기열이 비어 있습니다.',
+      queueNowPlaying: '지금 재생 중',
+      queueUpcoming: '다음 재생',
+      queueMoreItems: '… 외 **{{count}}**곡 더 있음',
+      queueRemoved: '대기열에서 **{{title}}**을(를) 제거했습니다.',
+      queueRemoveOutOfRange: '해당 대기열 번호가 없습니다.',
+      queueRemoveOutOfRangeResolution: '먼저 `/music queue`로 현재 대기열 번호를 확인하세요.',
+      pauseSuccess: '현재 곡을 일시정지했습니다.',
+      resumeSuccess: '재생을 재개했습니다.',
+      skipSuccess: '현재 곡을 건너뛰었습니다.',
+      leaveSuccess: '음성 채널에서 나가고 대기열을 비웠습니다.',
+      stopSuccess: '재생을 중지하고 대기열을 비웠습니다.',
+      playbackStartedTitle: '지금 재생 중',
+      playbackIdleTitle: '대기열 종료',
+      playbackIdleBody: '대기열에 더 이상 곡이 없습니다.',
+      playbackFailed: '**{{title}}** 재생에 실패했습니다. 다음 곡으로 넘어갑니다.',
+      playbackFailedResolution: 'YouTube에서 스트림을 불러오지 못했습니다.',
+      streamUnavailable: '이 영상의 재생 가능한 오디오 스트림을 불러올 수 없습니다.',
+      streamUnavailableResolution: '다른 영상을 시도하거나 나중에 다시 추가해 보세요.',
+      requestedBy: '요청자',
+      duration: '길이',
+      progress: '진행',
+      source: '출처',
+      status: '상태',
+      queueLength: '대기열 길이',
+      nextTrack: '다음 곡',
+      statusPlaying: '재생 중',
+      statusPaused: '일시정지',
+      unknownDuration: '알 수 없음',
+      buttons: {
+        pause: '일시정지',
+        resume: '재개',
+        skip: '건너뛰기',
+        stop: '중지',
+        leave: '나가기',
+      },
+    },
+    fishing: {
+      description: '낚시 미니게임을 플레이합니다.',
+      enterDescription: '낚시 전용 스레드를 생성하거나 다시 엽니다.',
+      castDescription: '자신의 낚시 스레드 안에서 낚시 세션을 시작합니다.',
+      endDescription: '낚시 스레드를 종료하고 삭제합니다.',
+      statusDescription: '낚시 통계를 확인합니다.',
+      dexDescription: '낚시 도감을 확인합니다.',
+      rankingDescription: '이 서버의 물고기 크기 랭킹을 확인합니다.',
+      disabled: '이 서버에서는 낚시 미니게임이 비활성화되어 있습니다.',
+      restrictedChannel: '낚시는 {{channel}} 채널에서만 시작할 수 있습니다.',
+      enterTextChannelOnly: '낚시 스레드는 일반 텍스트 채널에서만 열 수 있습니다.',
+      enterExistingThread: '이미 {{thread}}에 자신의 낚시 스레드가 열려 있습니다.',
+      enterCreated: '{{thread}}에 낚시 스레드를 만들었습니다.',
+      castThreadOnly: '/fishing cast는 자신의 낚시 스레드 안에서만 사용할 수 있습니다.',
+      startExistingSession: '이미 {{thread}}에서 진행 중인 낚시 세션이 있습니다.',
+      startCreated: '{{thread}}에서 낚시 세션을 시작했습니다.',
+      noActiveSession: '종료할 낚시 세션이나 스레드가 없습니다.',
+      ownerOnly: '이 낚시 세션의 소유자만 조작할 수 있습니다.',
+      wrongThread: '이 조작은 자신의 낚시 스레드 안에서만 사용할 수 있습니다.',
+      endDeleted: '낚시 스레드를 종료했습니다. 스레드를 삭제합니다.',
+      profileTitle: '{{user}}의 낚시 프로필',
+      profileEmpty: '아직 낚시 기록이 없습니다.',
+      dexTitle: '{{user}}의 낚시 도감',
+      dexEmpty: '아직 발견한 물고기가 없습니다.',
+      rankingTitle: '낚시 크기 랭킹',
+      rankingEmpty: '아직 이 서버에 낚시 기록이 없습니다.',
+      titleActive: '낚시 세션',
+      titleEnded: '낚시 세션 종료',
+      status: '상태',
+      rarity: '레어도',
+      size: '크기',
+      catchCount: '포획 수',
+      bestRarity: '최고 레어도',
+      bestSize: '최고 크기',
+      targetFish: '대상 물고기',
+      distance: '거리',
+      tension: '끊어짐 게이지',
+      reward: '보상',
+      successRate: '성공률',
+      totalCasts: '총 시도',
+      totalGoldEarned: '누적 골드',
+      bestCatchReward: '최고 보상',
+      rarityBreakdown: '레어도별 포획',
+      lastCastAt: '최근 낚시',
+      noRecord: '기록 없음',
+      threadHint: '/fishing cast로 다시 시작하거나 /fishing end로 스레드를 삭제할 수 있습니다.',
+      catchResultTitle: '낚시 성공!',
+      catchResultBody: '**{{rarity}} {{fish}}**를 낚았습니다. 크기는 **{{sizeCm}} cm**, 보상은 **{{reward}} G**입니다.',
+      states: {
+        hooked: '입질 중',
+        resting: '휴식 중',
+        tense: '당기는 중',
+        missed: '타이밍 빗나감',
+        success: '낚시 성공',
+        failed: '줄이 끊어짐',
+      },
+    },
+    permissionAudit: {
+      title: '봇 권한 진단 보고서',
+      channel: '채널',
+      noResults: '진단할 기능이 없습니다. 봇이 아직 설정되지 않았을 수 있습니다.',
+      summaryLabel: '진단 결과 요약',
+      summaryOk: '모든 항목 정상. 문제가 없습니다.',
+      summaryIssue: '{{fail}}건 실패 · {{warn}}건 경고가 있습니다.',
+      hierarchyWarning:
+        "봇 역할(위치: {{botPos}})이 '{{role}}'(위치: {{targetPos}})보다 위에 있어야 해당 역할을 관리할 수 있습니다.",
+
+      features: {
+        BASIC: '기본 봇 기능',
+        VOICE_GLOBAL: '임시 음성 채널 (전역)',
+        VOICE_GENERATOR_CHANNEL: '음성 생성기 채널',
+        VOICE_GENERATOR_CATEGORY: '음성 생성기 카테고리',
+
+        MIMIC_WEBHOOK: '메시지 흉내 (Webhook)',
+      },
+    },
+    setup: {
+      description: '설정 마법사를 실행해 봇의 필수 기능을 단계별로 설정합니다.',
+      step0: {
+        title: '봇 설정 마법사 시작',
+        desc:
+          '환영합니다! 이 마법사로 아래 4가지 항목을 설정합니다.\n\n1단계 **언어 설정**\n2단계 **필수 권한 확인**\n3단계 **감사 채널 설정**\n4단계 **임시 음성 채널 설정**',
+        startBtn: '설정 시작하기',
+      },
+      step1: {
+        title: '1단계 언어 설정',
+        desc: '서버 전체에 적용될 봇의 기본 언어를 선택하세요. (현재: **{{locale}}**)',
+        placeholder: '언어를 선택하세요',
+        nextBtn: '다음 단계',
+        skipBtn: '건너뛰기',
+      },
+      step2: {
+        title: '2단계 필수 권한 확인',
+        descOk: '**필요한 권한이 모두 부여되어 있습니다.**',
+        descFail:
+          '**일부 권한이 부족합니다.**\n결과를 확인하고 봇 역할에 필요한 기능 권한을 부여해 주세요.',
+        recheckBtn: '다시 검사하기',
+        nextBtn: '다음 단계',
+      },
+      step3: {
+        title: '3단계 감사 채널 설정',
+        desc: '봇 이벤트와 오류 로그를 받을 채널을 선택하세요.',
+        placeholder: '감사 로그 채널 선택',
+        disableBtn: '감사 로그 끄기',
+        nextBtn: '다음 단계',
+      },
+      step4: {
+        title: '3-1단계 감사 로그 카테고리',
+        desc: '받을 로그 카테고리를 선택하세요. **초록**은 켜짐, **빨강**은 꺼짐입니다.',
+        nextBtn: '다음 단계',
+      },
+      step5: {
+        title: '4단계 임시 음성 채널 설정',
+        desc:
+          '임시 음성 채널의 「생성기 채널」을 선택하세요.\n기존 채널을 고르거나 카테고리/채널을 봇이 **자동 생성**하게 할 수도 있습니다.',
+        placeholder: '생성기로 쓸 음성 채널 선택',
+        autoBtn: '자동 생성하기',
+        skipBtn: '임시 음성 사용 안 함',
+        nextBtn: '설정 완료',
+      },
+      step6: {
+        title: '설정 요약',
+        desc: '**1. 언어**: {{lang}}\n**2. 감사 채널**: {{audit}}\n**3. 감사 카테고리**: {{categories}}\n**4. 임시 음성 채널**: {{voice}}',
+        finishBtn: '마치기',
+      },
+      finished: '설정 마법사를 완료했습니다.',
+      expired: '시간이 만료되었습니다. `/setup`을 다시 실행해 주세요.',
+      defaultCategoryName: '음성 채널',
+      defaultGeneratorName: '채널 생성하기',
+
+      auditCategories: {
+        SYSTEM: '시스템',
+        BOOT: '부팅',
+        VOICE: '음성',
+        PERMISSION: '권한',
+
+      },
+    },
+    config: {
+      title: '기능 설정 변경 결과',
+      noOptions: '변경할 옵션을 하나 이상 선택해 주세요.',
+      mimic: {
+        label: '흉내(Mimic)',
+        enabled: '활성',
+        disabled: '비활성',
+      },
+      emoji: {
+        label: '큰 이모지(Big Emoji)',
+        enabled: '활성',
+        disabled: '비활성',
+      },
+    },
+  },
+
+
+  // ── 모달 ────────────────────────────────────────────────
+
+  modals: {
+    renameTitle: '음성 채널 이름 변경',
+    renameLabel: '새 채널 이름',
+    limitTitle: '인원 제한 설정',
+    limitLabel: '인원 제한 (0 = 무제한, 1–99)',
+  },
+
+  // ── 셀렉트 메뉴 플레이스홀더 ────────────────────────────
+
+  selects: {
+    kickUser: '추방할 유저를 선택하세요',
+    banUser: '차단할 유저를 선택하세요',
+    transferOwner: '소유권을 이전할 유저를 선택하세요',
+  },
+
+  // ── 상태 메시지 ──────────────────────────────────────────
+
+  presence: {
+    servers: '{{guildCount}}개의 서버에서 작동 중',
+    help: '/help 명령어를 확인하세요',
+    managing: '임시 음성 채널 관리 중',
+    version: 'Kord v1.0.0',
+  },
+};

apps/bot/src/i18n/types.ts

@@ -145,6 +145,26 @@ export interface TranslationSchema {
         status: string;
       };
     };
+    autorole: {
+      description: string;
+      statusTitle: string;
+      userRoleLabel: string;
+      botRoleLabel: string;
+      statusLabel: string;
+      botStatusLabel: string;
+      userRolePlaceholder: string;
+      botRolePlaceholder: string;
+      toggleUserEnable: string;
+      toggleUserDisable: string;
+      toggleBotEnable: string;
+      toggleBotDisable: string;
+      notSet: string;
+      enabled: string;
+      disabled: string;
+      updateSuccess: string;
+      permissionsError: string;
+      suspendNotice: string;
+    };
     music: {
       description: string;
       addDescription: string;
@@ -212,6 +232,63 @@ export interface TranslationSchema {
         leave: string;
       };
     };
+    fishing: {
+      description: string;
+      enterDescription: string;
+      castDescription: string;
+      endDescription: string;
+      statusDescription: string;
+      dexDescription: string;
+      rankingDescription: string;
+      disabled: string;
+      restrictedChannel: string;
+      enterTextChannelOnly: string;
+      enterExistingThread: string;
+      enterCreated: string;
+      castThreadOnly: string;
+      startExistingSession: string;
+      startCreated: string;
+      noActiveSession: string;
+      ownerOnly: string;
+      wrongThread: string;
+      endDeleted: string;
+      profileTitle: string;
+      profileEmpty: string;
+      dexTitle: string;
+      dexEmpty: string;
+      rankingTitle: string;
+      rankingEmpty: string;
+      titleActive: string;
+      titleEnded: string;
+      status: string;
+      rarity: string;
+      size: string;
+      catchCount: string;
+      bestRarity: string;
+      bestSize: string;
+      targetFish: string;
+      distance: string;
+      tension: string;
+      reward: string;
+      successRate: string;
+      totalCasts: string;
+      totalGoldEarned: string;
+      bestCatchReward: string;
+      rarityBreakdown: string;
+      lastCastAt: string;
+      noRecord: string;
+      threadHint: string;
+      catchResultTitle: string;
+      catchResultBody: string;
+      states: {
+        hooked: string;
+        resting: string;
+        tense: string;
+        missed: string;
+        success: string;
+        failed: string;
+      };
+    };
     permissionAudit: {
       title: string;
       channel: string;
@@ -225,8 +302,6 @@ export interface TranslationSchema {
         VOICE_GLOBAL: string;
         VOICE_GENERATOR_CHANNEL: string;
         VOICE_GENERATOR_CATEGORY: string;
-        INVITE_TRACKING: string;
-        INVITE_ROLE_HIERARCHY: string;
         MIMIC_WEBHOOK: string;
       };
     };
@@ -248,7 +323,6 @@ export interface TranslationSchema {
         BOOT: string;
         VOICE: string;
         PERMISSION: string;
-        INVITE: string;
       };
     };
     config: {

apps/bot/src/index.ts

@@ -1,4 +1,6 @@
 import { KordClient } from './client/KordClient';
+import { startGrpcServer } from './utils/grpcServer';
 
 const client = new KordClient();
+startGrpcServer(client as any);
 client.start();

apps/bot/src/services/AuditLogService.ts

@@ -3,7 +3,7 @@ import { prisma } from '../database';
 import { env } from '../config/env';
 
 export type AuditSeverity = 'INFO' | 'WARN' | 'ERROR';
-export type AuditCategory = 'SYSTEM' | 'BOOT' | 'VOICE' | 'PERMISSION' | 'INVITE' | 'MIMIC';
+export type AuditCategory = 'SYSTEM' | 'BOOT' | 'VOICE' | 'PERMISSION' | 'MIMIC';
 
 export interface AuditLogPayload {
   category: AuditCategory;

apps/bot/src/services/AutoRoleService.ts

@@ -0,0 +1,72 @@
+import { Guild, GuildMember, PermissionFlagsBits } from 'discord.js';
+import { prisma } from '../database';
+import { logger } from '../utils/logger';
+import { auditLogService } from './AuditLogService';
+
+export class AutoRoleService {
+  /**
+   * 서버의 자동 역할 설정을 조회합니다.
+   */
+  async getConfig(guildId: string) {
+    return prisma.autoRoleConfig.findUnique({
+      where: { guildId },
+    });
+  }
+
+  /**
+   * 서버의 자동 역할 설정을 업데이트합니다.
+   */
+  async updateConfig(guildId: string, data: {
+    userRoleIds?: string[];
+    botRoleIds?: string[];
+    isEnabled?: boolean;
+    botEnabled?: boolean;
+  }) {
+    return prisma.autoRoleConfig.upsert({
+      where: { guildId },
+      create: {
+        guildId,
+        ...data,
+      },
+      update: data,
+    });
+  }
+
+  /**
+   * 자동 역할 부여 기능을 활성/비활성합니다.
+   */
+  async setEnabled(guildId: string, enabled: boolean) {
+    return this.updateConfig(guildId, { isEnabled: enabled });
+  }
+
+  /**
+   * 신규 멤버가 입장했을 때 자동으로 역할을 부여합니다.
+   */
+  async handleMemberJoin(member: GuildMember) {
+    const config = await this.getConfig(member.guild.id);
+    if (!config) return;
+
+    const isBot = member.user.bot;
+    const isEnabled = isBot ? config.botEnabled : config.isEnabled;
+    const roleIds = isBot ? config.botRoleIds : config.userRoleIds;
+
+    if (!isEnabled || roleIds.length === 0) return;
+
+    try {
+      await member.roles.add(roleIds, 'Kord Auto-Role');
+      logger.info(`[AutoRole] Added roles to ${member.user.tag} in ${member.guild.name}`);
+    } catch (error) {
+      logger.error(`[AutoRole] Failed to add roles to ${member.user.tag} in ${member.guild.name}`, error);
+      
+      // 권한 문제인 경우 감사 로그에 기록
+      await auditLogService.log(member.guild, {
+        category: 'PERMISSION',
+        severity: 'WARN',
+        title: 'Auto-Role Failure',
+        description: `Failed to assign roles to ${member.user.toString()} automatically. Please check the bot's permission and role hierarchy.`
+      }).catch(() => {});
+    }
+  }
+}
+
+export const autoRoleService = new AutoRoleService();

apps/bot/src/services/MiniGameRegistry.ts

@@ -5,6 +5,11 @@ export interface MiniGame {
 }
 
 export const MINI_GAMES: Record<string, MiniGame> = {
+  fishing: {
+    key: 'fishing',
+    name: 'Fishing',
+    description: 'A real-time fishing mini-game that grants gold rewards.',
+  },
   refinement: {
     key: 'refinement',
     name: '재련',

apps/bot/src/services/MusicService.ts

@@ -1,4 +1,4 @@
-import {
+import {
   ActionRowBuilder,
   ButtonBuilder,
   ButtonInteraction,

apps/bot/src/services/PermissionAuditService.ts

@@ -109,24 +109,7 @@ const FEATURE_DEFINITIONS: FeatureDefinition[] = [
     },
   },
 
-  // ── 5. 초대 추적 ──
-  {
-    featureKey: 'INVITE_TRACKING',
-    scope: 'guild',
-    permissions: [PermissionFlagsBits.ManageGuild],
-  },
-
-  // ── 6. 역할 자동 부여 (초대 연동) - 계층 검사 ──
-  {
-    featureKey: 'INVITE_ROLE_HIERARCHY',
-    scope: 'hierarchy',
-    resolveTargetRoleIds: async (guildId) => {
-      const inviteRoles = await prisma.inviteRole.findMany({ where: { guildId } });
-      return inviteRoles.map((ir: { roleId: string }) => ir.roleId);
-    },
-  },
-
-  // ── 7. 메시지 흉내 (Mimic) ──
+  // ── 5. 메시지 흉내 (Mimic) ──
   {
     featureKey: 'MIMIC_WEBHOOK',
     scope: 'guild',

apps/bot/src/services/RefinementService.ts

@@ -300,6 +300,18 @@ export class RefinementService {
     return this.getOrCreateProfile(userId, guildId);
   }
 
+  public static async addGold(userId: string, guildId: string, amount: number): Promise<number> {
+    const profile = await this.getOrCreateProfile(userId, guildId);
+    const updated = await prisma.refinementProfile.update({
+      where: { userId_guildId: { userId, guildId } },
+      data: {
+        gold: profile.gold + amount,
+      },
+    });
+
+    return updated.gold;
+  }
+
   private static async getOrCreateProfile(userId: string, guildId: string) {
     let profile = await prisma.refinementProfile.findUnique({
       where: { userId_guildId: { userId, guildId } }