.turbo/cache/acf3ce7b1f0725e0-manifest.json

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,29 +0,0 @@
-# 인프라 치명적 오류 복구 및 안정화 (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

@@ -1,18 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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/index.md

@@ -69,7 +69,3 @@
 - [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)

README.md

@@ -54,22 +54,7 @@ Kord는 Discord 서버 관리를 돕는 강력하고 유연한 다기능 봇 및
     yarn workspace dashboard dev
     ```
 
-## 5. 인프라 검증 (Infrastructure Verification)
+## 4. 아키텍처 (Architecture)
-
-인프라 설정(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)

apps/bot/src/index.ts

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

apps/bot/src/shard.ts

@@ -1,25 +1,12 @@
 import { ShardingManager } from 'discord.js';
 import path from 'path';
-import { config } from 'dotenv';
+import 'dotenv/config';
-import { existsSync } from 'fs';
 import * as grpc from '@grpc/grpc-js';
 import { kordProto } from '@kord/grpc-contracts';
 
-const envPath = path.resolve(process.cwd(), '../../.env');
-if (existsSync(envPath)) {
-  config({ path: envPath });
-} else {
-  // Fallback for direct execution from root
-  config({ path: path.resolve(process.cwd(), '.env') });
-}
-
-if (!process.env.DISCORD_TOKEN) {
-  console.error('❌ DISCORD_TOKEN is missing in shard manager! Current CWD:', process.cwd());
-}
-
 const manager = new ShardingManager(path.resolve(__dirname, 'index.ts'), {
   token: process.env.DISCORD_TOKEN,
-  execArgv: ['--import', 'tsx'], // Node.js v22 compatibility
+  execArgv: ['-r', 'tsx'], // Allow running ts files natively in dev
 });
 
 manager.on('shardCreate', (shard) => {
@@ -38,18 +25,41 @@ manager.on('shardCreate', (shard) => {
   });
 });
 
-import { startGrpcServer } from './utils/grpcServer';
+// Spawn the required number of shards
-
+manager.spawn().then(() => {
-// ... (existing env/manager setup)
-
   // --- gRPC Proxy Server Setup ---
-// We start the gRPC server early to ensure the dashboard can connect
+  const server = new grpc.Server();
-// even if Discord sharding takes time to initialize.
-startGrpcServer(manager as any);
 
-// Only spawn shards after gRPC server is successfully bound
+  server.addService((kordProto as any).BotDashboardService.service, {
-console.log('Starting Discord ShardingManager...');
+    Ping: (call: any, callback: any) => {
-manager.spawn().catch(err => {
+      console.log('Received Ping:', call.request.message);
-  console.error('Failed to spawn shards:', err);
+      callback(null, { reply: `Pong to ${call.request.message}` });
+    },
+    GetGuildChannels: async (call: any, callback: any) => {
+      const guildId = call.request.guildId;
+      try {
+        const results = await manager.broadcastEval(
+          (c, context) => {
+            const guild = c.guilds.cache.get(context.guildId);
+            if (!guild) return null;
+            return guild.channels.cache.map(ch => ({ id: ch.id, name: ch.name, type: `${ch.type}` }));
+          },
+          { context: { guildId } }
+        );
+        
+        const channels = results.find(res => res !== null) || [];
+        callback(null, { channels });
+      } catch (error: any) {
+        callback({ code: grpc.status.INTERNAL, details: error.message });
+      }
+    }
   });
 
+  server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), (err, port) => {
+    if (err) {
+      console.error('Failed to bind gRPC server:', err);
+      return;
+    }
+    console.log(`gRPC Proxy Server running on port ${port}`);
+  });
+});

apps/bot/src/utils/grpcServer.ts

@@ -1,71 +0,0 @@
-import * as grpc from '@grpc/grpc-js';
-import { kordProto } from '@kord/grpc-contracts';
-import { logger } from './logger';
-
-export interface BotInstance {
-  broadcastEval?: (fn: any, options?: any) => Promise<any[]>;
-  guilds?: {
-    cache: {
-      get: (id: string) => any;
-    }
-  };
-}
-
-export function startGrpcServer(bot: BotInstance, port: string = '0.0.0.0:50051') {
-  const server = new grpc.Server();
-
-  server.addService((kordProto as any).BotDashboardService.service, {
-    Ping: (call: any, callback: any) => {
-      logger.info('gRPC: Received Ping request');
-      callback(null, { reply: `Pong to ${call.request.message}` });
-    },
-    GetGuildChannels: async (call: any, callback: any) => {
-      const guildId = call.request.guildId;
-      try {
-        let channels = [];
-        
-        if (bot.broadcastEval) {
-          // Sharded mode
-          const results = await bot.broadcastEval(
-            (c: any, context: any) => {
-              const guild = c.guilds.cache.get(context.guildId);
-              if (!guild) return null;
-              return guild.channels.cache.map((ch: any) => ({ 
-                id: ch.id, 
-                name: ch.name, 
-                type: `${ch.type}` 
-              }));
-            },
-            { context: { guildId } }
-          );
-          channels = results.find(res => res !== null) || [];
-        } else if (bot.guilds) {
-          // Standalone mode
-          const guild = bot.guilds.cache.get(guildId);
-          if (guild) {
-            channels = guild.channels.cache.map((ch: any) => ({
-              id: ch.id,
-              name: ch.name,
-              type: `${ch.type}`
-            }));
-          }
-        }
-
-        callback(null, { channels });
-      } catch (error: any) {
-        logger.error('gRPC Error in GetGuildChannels:', error);
-        callback({ code: grpc.status.INTERNAL, details: error.message });
-      }
-    }
-  });
-
-  server.bindAsync(port, grpc.ServerCredentials.createInsecure(), (err, boundPort) => {
-    if (err) {
-      logger.error(`Failed to bind gRPC server: ${err.message}`);
-      return;
-    }
-    logger.info(`gRPC Proxy Server running on port ${boundPort}`);
-  });
-
-  return server;
-}

apps/dashboard/next.config.ts

@@ -1,7 +1,7 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  transpilePackages: ["@kord/grpc-contracts"],
+  /* config options here */
 };
 
 export default nextConfig;

apps/dashboard/package.json

@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "dev": "PORT=3000 PATH=$PATH:/Users/wemadeplay/.nvm/versions/node/v22.18.0/bin next dev --webpack",
+    "dev": "next dev",
     "build": "next build",
     "start": "next start",
     "lint": "eslint",

apps/dashboard/src/lib/grpc.ts

@@ -1,7 +1,7 @@
 import * as grpc from '@grpc/grpc-js';
 import { kordProto } from '@kord/grpc-contracts';
 
-const BOT_GRPC_URL = process.env.BOT_GRPC_URL || '127.0.0.1:50051';
+const BOT_GRPC_URL = process.env.BOT_GRPC_URL || 'localhost:50051';
 
 export const botClient = new (kordProto as any).BotDashboardService(
   BOT_GRPC_URL,

packages/db/prisma/schema.prisma

@@ -11,10 +11,10 @@ model GuildConfig {
   guildId      String   @id
   prefix       String   @default("!")
   mimicEnabled    Boolean  @default(false)
+  bigEmojiEnabled Boolean  @default(false)
   locale          String?
   createdAt    DateTime @default(now())
   updatedAt    DateTime @updatedAt
-  bigEmojiEnabled Boolean  @default(false)
 }
 
 model UserSubscription {
@@ -57,11 +57,11 @@ model TempVoiceChannel {
 
 model UserVoiceProfile {
   userId     String
+  guildId    String
   customName String?
   userLimit  Int?
   createdAt  DateTime @default(now())
   updatedAt  DateTime @updatedAt
-  guildId    String
 
   @@id([userId, guildId])
 }
@@ -73,6 +73,18 @@ model UserLocale {
   updatedAt DateTime @updatedAt
 }
 
+enum SubscriptionTier {
+  FREE
+  STANDARD
+  PRO
+  PREMIUM
+}
+
+enum DeleteCondition {
+  OWNER_LEAVE
+  EMPTY
+}
+
 model AuditChannel {
   guildId            String   @id
   channelId          String
@@ -100,19 +112,25 @@ model GuildEvent {
   announcementChannelId String?
   createdByUserId       String
   reminderEnabled       Boolean     @default(true)
+  reminderOffsets       Int[]       @default([])
+  sentReminderOffsets   Int[]       @default([])
   remindedOneHour       Boolean     @default(false)
   remindedTenMinutes    Boolean     @default(false)
+  startedAnnounced      Boolean     @default(false)
   announcedAt           DateTime?
   createdAt             DateTime    @default(now())
   updatedAt             DateTime    @updatedAt
-  startedAnnounced      Boolean     @default(false)
-  reminderOffsets       Int[]       @default([])
-  sentReminderOffsets   Int[]       @default([])
 
   @@index([guildId, startsAt])
   @@index([guildId, status])
 }
 
+enum EventStatus {
+  SCHEDULED
+  CANCELLED
+  COMPLETED
+}
+
 /// 길드별 유료 기능(특성) 플래그. 행이 없거나 해당 컬럼이 false면 미결제로 간주합니다.
 model GuildPayment {
   id        String  @id
@@ -131,8 +149,8 @@ model MiniGameConfig {
   channelId String?
   updatedAt DateTime @updatedAt
 
-  @@unique([guildId, gameKey])
   @@index([guildId])
+  @@unique([guildId, gameKey])
 }
 
 model RefinementProfile {
@@ -148,27 +166,32 @@ model RefinementProfile {
   destroyCount    Int      @default(0)
   battleWin       Int      @default(0)
   battleLoss      Int      @default(0)
+  dailyBattleCount Int     @default(0)
   isDisabled      Boolean  @default(false)
   lastCheckIn     DateTime?
+  lastBattleReset DateTime @default(now())
   createdAt       DateTime @default(now())
   updatedAt       DateTime @updatedAt
-  dailyBattleCount Int       @default(0)
-  lastBattleReset  DateTime  @default(now())
 
   @@id([userId, guildId])
   @@index([guildId, weaponLevel(sort: Desc)])
 }
 
+
+
+
 model AutoRoleConfig {
   guildId        String   @id
+  userRoleIds    String[] @default([])
+  botRoleIds     String[] @default([])
   isEnabled      Boolean  @default(false)
   botEnabled     Boolean  @default(false)
   createdAt      DateTime @default(now())
   updatedAt      DateTime @updatedAt
-  botRoleIds  String[] @default([])
-  userRoleIds String[] @default([])
 }
 
+
+
 model RefinementLevelConfig {
   level          Int      @id
   successRate    Float
@@ -193,6 +216,7 @@ model RefinementSystemConfig {
   updatedAt   DateTime @updatedAt
 }
 
+// 서버 활동 추이 (시간대별 메시지 수)
 model ActivityLog {
   id        String   @id @default(uuid())
   guildId   String
@@ -205,6 +229,7 @@ model ActivityLog {
   @@index([guildId, weekStart])
 }
 
+// 피버 상태
 model FeverState {
   guildId   String   @id
   isActive  Boolean  @default(false)
@@ -252,26 +277,8 @@ model FishingCollectionEntry {
 }
 
 model ShardStatus {
-  id        Int      @id
+  id        Int      @id // Shard ID
-  status    String   @default("DISCONNECTED")
+  status    String   @default("DISCONNECTED") // CONNECTED, DISCONNECTED, READY
-  guilds    String[] @default([])
+  guilds    String[] @default([]) // Array of Guild IDs this shard manages
   updatedAt DateTime @updatedAt
 }
-
-enum SubscriptionTier {
-  FREE
-  STANDARD
-  PRO
-  PREMIUM
-}
-
-enum DeleteCondition {
-  OWNER_LEAVE
-  EMPTY
-}
-
-enum EventStatus {
-  SCHEDULED
-  CANCELLED
-  COMPLETED
-}

packages/grpc-contracts/src/index.js

@@ -1,92 +1,20 @@
 const path = require('path');
 const protoLoader = require('@grpc/proto-loader');
 const grpc = require('@grpc/grpc-js');
-const fs = require('fs');
 
-/**
+const PROTO_PATH = path.resolve(__dirname, 'kord.proto');
- * gRPC proto 로딩 결과를 캐싱하기 위한 변수
- */
-let _cache = null;
 
-const findProtoPath = () => {
+const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
-  const attemptedPaths = [];
-
-  // 1. Try explicit environment variable
-  if (process.env.KORD_PROTO_PATH) {
-    if (fs.existsSync(process.env.KORD_PROTO_PATH)) return process.env.KORD_PROTO_PATH;
-    attemptedPaths.push(`Env: ${process.env.KORD_PROTO_PATH}`);
-  }
-
-  // 2. Try standard __dirname (most reliable for direct node/tsx runs)
-  const dirnamePath = path.resolve(__dirname, 'kord.proto');
-  if (fs.existsSync(dirnamePath)) return dirnamePath;
-  attemptedPaths.push(`Dirname: ${dirnamePath}`);
-
-  // 3. Try monorepo root via process.cwd()
-  const rootPath = path.resolve(process.cwd(), 'packages/grpc-contracts/src/kord.proto');
-  if (fs.existsSync(rootPath)) return rootPath;
-  attemptedPaths.push(`CWD Root: ${rootPath}`);
-
-  // 4. Try relative from apps/ (Next.js context)
-  const relativePath = path.resolve(process.cwd(), '../../packages/grpc-contracts/src/kord.proto');
-  if (fs.existsSync(relativePath)) return relativePath;
-  attemptedPaths.push(`Relative: ${relativePath}`);
-
-  // 5. Try shared node_modules depth (monorepo artifacts)
-  const nmPath = path.resolve(process.cwd(), 'node_modules/@kord/grpc-contracts/src/kord.proto');
-  if (fs.existsSync(nmPath)) return nmPath;
-  attemptedPaths.push(`NodeModules: ${nmPath}`);
-
-  return { error: true, attemptedPaths };
-};
-
-const initialize = () => {
-  if (_cache) return _cache;
-
-  // browser환경이나 분석 단계에서 fs가 없을 경우를 대비하여 체크 (Turbopack 대응)
-  if (!fs || !fs.existsSync) {
-    return { kordProto: null, protoPath: null };
-  }
-
-  const result = findProtoPath();
-  if (result.error) {
-    // 런타임에 에러가 발생하도록 경고를 출력하되, 빌드/분석 단계에서는 치명적 에러가 되지 않도록 함
-    console.warn('⚠️ [grpc-contracts] Failed to locate kord.proto during initialization.');
-    return { kordProto: null, protoPath: null };
-  }
-
-  const PROTO_PATH = result;
-  let packageDefinition;
-  try {
-    packageDefinition = protoLoader.loadSync(PROTO_PATH, {
   keepCase: true,
   longs: String,
   enums: String,
   defaults: true,
   oneofs: true,
 });
-  } catch (error) {
-    console.error(`Failed to load gRPC proto from: ${PROTO_PATH}`);
-    throw error;
-  }
 
 const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
 
-  _cache = {
+module.exports = {
   kordProto: protoDescriptor.kord,
   protoPath: PROTO_PATH
 };
-
-  return _cache;
-};
-
-module.exports = {
-  // getter를 사용하여 실제 접근 시점에 로딩되도록 함 (Lazy Initialization)
-  get kordProto() {
-    return initialize().kordProto;
-  },
-  get protoPath() {
-    return initialize().protoPath;
-  }
-};
-

scripts/verify-recovery.ts

@@ -1,72 +0,0 @@
-import { PrismaClient } from '@prisma/client';
-import path from 'path';
-import fs from 'fs';
-import { config } from 'dotenv';
-
-async function verify() {
-  console.log('--- Kord Recovery & Infrastructure Verification ---');
-
-  // 1. Env Check
-  const rootEnvPath = path.resolve(process.cwd(), '.env');
-  console.log(`Checking .env at: ${rootEnvPath}`);
-  if (fs.existsSync(rootEnvPath)) {
-    config({ path: rootEnvPath });
-    console.log('✅ .env file found and loaded.');
-  } else {
-    console.error('❌ .env file NOT found at root!');
-  }
-
-  const token = process.env.DISCORD_TOKEN;
-  if (token) {
-    console.log(`✅ DISCORD_TOKEN found (starts with: ${token.substring(0, 10)}...)`);
-  } else {
-    console.error('❌ DISCORD_TOKEN is missing!');
-  }
-
-  // 2. DB Check
-  console.log('\nChecking Database Connection...');
-  const { Pool } = require('pg');
-  const pool = new Pool({ connectionString: process.env.DATABASE_URL });
-  
-  try {
-    const client = await pool.connect();
-    console.log('✅ Connected to Database.');
-    
-    // Check ShardStatus table
-    try {
-      const res = await client.query("SELECT to_regclass('public.\"ShardStatus\"') as exists");
-      if (res.rows[0].exists) {
-        console.log(`✅ ShardStatus table exists.`);
-      } else {
-        console.error('❌ ShardStatus table NOT found in public schema!');
-      }
-    } catch (e: any) {
-      console.error('❌ Error checking ShardStatus table:', e.message);
-    } finally {
-      client.release();
-    }
-  } catch (e: any) {
-    console.error('❌ Database connection failed:', e.message);
-  } finally {
-    await pool.end();
-  }
-
-  // 3. gRPC Contract Check
-  console.log('\nChecking gRPC Contracts...');
-  try {
-    const { kordProto, protoPath } = require(path.resolve(process.cwd(), 'packages/grpc-contracts/src/index'));
-    console.log(`✅ gRPC Proto found at: ${protoPath}`);
-    if (kordProto) {
-      console.log('✅ kordProto loaded successfully.');
-    }
-  } catch (e: any) {
-    console.error('❌ gRPC Contract loading failed:', e.message);
-  }
-
-  console.log('\n--- Verification Finished ---');
-}
-
-verify().catch(err => {
-  console.error('Fatal error during verification:', err);
-  process.exit(1);
-});

turbo.json

@@ -10,8 +10,7 @@
     },
     "dev": {
       "cache": false,
-      "persistent": true,
+      "persistent": true
-      "env": ["PATH", "DISCORD_TOKEN", "DATABASE_URL", "BOT_GRPC_URL"]
     },
     "generate": {
       "dependsOn": ["^generate"],