aiexecode 1.0.94 → 1.0.127

package/src/ai_based/orchestrator.js

@@ -2,9 +2,10 @@ import dotenv from "dotenv";
 // 이 파일은 계획을 실제 행동으로 옮기기 위해 어떤 도구를 호출할지 결정합니다.
 import path from 'path';
 import { truncateWithOmit } from "../util/text_formatter.js";
-import { createSystemMessage } from "../util/prompt_loader.js";
+import { createSystemMessage, createTodoReminder, createSystemReminder, createTrimmedFileReminder } from "../util/prompt_loader.js";
 import { request, shouldRetryWithTrim, getModelForProvider } from "../system/ai_request.js";
-import { cleanupOrphanOutputs, trimConversation } from "../system/conversation_trimmer.js";
+import { supportsCaching } from "../config/ai_models.js";
+import { cleanupOrphanOutputs, trimConversation, getTrimmedFileReads, clearTrimmedFileReads } from "../system/conversation_trimmer.js";
 import { runPythonCodeSchema, bashSchema } from "../system/code_executer.js";
 import { readFileSchema, readFileRangeSchema } from "../tools/file_reader.js";
 import { writeFileSchema, editFileRangeSchema, editFileReplaceSchema } from "../tools/code_editor.js";
@@ -13,9 +14,11 @@ import { responseMessageSchema } from "../tools/response_message.js";
 import { todoWriteSchema } from "../tools/todo_write.js";
 import { ripgrepSchema } from "../tools/ripgrep.js";
 import { globSearchSchema } from "../tools/glob.js";
+import { skillSchema, generateSkillListForPrompt } from "../tools/skill_tool.js";
 import { loadSettings } from "../util/config.js";
 import { createDebugLogger } from "../util/debug_log.js";
 import { getCurrentTodos } from "../system/session_memory.js";
+import { loadAgentsMdForPrompt } from "../system/agents_loader.js";
 dotenv.config({ quiet: true });
 
 const debugLog = createDebugLogger('orchestrator.log', 'orchestrator');
@@ -26,42 +29,144 @@ let orchestratorRequestOptions = null;
 /**
  * Orchestrator conversation을 초기화하거나 시스템 프롬프트를 업데이트합니다.
  * 매 요청마다 프롬프트 파일을 새로 읽어서 변경사항을 즉시 반영합니다.
+ *
+ * 로그 분석에서 발견한 전략 적용:
+ * 1. 캐시 제어 (cache_control: ephemeral) - Z.AI/GLM 모델의 경우
+ * 2. System-Reminder 패턴 - TODO 상태 등을 별도 블록으로 분리
+ * 3. 다중 시스템 메시지 구조 - 캐시 효과 극대화
  */
 async function ensureConversationInitialized() {
-    // 매번 최신 시스템 프롬프트를 로드
+    // 현재 모델 확인 (캐시 제어 여부 결정)
+    const currentModel = await getModelForProvider();
+    const useCache = supportsCaching(currentModel);
+    debugLog(`[ensureConversationInitialized] Model: ${currentModel}, Cache enabled: ${useCache}`);
+
+    // 매번 최신 시스템 프롬프트를 로드 (캐시 제어 옵션 적용)
     const systemMessage = await createSystemMessage("orchestrator.txt", {
         CWD: process.cwd(),
         OS: process.app_custom?.systemInfo?.os || 'unknown'
+    }, {
+        model: currentModel,
+        enableCache: useCache
     });
 
     // 현재 todos 가져오기
     const currentTodos = getCurrentTodos();
 
-    // todos를 system message에 추가
-    let systemMessageText = systemMessage.content;
-    if (currentTodos && currentTodos.length > 0) {
-        const todosSection = '\n\n## Current Task List (Your TODO tracker)\n\n' +
-            'You have created the following task list to track your work. Continue working on these tasks systematically:\n\n' +
-            currentTodos.map((todo, index) => {
-                const statusIcon = todo.status === 'completed' ? '✓' :
-                                  todo.status === 'in_progress' ? '→' : '○';
-                return `${index + 1}. [${statusIcon}] ${todo.content} (${todo.status})`;
-            }).join('\n') +
-            '\n\n**Remember**: Mark tasks as completed immediately after finishing them. Keep exactly ONE task as in_progress at a time.\n';
-
-        systemMessageText += todosSection;
-        debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos to system message`);
-    }
+    // 사용 가능한 스킬 목록 생성
+    const skillListText = await generateSkillListForPrompt();
+    debugLog(`[ensureConversationInitialized] Generated skill list: ${skillListText ? 'has skills' : 'no skills'}`);
+
+    // AGENTS.md 로드 (프로젝트별 에이전트 지침)
+    const agentsMdText = await loadAgentsMdForPrompt();
+    debugLog(`[ensureConversationInitialized] AGENTS.md: ${agentsMdText ? `loaded (${agentsMdText.length} chars)` : 'not found'}`);
+
+    // 시스템 메시지 구성 (캐싱 모델의 경우 다중 블록 구조)
+    let systemMessageEntry;
+
+    if (useCache && Array.isArray(systemMessage.content)) {
+        // 캐싱 모델: 다중 블록 구조 사용 (Claude Code 스타일)
+        const contentBlocks = [...systemMessage.content];
+
+        // AGENTS.md를 별도 블록으로 추가 (프로젝트별 지침)
+        if (agentsMdText) {
+            contentBlocks.push({
+                type: "input_text",
+                text: agentsMdText,
+                cache_control: { type: "ephemeral" }  // 프로젝트가 바뀔 때만 변경되므로 캐시
+            });
+            debugLog(`[ensureConversationInitialized] Added AGENTS.md as separate block (cached)`);
+        }
+
+        // 스킬 목록을 별도 블록으로 추가
+        if (skillListText) {
+            contentBlocks.push({
+                type: "input_text",
+                text: skillListText
+                // 스킬 목록은 자주 변경될 수 있으므로 캐시하지 않음
+            });
+            debugLog(`[ensureConversationInitialized] Added skill list as separate block`);
+        }
 
-    const systemMessageEntry = {
-        role: "system",
-        content: [
-            {
+        // TODO 리마인더를 별도 블록으로 추가 (캐시 대상 아님)
+        if (currentTodos && currentTodos.length > 0) {
+            const todoReminder = createTodoReminder(currentTodos);
+            contentBlocks.push({
                 type: "input_text",
-                text: systemMessageText
+                text: todoReminder
+                // cache_control 없음 - 동적 데이터이므로
+            });
+            debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos as separate block (uncached)`);
+        }
+
+        // Trim된 파일 읽기 알림 추가 (파일 경로 알림 기능)
+        const trimmedFiles = getTrimmedFileReads();
+        if (trimmedFiles.length > 0) {
+            const trimmedFileReminder = createTrimmedFileReminder(trimmedFiles);
+            if (trimmedFileReminder) {
+                contentBlocks.push({
+                    type: "input_text",
+                    text: trimmedFileReminder
+                    // cache_control 없음 - 동적 데이터이므로
+                });
+                debugLog(`[ensureConversationInitialized] Added trimmed file reminder for ${trimmedFiles.length} files (uncached)`);
             }
-        ]
-    };
+        }
+
+        systemMessageEntry = {
+            role: "system",
+            content: contentBlocks
+        };
+    } else {
+        // 일반 모델: 기존 방식 유지
+        let systemMessageText = systemMessage.content;
+
+        // AGENTS.md 추가 (프로젝트별 지침)
+        if (agentsMdText) {
+            systemMessageText += agentsMdText;
+            debugLog(`[ensureConversationInitialized] Added AGENTS.md to system message`);
+        }
+
+        // 스킬 목록 추가
+        if (skillListText) {
+            systemMessageText += skillListText;
+            debugLog(`[ensureConversationInitialized] Added skill list to system message`);
+        }
+
+        if (currentTodos && currentTodos.length > 0) {
+            const todosSection = '\n\n## Current Task List (Your TODO tracker)\n\n' +
+                'You have created the following task list to track your work. Continue working on these tasks systematically:\n\n' +
+                currentTodos.map((todo, index) => {
+                    const statusIcon = todo.status === 'completed' ? '✓' :
+                                      todo.status === 'in_progress' ? '→' : '○';
+                    return `${index + 1}. [${statusIcon}] ${todo.content} (${todo.status})`;
+                }).join('\n') +
+                '\n\n**Remember**: Mark tasks as completed immediately after finishing them. Keep exactly ONE task as in_progress at a time.\n';
+
+            systemMessageText += todosSection;
+            debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos to system message`);
+        }
+
+        // Trim된 파일 읽기 알림 추가 (파일 경로 알림 기능)
+        const trimmedFiles = getTrimmedFileReads();
+        if (trimmedFiles.length > 0) {
+            const trimmedFileReminder = createTrimmedFileReminder(trimmedFiles);
+            if (trimmedFileReminder) {
+                systemMessageText += '\n\n' + trimmedFileReminder;
+                debugLog(`[ensureConversationInitialized] Added trimmed file reminder for ${trimmedFiles.length} files`);
+            }
+        }
+
+        systemMessageEntry = {
+            role: "system",
+            content: [
+                {
+                    type: "input_text",
+                    text: systemMessageText
+                }
+            ]
+        };
+    }
 
     // conversation이 비어있으면 새로 추가
     if (!orchestratorConversation.length) {
@@ -97,6 +202,7 @@ function appendResponseToConversation(response) {
 export function resetOrchestratorConversation() {
     orchestratorConversation.length = 0;
     orchestratorRequestOptions = null;
+    clearTrimmedFileReads(); // 세션 초기화 시 trim된 파일 목록도 초기화
 }
 
 export function getOrchestratorConversation() {
@@ -201,11 +307,13 @@ async function dispatchOrchestratorRequest({ toolChoice }) {
         const estimatedTokens = Math.ceil(conversationJson.length / 4); // 대략 4 chars = 1 token
         debugLog(`[dispatchOrchestratorRequest] Estimated tokens: ${estimatedTokens} (conversation size: ${conversationJson.length} bytes)`);
 
-        debugLog(`[dispatchOrchestratorRequest] Sending API request...`);
+        const apiStartTime = Date.now();
+        debugLog(`[dispatchOrchestratorRequest] >>>>> Sending API request at ${new Date(apiStartTime).toISOString()}...`);
 
         try {
             const response = await request(taskName, requestConfig);
-            debugLog(`[dispatchOrchestratorRequest] API request successful`);
+            const apiDuration = Date.now() - apiStartTime;
+            debugLog(`[dispatchOrchestratorRequest] <<<<< API request successful in ${apiDuration}ms`);
             debugLog(`[dispatchOrchestratorRequest] Response outputs: ${response?.output?.length || 0}`);
             if (response?.output) {
                 const outputTypes = {};
@@ -219,7 +327,8 @@ async function dispatchOrchestratorRequest({ toolChoice }) {
             // consolelog(JSON.stringify(response, null, 2));
             return response;
         } catch (error) {
-            debugLog(`[dispatchOrchestratorRequest] API request failed: ${error.message}`);
+            const apiDuration = Date.now() - apiStartTime;
+            debugLog(`[dispatchOrchestratorRequest] <<<<< API request FAILED after ${apiDuration}ms: ${error.message}`);
             debugLog(`[dispatchOrchestratorRequest] Error name: ${error.name}, type: ${error?.constructor?.name}`);
 
             // AbortError는 즉시 전파 (세션 중단)
@@ -308,7 +417,8 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
         response_message: responseMessageSchema,
         todo_write: todoWriteSchema,
         ripgrep: ripgrepSchema,
-        glob_search: globSearchSchema
+        glob_search: globSearchSchema,
+        invoke_skill: skillSchema  // 스킬 호출 도구
     };
 
     // Python 관련 도구 (조건부 추가)
@@ -355,14 +465,40 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
     debugLog(`[orchestrateMission] Conversation initialized, current length: ${orchestratorConversation.length}`);
 
     debugLog(`[orchestrateMission] Adding user message to conversation: "${improvementPointsText.substring(0, 100)}"`);
+
+    // 캐싱 모델인 경우 사용자 메시지에도 캐시 제어 적용 (Claude Code 스타일)
+    const useCache = supportsCaching(model);
+    const userContentBlocks = [];
+
+    // Auto-generated 메시지의 경우 system-reminder 추가
+    if (isAutoGenerated) {
+        const autoGenReminder = createSystemReminder(
+            '이 메시지는 시스템에서 자동 생성되었습니다. 사용자가 직접 입력한 것이 아닙니다.',
+            { hideFromUser: true }
+        );
+        userContentBlocks.push({
+            type: "input_text",
+            text: autoGenReminder
+        });
+    }
+
+    // 메인 사용자 메시지
+    const mainContent = {
+        type: "input_text",
+        text: improvementPointsText
+    };
+
+    // 캐싱 모델의 경우 사용자 메시지에도 캐시 적용 (반복되는 긴 메시지에 효과적)
+    if (useCache && improvementPointsText.length > 500) {
+        mainContent.cache_control = { type: "ephemeral" };
+        debugLog(`[orchestrateMission] Applied cache control to user message (${improvementPointsText.length} chars)`);
+    }
+
+    userContentBlocks.push(mainContent);
+
     const userMessage = {
         role: "user",
-        content: [
-            {
-                type: "input_text",
-                text: improvementPointsText
-            }
-        ]
+        content: userContentBlocks
     };
 
     // Auto-generated user message인 경우 _internal_only 플래그 추가

package/src/commands/agents.js

@@ -0,0 +1,70 @@
+import { uiEvents } from '../system/ui_events.js';
+import {
+    formatAgentsMdSummary,
+    discoverAllAgentsMd
+} from '../system/agents_loader.js';
+import { safeReadFile } from '../util/safe_fs.js';
+
+/**
+ * /agents 커맨드 - AGENTS.md 파일 조회
+ *
+ * 사용법:
+ *   /agents           - 로드된 AGENTS.md 파일 목록 및 요약 표시
+ *   /agents <path>    - 특정 AGENTS.md 파일 전체 내용 표시
+ */
+export default {
+    name: 'agents',
+    description: 'Show AGENTS.md files and their contents',
+    usage: '/agents [file-path]',
+    handler: async (args, context) => {
+        if (!args || args.length === 0) {
+            // AGENTS.md 요약 표시
+            const summary = await formatAgentsMdSummary();
+            uiEvents.addSystemMessage(summary);
+            return;
+        }
+
+        // 특정 파일 내용 표시
+        const filePath = args[0];
+
+        // 숫자가 입력된 경우 인덱스로 처리
+        const index = parseInt(filePath, 10);
+        if (!isNaN(index) && index > 0) {
+            const agentsMdFiles = await discoverAllAgentsMd();
+            if (index > agentsMdFiles.length) {
+                uiEvents.addSystemMessage(`Invalid index: ${index}. Found ${agentsMdFiles.length} AGENTS.md file(s).`);
+                return;
+            }
+
+            const file = agentsMdFiles[index - 1];
+            const info = [
+                `AGENTS.md (${file.source})`,
+                `Path: ${file.path}`,
+                '',
+                '--- Content ---',
+                '',
+                file.content
+            ].join('\n');
+
+            uiEvents.addSystemMessage(info);
+            return;
+        }
+
+        // 경로가 입력된 경우 해당 파일 읽기
+        try {
+            const content = await safeReadFile(filePath, 'utf8');
+            const info = [
+                `AGENTS.md`,
+                `Path: ${filePath}`,
+                '',
+                '--- Content ---',
+                '',
+                content
+            ].join('\n');
+
+            uiEvents.addSystemMessage(info);
+        } catch (error) {
+            uiEvents.addSystemMessage(`Failed to read file: ${filePath}\n${error.message}`);
+        }
+    }
+};

package/src/commands/apikey.js

@@ -15,7 +15,7 @@ export default {
             uiEvents.addSystemMessage(
                 `Please enter API key.\n\n` +
                 `Usage:\n` +
-                `  /apikey sk-proj-...`
+                `  /apikey <your-zai-api-key>`
             );
             return;
         }

package/src/commands/bg.js

@@ -0,0 +1,129 @@
+import { listBackgroundProcesses, killBackgroundProcess, getBackgroundProcess } from '../system/background_process.js';
+import { uiEvents } from '../system/ui_events.js';
+
+/**
+ * /bg 커맨드 - 백그라운드 프로세스 관리
+ *
+ * 사용법:
+ *   /bg          - 프로세스 목록 표시
+ *   /bg list     - 프로세스 목록 표시
+ *   /bg kill <id> - 프로세스 종료
+ *   /bg killall  - 모든 실행 중인 프로세스 종료
+ */
+export default {
+    name: 'bg',
+    description: 'Manage background processes',
+    usage: '/bg [list|kill <id>|killall]',
+    handler: async (args, context) => {
+        const subcommand = args[0]?.toLowerCase() || 'list';
+
+        switch (subcommand) {
+            case 'list':
+            case 'ls': {
+                const processes = listBackgroundProcesses({ running: true });
+                if (processes.length === 0) {
+                    uiEvents.addSystemMessage('No running background processes');
+                    return;
+                }
+
+                const lines = ['Background Processes:'];
+                for (const proc of processes) {
+                    const statusIcon = proc.status === 'running' ? '●' :
+                                       proc.status === 'completed' ? '✓' :
+                                       proc.status === 'failed' ? '✗' : '⊘';
+                    const duration = formatDuration(proc.startedAt, proc.endedAt);
+                    lines.push(`  ${statusIcon} [${proc.id}] pid:${proc.pid} ${duration} - ${proc.command.substring(0, 50)}${proc.command.length > 50 ? '...' : ''}`);
+                }
+                uiEvents.addSystemMessage(lines.join('\n'));
+                break;
+            }
+
+            case 'kill': {
+                const id = args[1];
+                if (!id) {
+                    uiEvents.addErrorMessage('Usage: /bg kill <process_id>');
+                    return;
+                }
+
+                const proc = getBackgroundProcess(id);
+                if (!proc) {
+                    uiEvents.addErrorMessage(`Process not found: ${id}`);
+                    return;
+                }
+
+                if (proc.status !== 'running') {
+                    uiEvents.addSystemMessage(`Process ${id} is already ${proc.status}`);
+                    return;
+                }
+
+                const killed = killBackgroundProcess(id);
+                if (killed) {
+                    uiEvents.addSystemMessage(`Killed process: ${id} (pid: ${proc.pid})`);
+                } else {
+                    uiEvents.addErrorMessage(`Failed to kill process: ${id}`);
+                }
+                break;
+            }
+
+            case 'killall': {
+                const processes = listBackgroundProcesses({ running: true });
+                if (processes.length === 0) {
+                    uiEvents.addSystemMessage('No running background processes');
+                    return;
+                }
+
+                let killedCount = 0;
+                for (const proc of processes) {
+                    if (killBackgroundProcess(proc.id)) {
+                        killedCount++;
+                    }
+                }
+                uiEvents.addSystemMessage(`Killed ${killedCount} background process(es)`);
+                break;
+            }
+
+            case 'show': {
+                const id = args[1];
+                if (!id) {
+                    uiEvents.addErrorMessage('Usage: /bg show <process_id>');
+                    return;
+                }
+
+                const proc = getBackgroundProcess(id);
+                if (!proc) {
+                    uiEvents.addErrorMessage(`Process not found: ${id}`);
+                    return;
+                }
+
+                const lines = [
+                    `Process: ${proc.id}`,
+                    `  PID: ${proc.pid}`,
+                    `  Status: ${proc.status}`,
+                    `  Command: ${proc.command}`,
+                    `  Started: ${proc.startedAt.toISOString()}`,
+                    proc.endedAt ? `  Ended: ${proc.endedAt.toISOString()}` : null,
+                    proc.exitCode !== null ? `  Exit Code: ${proc.exitCode}` : null,
+                    proc.stdout ? `  Stdout (last 200 chars): ${proc.stdout.slice(-200)}` : null,
+                    proc.stderr ? `  Stderr (last 200 chars): ${proc.stderr.slice(-200)}` : null,
+                ].filter(Boolean);
+
+                uiEvents.addSystemMessage(lines.join('\n'));
+                break;
+            }
+
+            default:
+                uiEvents.addErrorMessage(`Unknown subcommand: ${subcommand}\nUsage: /bg [list|kill <id>|killall|show <id>]`);
+        }
+    }
+};
+
+function formatDuration(startedAt, endedAt) {
+    const end = endedAt ? new Date(endedAt) : new Date();
+    const start = new Date(startedAt);
+    const diffMs = end - start;
+
+    if (diffMs < 1000) return `${diffMs}ms`;
+    if (diffMs < 60000) return `${Math.round(diffMs / 1000)}s`;
+    if (diffMs < 3600000) return `${Math.round(diffMs / 60000)}m`;
+    return `${Math.round(diffMs / 3600000)}h`;
+}

package/src/commands/commands.js

@@ -0,0 +1,51 @@
+import { uiEvents } from '../system/ui_events.js';
+import {
+    formatCustomCommandList,
+    findCustomCommandByName
+} from '../system/custom_command_loader.js';
+
+/**
+ * /commands 커맨드 - 커스텀 커맨드 목록 조회 및 정보 확인
+ *
+ * 사용법:
+ *   /commands           - 모든 커스텀 커맨드 목록 표시
+ *   /commands <name>    - 특정 커맨드 상세 정보 표시
+ */
+export default {
+    name: 'commands',
+    description: 'List custom commands or show command details',
+    usage: '/commands [command-name]',
+    handler: async (args, context) => {
+        if (!args || args.length === 0) {
+            // 커맨드 목록 표시
+            const commandList = await formatCustomCommandList();
+            uiEvents.addSystemMessage(commandList);
+            return;
+        }
+
+        // 특정 커맨드 정보 표시
+        const commandName = args[0];
+        const command = await findCustomCommandByName(commandName);
+
+        if (!command) {
+            uiEvents.addSystemMessage(`Custom command not found: ${commandName}\n\nUse /commands to see available commands.`);
+            return;
+        }
+
+        const info = [
+            `Command: ${command.name}`,
+            `Source: ${command.source}`,
+            `Path: ${command.path}`,
+            command.argumentHint ? `Argument Hint: ${command.argumentHint}` : null,
+            command.disableModelInvocation ? 'Model Invocation: Disabled (manual only)' : null,
+            '',
+            'Frontmatter:',
+            JSON.stringify(command.frontmatter, null, 2),
+            '',
+            'Content Preview:',
+            command.content.substring(0, 500) + (command.content.length > 500 ? '...' : '')
+        ].filter(Boolean).join('\n');
+
+        uiEvents.addSystemMessage(info);
+    }
+};

package/src/commands/debug.js

@@ -0,0 +1,52 @@
+import { uiEvents } from '../system/ui_events.js';
+import { loadSettings, saveSettings, SETTINGS_FILE } from '../util/config.js';
+
+/**
+ * /debug 커맨드 - API 요청/응답 내용 표시 설정
+ *
+ * 사용법:
+ *   /debug         - 현재 설정 상태 표시
+ *   /debug on      - API payload 표시 켜기
+ *   /debug off     - API payload 표시 끄기
+ */
+export default {
+    name: 'debug',
+    description: 'Toggle API request/response payload display',
+    usage: '/debug [on|off]',
+    handler: async (args, context) => {
+        const settings = await loadSettings();
+        const currentValue = settings?.SHOW_API_PAYLOAD === true;
+
+        if (!args || args.length === 0) {
+            // 현재 상태 표시
+            const status = currentValue ? 'ON (표시됨)' : 'OFF (숨김)';
+            const message = [
+                `API Payload Display: ${status}`,
+                '',
+                'Usage:',
+                '  /debug      - Show current status',
+                '  /debug on   - Enable API payload display',
+                '  /debug off  - Disable API payload display',
+                '',
+                `Settings file: ${SETTINGS_FILE}`
+            ].join('\n');
+
+            uiEvents.addSystemMessage(message);
+            return;
+        }
+
+        const action = args[0]?.toLowerCase();
+
+        if (action === 'on' || action === 'true' || action === '1') {
+            settings.SHOW_API_PAYLOAD = true;
+            await saveSettings(settings);
+            uiEvents.addSystemMessage('API Payload Display: ON\n이제 AI 요청/응답 내용이 화면에 표시됩니다.');
+        } else if (action === 'off' || action === 'false' || action === '0') {
+            settings.SHOW_API_PAYLOAD = false;
+            await saveSettings(settings);
+            uiEvents.addSystemMessage('API Payload Display: OFF\nAI 요청/응답 내용이 화면에 표시되지 않습니다.');
+        } else {
+            uiEvents.addSystemMessage(`Unknown option: ${action}\nUsage: /debug [on|off]`);
+        }
+    }
+};

package/src/commands/help.js

@@ -2,6 +2,8 @@ import React from 'react';
 import { uiEvents } from '../system/ui_events.js';
 import { renderInkComponent } from '../frontend/utils/renderInkComponent.js';
 import { HelpView } from '../frontend/components/HelpView.js';
+import { discoverAllCustomCommands } from '../system/custom_command_loader.js';
+import { discoverAllSkills } from '../system/skill_loader.js';
 
 /**
  * /help 커맨드 - 사용 가능한 커맨드 목록 표시
@@ -15,8 +17,16 @@ export default {
 
         const commands = commandRegistry.getCommands();
 
+        // 커스텀 커맨드 로드
+        const customCommands = await discoverAllCustomCommands();
+
+        // 스킬 로드
+        const skills = await discoverAllSkills();
+
         const component = React.createElement(HelpView, {
-            commands
+            commands,
+            customCommands,
+            skills
         });
 
         const output = await renderInkComponent(component);