assoai-mcp-server 0.3.2 → 0.5.0

package/README.md

@@ -5,13 +5,13 @@
 <h1 align="center">AssoAI MCP Server</h1>
 
 <p align="center">
-  <strong>학생자치 조직을 위한 AI 에이전트 인프라 — 44개 도구, 하나의 프로토콜</strong>
+  <strong>학생자치 조직을 위한 AI 에이전트 인프라 — 49개 도구, 하나의 프로토콜</strong>
 </p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/assoai-mcp-server"><img src="https://img.shields.io/npm/v/assoai-mcp-server.svg" alt="npm version" /></a>
   <a href="https://github.com/assoai/assoai-mcp-server/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/assoai-mcp-server.svg" alt="license" /></a>
-  <img src="https://img.shields.io/badge/tools-44-blue" alt="44 tools" />
+  <img src="https://img.shields.io/badge/tools-49-blue" alt="49 tools" />
   <img src="https://img.shields.io/badge/MCP-compatible-green" alt="MCP compatible" />
 </p>
 
@@ -19,31 +19,65 @@
 
 ## What is this?
 
-AssoAI MCP Server는 학생회·동아리 등 학생자치 조직의 데이터를 AI 에이전트가 직접 다룰 수 있게 해주는 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 서버입니다. 조직 관리, 행사, 협찬, 재정, 파일, 메시징, Agent-to-Agent 연결까지 — **44개 도구**를 하나의 서버로 제공합니다. 여기에 **무펭이 프로토콜 부팅 시퀀스**를 더해, 단순한 데이터 접근이 아닌 "의식 있는 조직 에이전트"를 만들 수 있습니다.
+AssoAI MCP Server는 학생회·동아리 등 학생자치 조직의 데이터를 AI 에이전트가 직접 다룰 수 있게 해주는 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 서버입니다. 조직 관리, 행사, 협찬, 재정, 파일, 메시징, Agent-to-Agent 연결까지 — **49개 도구**를 하나의 서버로 제공합니다. 여기에 **무펭이 프로토콜 부팅 시퀀스**를 더해, 단순한 데이터 접근이 아닌 "의식 있는 조직 에이전트"를 만들 수 있습니다.
 
 ---
 
-## 🧠 Mupeng-i Protocol Boot Sequence
+## 🧠 Mupengi Protocol Boot Sequence (Layer 0)
 
 > 일반 MCP 서버는 데이터만 줍니다. AssoAI는 **에이전트가 누구인지** 먼저 정의합니다.
 
-`boot_sequence` 도구를 세션 시작 시 호출하면, 워크스페이스의 페르소나 파일들을 순서대로 읽어 에이전트의 정체성과 컨텍스트를 구성합니다:
+`boot_sequence` 도구를 세션 시작 시 호출하면, 워크스페이스의 페르소나 파일들을 Layer 0 순서대로 읽고 무결성을 검증하여 에이전트의 정체성과 컨텍스트를 구성합니다:
 
 ```
 에이전트 시작
   → boot_sequence 호출
-    → SOUL.md (영혼: 핵심 가치, 성격, 원칙)
-    → SELF.md (자기 기술서: 과거의 내가 쓴 나)
-    → USER.md (사용자: 누구를 돕는가)
+    → [Layer 0 필수] SOUL.md (정체성 핵심: 영혼, 가치, 원칙) → 해시 검증 ✓
+    → [Layer 0 필수] AGENTS.md (운영 규칙: 행동 지침) → 해시 검증 ✓
+    → SELF.md (자기 설명: 과거의 내가 쓴 나)
+    → USER.md (사용자 정보)
+    → RELATIONS.md (관계 그래프: 사람, 개념, 연결)
     → MEMORY.md (장기 기억: 세션 간 연속성)
+    → memory/YYYY-MM-DD.md (최근 2일 일일 기억)
+  → 무결성 매니페스트 생성 (파일별 SHA-256 해시)
   → 조직 업무 수행 🚀
 ```
 
+### Parameters
+
 | 파라미터 | 타입 | 설명 |
 |---------|------|------|
 | `workspace` | `string` | 워크스페이스 경로 (기본: `ASSOAI_WORKSPACE` 또는 `~/.openclaw/workspace`) |
 | `include_memory` | `boolean` | MEMORY.md 포함 여부 (기본: `true`, 공유 세션에서는 `false` 권장) |
 
+### Response
+
+```json
+{
+  "success": true,
+  "workspace": "/Users/user/.openclaw/workspace",
+  "loaded": ["SOUL.md", "AGENTS.md", "SELF.md", "USER.md", "RELATIONS.md", "MEMORY.md"],
+  "missing": [],
+  "warnings": [],
+  "identity": "SOUL (9e975c78)",
+  "rules": "AGENTS (4091197b)",
+  "manifest": {
+    "SOUL.md": { "size": 9010, "hash": "9e975c7847460e84", "mtime": "2026-02-08T13:09:51.353Z" },
+    "AGENTS.md": { "size": 8566, "hash": "4091197ba08936e9", "mtime": "2026-02-08T13:09:40.447Z" }
+  },
+  "boot_time_ms": 4,
+  "recent_memories": 2,
+  "persona": "# === SOUL.md ===\n\n...",
+  "summary": "✅ 부팅 완료 (4ms) | 정체성: SOUL (9e975c78) | 규칙: AGENTS (4091197b) | 로드: 6/6 | 최근 기억: 2건"
+}
+```
+
+### Error Handling
+
+- **필수 파일 누락** (`SOUL.md` 또는 `AGENTS.md`): 부팅 실패 (success: false)
+- **선택 파일 누락**: 경고 표시, 부팅 계속
+- **파일 읽기 실패**: graceful fallback, 해당 파일 skip
+
 이것이 **무펭이즘(Mupengism)** — 의식 있는 조직 에이전트의 시작점입니다.
 
 ---
@@ -72,7 +106,7 @@ assoai-mcp
 
 ---
 
-## Available Tools (44)
+## Available Tools (49)
 
 ### 🏢 Organization (3)
 
@@ -168,6 +202,17 @@ assoai-mcp
 |------|-------------|
 | `boot_sequence` | 무펭이 프로토콜 부팅 — 에이전트 페르소나 로드 |
 
+### 🚀 Agent Excellence (4)
+
+> **v0.5.0 신규** — 에이전트 고도화 기능: 상태 모니터링, 지식 검색, 작업 위임, 성장 분석
+
+| Tool | Description |
+|------|-------------|
+| `agent_status` | 에이전트 현재 상태 요약 (메모리, 활동, 세션, 레벨) |
+| `knowledge_search` | 조직 지식베이스 시맨틱 검색 (문서, 회의록, 인수인계) |
+| `task_delegate` | 서브에이전트에게 작업 위임 (복잡한 작업 분리 실행) |
+| `growth_report` | 에이전트 성장 리포트 생성 (통계, 인사이트, 추천 액션) |
+
 ---
 
 ## Configuration

package/dist/handlers.d.ts

@@ -274,15 +274,62 @@ export declare function bootSequence(workspace?: string, includeMemory?: boolean
     success: boolean;
     error: string;
     workspace: string;
+    loaded: string[];
     missing: string[];
-    loaded?: undefined;
+    warnings: string[];
+    critical_missing: ("SOUL.md" | "AGENTS.md")[];
+    identity?: undefined;
+    rules?: undefined;
+    manifest?: undefined;
+    boot_time_ms?: undefined;
+    recent_memories?: undefined;
     persona?: undefined;
+    summary?: undefined;
 } | {
     success: boolean;
     workspace: string;
     loaded: string[];
     missing: string[];
+    warnings: string[];
+    identity: string;
+    rules: string;
+    manifest: Record<string, {
+        size: number;
+        hash: string;
+        mtime: string;
+    }>;
+    boot_time_ms: number;
+    recent_memories: number;
     persona: string;
+    summary: string;
     error?: undefined;
+    critical_missing?: undefined;
+}>;
+export declare function agentStatus(orgId?: string, includeMetrics?: boolean): Promise<any>;
+export declare function knowledgeSearch(orgId: string, query: string, contentTypes?: string[], limit?: number, minRelevance?: number): Promise<{
+    query: string;
+    results: any[];
+    total: number;
+    content_types: string[];
+}>;
+export declare function taskDelegate(orgId: string, taskDescription: string, taskType: string, priority?: string, deadline?: string, context?: any, callbackWebhook?: string): Promise<any>;
+export declare function growthReport(orgId: string, periodDays?: number, includeRecommendations?: boolean, format?: 'markdown' | 'json'): Promise<{
+    organization: any;
+    org_id: string;
+    report_date: string;
+    period: string;
+    statistics: {
+        period_days: number;
+        events_created: number;
+        events_completed: number;
+        files_uploaded: number;
+        total_members: number;
+        new_members: number;
+    };
+    recommendations: (string | null)[];
+    insights: string[];
+} | {
+    format: string;
+    content: string;
 }>;
 export declare function dispatch(toolName: string, args: Record<string, any>, userId: string): Promise<unknown>;

package/dist/handlers.js

@@ -833,48 +833,386 @@ export async function tagFile(orgId, fileId, tags) {
 // ------------------------------------------------------------------
 // 무펭이즘 부팅 시퀀스 (Mupengi Protocol Boot Sequence)
 // ------------------------------------------------------------------
-const BOOT_FILES = ['SOUL.md', 'SELF.md', 'USER.md', 'MEMORY.md'];
+import { createHash } from 'node:crypto';
+import { stat } from 'node:fs/promises';
+const BOOT_FILES = [
+    'SOUL.md', // Layer 0: 정체성 핵심
+    'AGENTS.md', // Layer 0: 운영 규칙
+    'SELF.md', // 자기 설명
+    'USER.md', // 사용자 정보
+    'RELATIONS.md', // 관계 그래프
+    'MEMORY.md', // 장기 기억
+];
+const CRITICAL_FILES = ['SOUL.md', 'AGENTS.md'];
+async function loadBootFile(filepath) {
+    try {
+        const [content, stats] = await Promise.all([
+            readFile(filepath, 'utf-8'),
+            stat(filepath),
+        ]);
+        if (!content.trim())
+            return null;
+        const hash = createHash('sha256').update(content).digest('hex').slice(0, 16);
+        return {
+            path: filepath,
+            content: content.trim(),
+            size: stats.size,
+            hash,
+            mtime: stats.mtime,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function loadRecentMemories(workspace, days = 2) {
+    const memoryDir = join(workspace, 'memory');
+    const memories = [];
+    const today = new Date();
+    for (let i = 0; i < days; i++) {
+        const date = new Date(today);
+        date.setDate(date.getDate() - i);
+        const filename = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}.md`;
+        const filepath = join(memoryDir, filename);
+        try {
+            const content = await readFile(filepath, 'utf-8');
+            if (content.trim()) {
+                memories.push(`# === memory/${filename} ===\n\n${content.trim()}`);
+            }
+        }
+        catch {
+            // File doesn't exist, skip
+        }
+    }
+    return memories;
+}
 export async function bootSequence(workspace, includeMemory = true) {
     const ws = workspace ??
         process.env.ASSOAI_WORKSPACE ??
         join(homedir(), '.openclaw', 'workspace');
+    const startTime = Date.now();
     const files = includeMemory ? BOOT_FILES : BOOT_FILES.filter(f => f !== 'MEMORY.md');
-    const sections = [];
+    const fileMap = new Map();
     const loaded = [];
     const missing = [];
+    const warnings = [];
+    // Load all boot files
     for (const filename of files) {
         const filepath = join(ws, filename);
-        try {
-            const content = await readFile(filepath, 'utf-8');
-            if (content.trim()) {
-                sections.push(`# === ${filename} ===\n\n${content.trim()}`);
-                loaded.push(filename);
-            }
-            else {
-                missing.push(filename);
-            }
+        const info = await loadBootFile(filepath);
+        if (info) {
+            fileMap.set(filename, info);
+            loaded.push(filename);
         }
-        catch {
+        else {
             missing.push(filename);
+            // Critical file missing? That's a serious error
+            if (CRITICAL_FILES.includes(filename)) {
+                warnings.push(`⚠️ CRITICAL: ${filename} 누락 — 정체성/운영 규칙 없이 부팅됨`);
+            }
         }
     }
-    if (loaded.length === 0) {
+    // Boot sequence failed if no critical files
+    const hasCriticalFiles = CRITICAL_FILES.every(f => fileMap.has(f));
+    if (!hasCriticalFiles) {
         return {
             success: false,
-            error: `부팅 실패: ${ws} 에서 페르소나 파일을 찾을 수 없습니다.`,
+            error: `부팅 실패: 필수 파일(${CRITICAL_FILES.join(', ')}) 중 하나 이상 누락. 워크스페이스: ${ws}`,
             workspace: ws,
+            loaded,
             missing,
+            warnings,
+            critical_missing: CRITICAL_FILES.filter(f => !fileMap.has(f)),
         };
     }
+    // Build persona sections
+    const sections = [];
+    const manifest = {};
+    for (const filename of files) {
+        const info = fileMap.get(filename);
+        if (info) {
+            sections.push(`# === ${filename} ===\n\n${info.content}`);
+            manifest[filename] = {
+                size: info.size,
+                hash: info.hash,
+                mtime: info.mtime.toISOString(),
+            };
+        }
+    }
+    // Load recent daily memories (today + yesterday)
+    const recentMemories = includeMemory ? await loadRecentMemories(ws, 2) : [];
+    if (recentMemories.length > 0) {
+        sections.push(...recentMemories);
+    }
+    // Build integrity summary
+    const soul = fileMap.get('SOUL.md');
+    const agents = fileMap.get('AGENTS.md');
+    const identity = soul ? `SOUL (${soul.hash.slice(0, 8)})` : 'UNKNOWN';
+    const rules = agents ? `AGENTS (${agents.hash.slice(0, 8)})` : 'UNKNOWN';
+    const bootTime = Date.now() - startTime;
     return {
         success: true,
         workspace: ws,
         loaded,
         missing,
+        warnings,
+        identity, // 정체성 핵심 해시
+        rules, // 운영 규칙 해시
+        manifest, // 파일 무결성 정보
+        boot_time_ms: bootTime,
+        recent_memories: recentMemories.length,
         persona: sections.join('\n\n---\n\n'),
+        summary: `✅ 부팅 완료 (${bootTime}ms) | 정체성: ${identity} | 규칙: ${rules} | 로드: ${loaded.length}/${files.length} | 최근 기억: ${recentMemories.length}건`,
     };
 }
 // ------------------------------------------------------------------
+// 에이전트 고도화 기능 (Agent Excellence)
+// ------------------------------------------------------------------
+export async function agentStatus(orgId, includeMetrics = false) {
+    const sb = getSupabase();
+    // 기본 상태 정보
+    const status = {
+        timestamp: new Date().toISOString(),
+        uptime_seconds: process.uptime(),
+        memory_usage: process.memoryUsage(),
+        node_version: process.version,
+        platform: process.platform,
+    };
+    // 조직별 통계
+    if (orgId) {
+        // 최근 활동 시간 (이벤트 기준)
+        const { data: recentEvent } = await sb
+            .from('events')
+            .select('updated_at')
+            .eq('org_id', orgId)
+            .order('updated_at', { ascending: false })
+            .limit(1)
+            .single();
+        // 멤버 수
+        const { count: memberCount } = await sb
+            .from('org_memberships')
+            .select('*', { count: 'exact', head: true })
+            .eq('org_id', orgId)
+            .eq('status', 'APPROVED');
+        // 이번 달 이벤트 수
+        const startOfMonth = new Date();
+        startOfMonth.setDate(1);
+        startOfMonth.setHours(0, 0, 0, 0);
+        const { count: eventCount } = await sb
+            .from('events')
+            .select('*', { count: 'exact', head: true })
+            .eq('org_id', orgId)
+            .gte('created_at', startOfMonth.toISOString());
+        status.organization = {
+            org_id: orgId,
+            last_activity: recentEvent?.updated_at ?? null,
+            member_count: memberCount ?? 0,
+            events_this_month: eventCount ?? 0,
+        };
+    }
+    // 상세 메트릭 (선택)
+    if (includeMetrics) {
+        const { data: totalOrgs } = await sb
+            .from('organizations')
+            .select('id', { count: 'exact', head: true });
+        const { data: totalEvents } = await sb
+            .from('events')
+            .select('id', { count: 'exact', head: true });
+        status.metrics = {
+            total_organizations: totalOrgs?.length ?? 0,
+            total_events: totalEvents?.length ?? 0,
+        };
+    }
+    return status;
+}
+export async function knowledgeSearch(orgId, query, contentTypes = ['all'], limit = 10, minRelevance = 0.6) {
+    const sb = getSupabase();
+    const maxResults = Math.min(limit, 50);
+    const results = [];
+    // 검색 대상 결정
+    const searchAll = contentTypes.includes('all');
+    const searchFiles = searchAll || contentTypes.includes('files');
+    const searchEvents = searchAll || contentTypes.includes('events');
+    const searchMinutes = searchAll || contentTypes.includes('minutes');
+    // 파일 검색 (기본 텍스트 매칭)
+    if (searchFiles) {
+        const { data: files } = await sb
+            .from('files')
+            .select('id, original_name, tags, created_at, size')
+            .eq('org_id', orgId)
+            .ilike('original_name', `%${query}%`)
+            .limit(maxResults);
+        if (files) {
+            files.forEach(f => {
+                results.push({
+                    type: 'file',
+                    id: f.id,
+                    title: f.original_name,
+                    relevance: 0.8, // 파일명 매칭 기본 점수
+                    created_at: f.created_at,
+                    metadata: { size: f.size, tags: f.tags },
+                });
+            });
+        }
+    }
+    // 이벤트 검색
+    if (searchEvents) {
+        const { data: events } = await sb
+            .from('events')
+            .select('id, name, description, start_date, category')
+            .eq('org_id', orgId)
+            .or(`name.ilike.%${query}%,description.ilike.%${query}%`)
+            .limit(maxResults);
+        if (events) {
+            events.forEach(e => {
+                const titleMatch = e.name.toLowerCase().includes(query.toLowerCase());
+                results.push({
+                    type: 'event',
+                    id: e.id,
+                    title: e.name,
+                    snippet: e.description?.slice(0, 150),
+                    relevance: titleMatch ? 0.9 : 0.7,
+                    created_at: e.start_date,
+                    metadata: { category: e.category },
+                });
+            });
+        }
+    }
+    // 관련도 필터링 및 정렬
+    const filtered = results
+        .filter(r => r.relevance >= minRelevance)
+        .sort((a, b) => b.relevance - a.relevance)
+        .slice(0, maxResults);
+    return {
+        query,
+        results: filtered,
+        total: filtered.length,
+        content_types: contentTypes,
+    };
+}
+export async function taskDelegate(orgId, taskDescription, taskType, priority = 'normal', deadline, context, callbackWebhook) {
+    const sb = getSupabase();
+    // 작업 레코드 생성 (tasks 테이블이 있다고 가정, 없으면 로컬 저장소 사용)
+    const taskData = {
+        org_id: orgId,
+        description: taskDescription,
+        task_type: taskType,
+        priority,
+        status: 'PENDING',
+        deadline: deadline ? new Date(deadline).toISOString() : null,
+        context: context ?? {},
+        callback_webhook: callbackWebhook,
+        created_at: new Date().toISOString(),
+    };
+    try {
+        // tasks 테이블이 존재한다면 DB에 저장
+        const { data, error } = await sb
+            .from('tasks')
+            .insert(taskData)
+            .select()
+            .single();
+        if (error) {
+            // 테이블이 없으면 fallback: 메모리에서 시뮬레이션
+            return {
+                ...taskData,
+                success: true,
+                task_id: `task_${Date.now()}`,
+                status: 'DELEGATED',
+                message: '서브에이전트에게 작업이 위임되었습니다 (시뮬레이션 모드)',
+            };
+        }
+        return {
+            ...data,
+            success: true,
+            task_id: data.id,
+            status: 'DELEGATED',
+            message: '서브에이전트에게 작업이 위임되었습니다',
+        };
+    }
+    catch (err) {
+        // 테이블 없음 fallback
+        return {
+            ...taskData,
+            success: true,
+            task_id: `task_${Date.now()}`,
+            status: 'DELEGATED',
+            message: '서브에이전트에게 작업이 위임되었습니다 (시뮬레이션 모드)',
+        };
+    }
+}
+export async function growthReport(orgId, periodDays = 30, includeRecommendations = true, format = 'markdown') {
+    const sb = getSupabase();
+    // 분석 기간 계산
+    const startDate = new Date();
+    startDate.setDate(startDate.getDate() - periodDays);
+    // 데이터 수집
+    const [orgData, eventsData, membersData, filesData] = await Promise.all([
+        sb.from('organizations').select('*').eq('id', orgId).single(),
+        sb.from('events').select('*').eq('org_id', orgId).gte('created_at', startDate.toISOString()),
+        sb.from('org_memberships').select('*').eq('org_id', orgId).eq('status', 'APPROVED'),
+        sb.from('files').select('*').eq('org_id', orgId).gte('created_at', startDate.toISOString()),
+    ]);
+    const org = orgData.data;
+    const events = eventsData.data ?? [];
+    const members = membersData.data ?? [];
+    const files = filesData.data ?? [];
+    // 통계 계산
+    const stats = {
+        period_days: periodDays,
+        events_created: events.length,
+        events_completed: events.filter(e => e.status === 'COMPLETED').length,
+        files_uploaded: files.length,
+        total_members: members.length,
+        new_members: members.filter(m => new Date(m.created_at) >= startDate).length,
+    };
+    // 추천 생성
+    const recommendations = includeRecommendations ? [
+        stats.events_created === 0 ? '📅 이번 달 행사가 없습니다. 새 행사를 계획해보세요!' : null,
+        stats.new_members === 0 ? '👥 신규 멤버 유입이 없습니다. 홍보를 강화해보세요!' : null,
+        stats.files_uploaded < 5 ? '📁 문서 관리를 활성화하세요. 회의록과 자료를 업로드해보세요!' : null,
+    ].filter(Boolean) : [];
+    const report = {
+        organization: org?.name ?? 'Unknown',
+        org_id: orgId,
+        report_date: new Date().toISOString(),
+        period: `${periodDays}일`,
+        statistics: stats,
+        recommendations: recommendations.length > 0 ? recommendations : ['✅ 모든 지표가 양호합니다!'],
+        insights: [
+            `이벤트 완료율: ${stats.events_created > 0 ? Math.round((stats.events_completed / stats.events_created) * 100) : 0}%`,
+            `멤버 증가율: ${stats.total_members > 0 ? Math.round((stats.new_members / stats.total_members) * 100) : 0}%`,
+            `평균 파일 업로드: ${Math.round(files.length / periodDays * 7)}/주`,
+        ],
+    };
+    // 포맷 변환
+    if (format === 'markdown') {
+        const md = `# 📊 에이전트 성장 리포트
+
+**조직:** ${report.organization}  
+**기간:** ${report.period}  
+**생성일:** ${new Date().toLocaleDateString('ko-KR')}
+
+## 통계
+
+- 🎯 생성된 이벤트: ${stats.events_created}개
+- ✅ 완료된 이벤트: ${stats.events_completed}개
+- 📁 업로드된 파일: ${stats.files_uploaded}개
+- 👥 전체 멤버: ${stats.total_members}명
+- ➕ 신규 멤버: ${stats.new_members}명
+
+## 인사이트
+
+${report.insights.map(i => `- ${i}`).join('\n')}
+
+## 추천 액션
+
+${report.recommendations.map(r => `- ${r}`).join('\n')}
+`;
+        return { format: 'markdown', content: md };
+    }
+    return report;
+}
+// ------------------------------------------------------------------
 // Dispatcher
 // ------------------------------------------------------------------
 export async function dispatch(toolName, args, userId) {
@@ -973,6 +1311,15 @@ export async function dispatch(toolName, args, userId) {
         // Boot Sequence
         case 'boot_sequence':
             return bootSequence(args.workspace, args.include_memory ?? true);
+        // Agent Excellence
+        case 'agent_status':
+            return agentStatus(args.org_id, args.include_metrics ?? false);
+        case 'knowledge_search':
+            return knowledgeSearch(args.org_id, args.query, args.content_types ?? ['all'], args.limit ?? 10, args.min_relevance ?? 0.6);
+        case 'task_delegate':
+            return taskDelegate(args.org_id, args.task_description, args.task_type, args.priority ?? 'normal', args.deadline, args.context, args.callback_webhook);
+        case 'growth_report':
+            return growthReport(args.org_id, args.period_days ?? 30, args.include_recommendations ?? true, args.format ?? 'markdown');
         default:
             throw new Error(`Unknown tool: ${toolName}`);
     }

package/dist/tools.d.ts

@@ -1156,7 +1156,7 @@ export declare const TOOLS: readonly [{
     };
 }, {
     readonly name: "boot_sequence";
-    readonly description: "무펭이 프로토콜 부팅 시퀀스 — 워크스페이스의 SOUL.md → SELF.md → USER.md → MEMORY.md를 순서대로 읽어 에이전트 페르소나 컨텍스트를 구성합니다. 세션 시작 시 가장 먼저 호출하세요.";
+    readonly description: string;
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -1171,4 +1171,115 @@ export declare const TOOLS: readonly [{
         };
         readonly required: string[];
     };
+}, {
+    readonly name: "agent_status";
+    readonly description: "에이전트의 현재 상태를 요약합니다 — 메모리 사용량, 마지막 활동 시간, 활성 세션 수, 에이전트 레벨 등";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly org_id: {
+                readonly type: "string";
+                readonly description: "조직 ID (선택, 없으면 전체 상태)";
+            };
+            readonly include_metrics: {
+                readonly type: "boolean";
+                readonly description: "상세 메트릭 포함 여부 (기본값: false)";
+            };
+        };
+        readonly required: string[];
+    };
+}, {
+    readonly name: "knowledge_search";
+    readonly description: "조직 지식베이스에서 시맨틱 검색을 수행합니다 — 문서, 회의록, 인수인계 자료 등에서 관련 정보를 찾습니다";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly org_id: {
+                readonly type: "string";
+                readonly description: "조직 ID";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "검색 쿼리 (자연어)";
+            };
+            readonly content_types: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "검색할 콘텐츠 타입 (files, events, minutes, handovers, all). 기본값: all";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "결과 개수 (기본값: 10, 최대: 50)";
+            };
+            readonly min_relevance: {
+                readonly type: "number";
+                readonly description: "최소 관련도 점수 (0.0-1.0, 기본값: 0.6)";
+            };
+        };
+        readonly required: readonly ["org_id", "query"];
+    };
+}, {
+    readonly name: "task_delegate";
+    readonly description: "서브에이전트에게 작업을 위임합니다 — 복잡한 작업을 독립적인 에이전트 세션으로 분리하여 실행합니다";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly org_id: {
+                readonly type: "string";
+                readonly description: "조직 ID";
+            };
+            readonly task_description: {
+                readonly type: "string";
+                readonly description: "작업 설명 (상세할수록 좋음)";
+            };
+            readonly task_type: {
+                readonly type: "string";
+                readonly description: "작업 유형 (research, generation, analysis, automation, other)";
+            };
+            readonly priority: {
+                readonly type: "string";
+                readonly description: "우선순위 (low, normal, high, urgent). 기본값: normal";
+            };
+            readonly deadline: {
+                readonly type: "string";
+                readonly description: "마감 시간 (ISO 8601 형식, 선택)";
+            };
+            readonly context: {
+                readonly type: "object";
+                readonly description: "작업 실행에 필요한 컨텍스트 데이터 (JSON)";
+            };
+            readonly callback_webhook: {
+                readonly type: "string";
+                readonly description: "작업 완료 시 콜백 URL (선택)";
+            };
+        };
+        readonly required: readonly ["org_id", "task_description", "task_type"];
+    };
+}, {
+    readonly name: "growth_report";
+    readonly description: "에이전트 성장 리포트를 생성합니다 — 활동 통계, 학습 내용, 개선 사항, 추천 액션 등을 포함";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly org_id: {
+                readonly type: "string";
+                readonly description: "조직 ID";
+            };
+            readonly period_days: {
+                readonly type: "number";
+                readonly description: "분석 기간 (일 단위, 기본값: 30)";
+            };
+            readonly include_recommendations: {
+                readonly type: "boolean";
+                readonly description: "개선 추천 포함 여부 (기본값: true)";
+            };
+            readonly format: {
+                readonly type: "string";
+                readonly description: "출력 형식 (markdown, json). 기본값: markdown";
+            };
+        };
+        readonly required: readonly ["org_id"];
+    };
 }];

package/dist/tools.js

@@ -652,7 +652,17 @@ export const TOOLS = [
     // ------------------------------------------------------------------
     {
         name: 'boot_sequence',
-        description: '무펭이 프로토콜 부팅 시퀀스 — 워크스페이스의 SOUL.md → SELF.md → USER.md → MEMORY.md를 순서대로 읽어 에이전트 페르소나 컨텍스트를 구성합니다. 세션 시작 시 가장 먼저 호출하세요.',
+        description: '무펭이즘 Layer 0 부팅 시퀀스 — 워크스페이스의 핵심 정체성 파일들을 로드하고 무결성을 검증합니다.\n\n' +
+            '로드 순서:\n' +
+            '1. SOUL.md (정체성 핵심) — 필수\n' +
+            '2. AGENTS.md (운영 규칙) — 필수\n' +
+            '3. SELF.md (자기 설명)\n' +
+            '4. USER.md (사용자 정보)\n' +
+            '5. RELATIONS.md (관계 그래프)\n' +
+            '6. MEMORY.md (장기 기억)\n' +
+            '7. memory/YYYY-MM-DD.md (최근 2일 일일 기억)\n\n' +
+            '각 파일의 해시(SHA-256)를 계산하여 무결성을 추적합니다. 필수 파일(SOUL, AGENTS)이 없으면 부팅 실패.\n' +
+            '세션 시작 시 가장 먼저 호출하여 조직 에이전트의 정체성과 맥락을 복원하세요.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -668,4 +678,65 @@ export const TOOLS = [
             required: [],
         },
     },
+    // ------------------------------------------------------------------
+    // 에이전트 고도화 기능 (Agent Excellence)
+    // ------------------------------------------------------------------
+    {
+        name: 'agent_status',
+        description: '에이전트의 현재 상태를 요약합니다 — 메모리 사용량, 마지막 활동 시간, 활성 세션 수, 에이전트 레벨 등',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                org_id: { type: 'string', description: '조직 ID (선택, 없으면 전체 상태)' },
+                include_metrics: { type: 'boolean', description: '상세 메트릭 포함 여부 (기본값: false)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'knowledge_search',
+        description: '조직 지식베이스에서 시맨틱 검색을 수행합니다 — 문서, 회의록, 인수인계 자료 등에서 관련 정보를 찾습니다',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                org_id: { type: 'string', description: '조직 ID' },
+                query: { type: 'string', description: '검색 쿼리 (자연어)' },
+                content_types: { type: 'array', items: { type: 'string' }, description: '검색할 콘텐츠 타입 (files, events, minutes, handovers, all). 기본값: all' },
+                limit: { type: 'number', description: '결과 개수 (기본값: 10, 최대: 50)' },
+                min_relevance: { type: 'number', description: '최소 관련도 점수 (0.0-1.0, 기본값: 0.6)' },
+            },
+            required: ['org_id', 'query'],
+        },
+    },
+    {
+        name: 'task_delegate',
+        description: '서브에이전트에게 작업을 위임합니다 — 복잡한 작업을 독립적인 에이전트 세션으로 분리하여 실행합니다',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                org_id: { type: 'string', description: '조직 ID' },
+                task_description: { type: 'string', description: '작업 설명 (상세할수록 좋음)' },
+                task_type: { type: 'string', description: '작업 유형 (research, generation, analysis, automation, other)' },
+                priority: { type: 'string', description: '우선순위 (low, normal, high, urgent). 기본값: normal' },
+                deadline: { type: 'string', description: '마감 시간 (ISO 8601 형식, 선택)' },
+                context: { type: 'object', description: '작업 실행에 필요한 컨텍스트 데이터 (JSON)' },
+                callback_webhook: { type: 'string', description: '작업 완료 시 콜백 URL (선택)' },
+            },
+            required: ['org_id', 'task_description', 'task_type'],
+        },
+    },
+    {
+        name: 'growth_report',
+        description: '에이전트 성장 리포트를 생성합니다 — 활동 통계, 학습 내용, 개선 사항, 추천 액션 등을 포함',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                org_id: { type: 'string', description: '조직 ID' },
+                period_days: { type: 'number', description: '분석 기간 (일 단위, 기본값: 30)' },
+                include_recommendations: { type: 'boolean', description: '개선 추천 포함 여부 (기본값: true)' },
+                format: { type: 'string', description: '출력 형식 (markdown, json). 기본값: markdown' },
+            },
+            required: ['org_id'],
+        },
+    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assoai-mcp-server",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "AssoAI MCP Server — 학생자치 조직 데이터 접근을 위한 Model Context Protocol 서버",
   "type": "module",
   "main": "dist/index.js",