moai-adk 0.3.13__py3-none-any.whl → 0.4.1__py3-none-any.whl

moai_adk/templates/.claude/hooks/alfred/core/checkpoint.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Event-Driven Checkpoint system
 
-위험한 작업 감지 및 자동 Checkpoint 생성
+Detect risky tasks and create automatic checkpoints
 @TAG:CHECKPOINT-EVENT-001
 """
 
@@ -12,7 +12,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-# MoAI-ADK 지원 언어별 스크립트 실행 패턴
+# Script execution pattern for each language supported by MoAI-ADK
 # Python, TypeScript, Java, Go, Rust, Dart, Swift, Kotlin + Shell
 SCRIPT_EXECUTION_PATTERN = re.compile(
     r"\b("
@@ -39,25 +39,25 @@ SCRIPT_EXECUTION_PATTERN = re.compile(
 
 
 def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str) -> tuple[bool, str]:
-    """위험한 작업 감지 (Event-Driven Checkpoint용)
+    """Risk task detection (for Event-Driven Checkpoint)
 
-    Claude Code tool 사용 전 위험한 작업을 자동으로 감지합니다.
-    위험 감지 시 자동으로 checkpoint를 생성하여 롤백 가능하게 합니다.
+    Claude Code tool automatically detects dangerous tasks before use.
+    When a risk is detected, a checkpoint is automatically created to enable rollback.
 
     Args:
-        tool_name: Claude Code tool 이름 (Bash, Edit, Write, MultiEdit)
-        tool_args: Tool 인자 딕셔너리
-        cwd: 프로젝트 루트 디렉토리 경로
+        tool_name: Name of the Claude Code tool (Bash, Edit, Write, MultiEdit)
+        tool_args: Tool argument dictionary
+        cwd: Project root directory path
 
     Returns:
-        (is_risky, operation_type) 튜플
-        - is_risky: 위험한 작업 여부 (bool)
-        - operation_type: 작업 유형 (str: delete, merge, script, critical-file, refactor)
+        (is_risky, operation_type) tuple
+        - is_risky: Whether the operation is dangerous (bool)
+        - operation_type: operation type (str: delete, merge, script, critical-file, refactor)
 
     Risky Operations:
         - Bash tool: rm -rf, git merge, git reset --hard, git rebase, script execution
         - Edit/Write tool: CLAUDE.md, config.json, .moai/memory/*.md
-        - MultiEdit tool: ≥10개 파일 동시 수정
+        - MultiEdit tool: Edit ≥10 items File simultaneously
         - Script execution: Python, Node, Java, Go, Rust, Dart, Swift, Kotlin, Shell scripts
 
     Examples:
@@ -69,29 +69,29 @@ def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str)
         (False, '')
 
     Notes:
-        - False Positive 최소화: 안전한 작업은 무시
-        - 성능: 가벼운 문자열 매칭 (< 1ms)
-        - 확장성: patterns 딕셔너리로 쉽게 추가 가능
+        - Minimize false positives: ignore safe operations
+        - Performance: lightweight string matching (< 1ms)
+        - Extensibility: Easily added to the patterns dictionary
 
     @TAG:CHECKPOINT-EVENT-001
     """
-    # Bash tool: 위험한 명령어 감지
+    # Bash tool: Detect dangerous commands
     if tool_name == "Bash":
         command = tool_args.get("command", "")
 
-        # 대규모 삭제
+        # Mass Delete
         if any(pattern in command for pattern in ["rm -rf", "git rm"]):
             return (True, "delete")
 
-        # Git 병합/리셋/리베이스
+        # Git merge/reset/rebase
         if any(pattern in command for pattern in ["git merge", "git reset --hard", "git rebase"]):
             return (True, "merge")
 
-        # 외부 스크립트 실행 (파괴적 가능성)
+        # Execute external script (potentially destructive)
         if any(command.startswith(prefix) for prefix in ["python ", "node ", "bash ", "sh "]):
             return (True, "script")
 
-    # Edit/Write tool: 중요 파일 감지
+    # Edit/Write tool: Detect important files
     if tool_name in ("Edit", "Write"):
         file_path = tool_args.get("file_path", "")
 
@@ -106,7 +106,7 @@ def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str)
         if any(cf in file_path for cf in critical_files):
             return (True, "critical-file")
 
-    # MultiEdit tool: 대규모 수정 감지
+    # MultiEdit tool: Detect large edits
     if tool_name == "MultiEdit":
         edits = tool_args.get("edits", [])
         if len(edits) >= 10:
@@ -116,32 +116,32 @@ def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str)
 
 
 def create_checkpoint(cwd: str, operation_type: str) -> str:
-    """Checkpoint 생성 (Git local branch)
+    """Create checkpoint (Git local branch)
 
-    위험한 작업 전 자동으로 checkpoint를 생성합니다.
-    Git local branch로 생성하여 원격 저장소 오염을 방지합니다.
+    Automatically creates checkpoints before dangerous operations.
+    Prevent remote repository contamination by creating a Git local branch.
 
     Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-        operation_type: 작업 유형 (delete, merge, script 등)
+        cwd: Project root directory path
+        operation_type: operation type (delete, merge, script, etc.)
 
     Returns:
-        checkpoint_branch: 생성된 브랜치명
-        실패 시 "checkpoint-failed" 반환
+        checkpoint_branch: Created branch name
+        Returns "checkpoint-failed" on failure
 
     Branch Naming:
         before-{operation}-{YYYYMMDD-HHMMSS}
-        예: before-delete-20251015-143000
+        Example: before-delete-20251015-143000
 
     Examples:
         >>> create_checkpoint(".", "delete")
         'before-delete-20251015-143000'
 
     Notes:
-        - Local branch만 생성 (원격 push 안 함)
-        - Git 오류 시 fallback (무시하고 계속 진행)
-        - Dirty working directory 체크 안 함 (커밋 안 된 변경사항 허용)
-        - Checkpoint 로그 자동 기록 (.moai/checkpoints.log)
+        - Create only local branch (no remote push)
+        - Fallback in case of Git error (ignore and continue)
+        - Do not check dirty working directory (allow uncommitted changes)
+        - Automatically record checkpoint logs (.moai/checkpoints.log)
 
     @TAG:CHECKPOINT-EVENT-001
     """
@@ -149,8 +149,8 @@ def create_checkpoint(cwd: str, operation_type: str) -> str:
     branch_name = f"before-{operation_type}-{timestamp}"
 
     try:
-        # 현재 브랜치에서 새 local branch 생성 (체크아웃 안 함)
-        result = subprocess.run(
+        # Create a new local branch from the current branch (without checking out)
+        subprocess.run(
             ["git", "branch", branch_name],
             cwd=cwd,
             check=True,
@@ -159,38 +159,38 @@ def create_checkpoint(cwd: str, operation_type: str) -> str:
             timeout=2,
         )
 
-        # Checkpoint 로그 기록
+        # Checkpoint log records
         log_checkpoint(cwd, branch_name, operation_type)
 
         return branch_name
 
     except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
-        # Git 오류 시 fallback (무시)
+        # Fallback (ignore) in case of Git error
         return "checkpoint-failed"
 
 
 def log_checkpoint(cwd: str, branch_name: str, operation_type: str) -> None:
-    """Checkpoint 로그 기록 (.moai/checkpoints.log)
+    """Checkpoint log records (.moai/checkpoints.log)
 
-    Checkpoint 생성 이력을 JSON Lines 형식으로 기록합니다.
-    SessionStart에서 이 로그를 읽어 checkpoint 목록을 표시합니다.
+    Checkpoint creation history is recorded in JSON Lines format.
+    SessionStart reads this log to display a list of checkpoints.
 
     Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-        branch_name: 생성된 checkpoint 브랜치명
-        operation_type: 작업 유형
+        cwd: Project root directory path
+        branch_name: Created checkpoint branch name
+        operation_type: operation type
 
     Log Format (JSON Lines):
         {"timestamp": "2025-10-15T14:30:00", "branch": "before-delete-...", "operation": "delete"}
 
     Examples:
         >>> log_checkpoint(".", "before-delete-20251015-143000", "delete")
-        # .moai/checkpoints.log에 1줄 추가
+        # Add 1 line to .moai/checkpoints.log
 
     Notes:
-        - 파일 없으면 자동 생성
-        - append 모드로 기록 (기존 로그 보존)
-        - 실패 시 무시 (critical하지 않음)
+        - If the file does not exist, it is automatically created.
+        - Record in append mode (preserve existing logs)
+        - Ignored in case of failure (not critical)
 
     @TAG:CHECKPOINT-EVENT-001
     """
@@ -209,22 +209,22 @@ def log_checkpoint(cwd: str, branch_name: str, operation_type: str) -> None:
             f.write(json.dumps(log_entry) + "\n")
 
     except (OSError, PermissionError):
-        # 로그 실패는 무시 (critical하지 않음)
+        # Ignore log failures (not critical)
         pass
 
 
 def list_checkpoints(cwd: str, max_count: int = 10) -> list[dict[str, str]]:
-    """Checkpoint 목록 조회 (.moai/checkpoints.log 파싱)
+    """Checkpoint list (parsing .moai/checkpoints.log)
 
-    최근 생성된 checkpoint 목록을 반환합니다.
-    SessionStart, /alfred:0-project restore 커맨드에서 사용합니다.
+    Returns a list of recently created checkpoints.
+    Used in the SessionStart, /alfred:0-project restore command.
 
     Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-        max_count: 반환할 최대 개수 (기본 10개)
+        cwd: Project root directory path
+        max_count: Maximum number to return (default 10 items)
 
     Returns:
-        Checkpoint 목록 (최신순)
+        Checkpoint list (most recent)
         [{"timestamp": "...", "branch": "...", "operation": "..."}, ...]
 
     Examples:
@@ -235,9 +235,9 @@ def list_checkpoints(cwd: str, max_count: int = 10) -> list[dict[str, str]]:
         ]
 
     Notes:
-        - 로그 파일 없으면 빈 리스트 반환
-        - JSON 파싱 실패한 줄은 무시
-        - 최신 max_count개만 반환
+        - If there is no log file, an empty list is returned.
+        - Ignore lines where JSON parsing fails
+        - Return only the latest max_count
 
     @TAG:CHECKPOINT-EVENT-001
     """
@@ -254,12 +254,12 @@ def list_checkpoints(cwd: str, max_count: int = 10) -> list[dict[str, str]]:
                 try:
                     checkpoints.append(json.loads(line.strip()))
                 except json.JSONDecodeError:
-                    # 파싱 실패한 줄 무시
+                    # Ignore lines where parsing failed
                     pass
     except (OSError, PermissionError):
         return []
 
-    # 최근 max_count개만 반환 (최신순)
+    # Return only the most recent max_count items (in order of latest)
     return checkpoints[-max_count:]
 
 

moai_adk/templates/.claude/hooks/alfred/core/context.py

@@ -8,26 +8,26 @@ from pathlib import Path
 
 
 def get_jit_context(prompt: str, cwd: str) -> list[str]:
-    """프롬프트 기반 JIT Context Retrieval
+    """JIT Context Retrieval based on prompt.
 
-    사용자 프롬프트를 분석하여 관련 문서를 자동으로 추천합니다.
-    Alfred 커맨드, 키워드 기반 패턴 매칭으로 필요한 문서만 로드합니다.
+    Analyze user prompts and automatically recommend relevant documents.
+    Alfred commands and keyword-based pattern matching load only the documents you need.
 
     Args:
-        prompt: 사용자 입력 프롬프트 (대소문자 무관)
-        cwd: 프로젝트 루트 디렉토리 경로
+        prompt: Prompt for user input (case is irrelevant)
+        cwd: Project root directory path
 
     Returns:
-        추천 문서 경로 리스트 (상대 경로).
-        매칭되는 패턴이 없거나 파일이 없으면 빈 리스트 []
+        List of recommended document paths (relative paths).
+        If there is no matching pattern or file, an empty list []
 
     Patterns:
-        - "/alfred:1-spec" → .moai/memory/spec-metadata.md
-        - "/alfred:2-build" → .moai/memory/development-guide.md
-        - "test" → tests/ (디렉토리가 존재하는 경우)
+        - "/alfred:1-plan" → .moai/memory/spec-metadata.md
+        - "/alfred:2-run" → .moai/memory/development-guide.md
+        - "test" → tests/ (if directory exists)
 
     Examples:
-        >>> get_jit_context("/alfred:1-spec", "/project")
+        >>> get_jit_context("/alfred:1-plan", "/project")
         ['.moai/memory/spec-metadata.md']
         >>> get_jit_context("implement test", "/project")
         ['tests/']
@@ -35,22 +35,22 @@ def get_jit_context(prompt: str, cwd: str) -> list[str]:
         []
 
     Notes:
-        - Context Engineering: JIT Retrieval 원칙 준수
-        - 필요한 문서만 로드하여 초기 컨텍스트 부담 최소화
-        - 파일 존재 여부 확인 후 반환
+        - Context Engineering: Compliance with JIT Retrieval principles
+        - Minimize initial context burden by loading only necessary documents
+        - Return after checking whether file exists
 
     TDD History:
-        - RED: 18개 시나리오 테스트 (커맨드 매칭, 키워드, 빈 결과)
-        - GREEN: 패턴 매칭 딕셔너리 기반 구현
-        - REFACTOR: 확장 가능한 패턴 구조, 파일 존재 검증 추가
+        - RED: 18 items scenario testing (command matching, keywords, empty results)
+        - GREEN: Pattern matching dictionary-based implementation
+        - REFACTOR: Expandable pattern structure, file existence validation added
     """
     context_files = []
     cwd_path = Path(cwd)
 
     # Pattern matching
     patterns = {
-        "/alfred:1-spec": [".moai/memory/spec-metadata.md"],
-        "/alfred:2-build": [".moai/memory/development-guide.md"],
+        "/alfred:1-plan": [".moai/memory/spec-metadata.md"],
+        "/alfred:2-run": [".moai/memory/development-guide.md"],
         "test": ["tests/"],
     }
 

moai_adk/templates/.claude/hooks/alfred/core/project.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Project metadata utilities
 
-프로젝트 정보 조회 (언어, Git, SPEC 진행도 등)
+Project information inquiry (language, Git, SPEC progress, etc.)
 """
 
 import json
@@ -11,18 +11,18 @@ from typing import Any
 
 
 def detect_language(cwd: str) -> str:
-    """프로젝트 언어 감지 (20개 언어 지원)
+    """Detect project language (supports 20 items languages)
 
-    파일 시스템을 탐색하여 프로젝트의 주 개발 언어를 감지합니다.
-    pyproject.toml, tsconfig.json 등의 설정 파일을 우선 검사하며,
-    TypeScript 우선 원칙을 적용합니다 (tsconfig.json 존재 시).
+    Browse the File system to detect your project's main development language.
+    First, check configuration files such as pyproject.toml and tsconfig.json.
+    Apply TypeScript first principles (if tsconfig.json exists).
 
     Args:
-        cwd: 프로젝트 루트 디렉토리 경로 (절대/상대 경로 모두 가능)
+        cwd: Project root directory path (both absolute and relative paths are possible)
 
     Returns:
-        감지된 언어명 (소문자). 감지 실패 시 "Unknown Language" 반환.
-        지원 언어: python, typescript, javascript, java, go, rust,
+        Detected language name (lowercase). If detection fails, "Unknown Language" is returned.
+        Supported languages: python, typescript, javascript, java, go, rust,
                   dart, swift, kotlin, php, ruby, elixir, scala,
                   clojure, cpp, c, csharp, haskell, shell, lua
 
@@ -35,9 +35,9 @@ def detect_language(cwd: str) -> str:
         'Unknown Language'
 
     TDD History:
-        - RED: 21개 언어 감지 테스트 작성 (20개 언어 + 1개 unknown)
-        - GREEN: 20개 언어 + unknown 구현, 모든 테스트 통과
-        - REFACTOR: 파일 검사 순서 최적화, TypeScript 우선 원칙 적용
+        - RED: Write a 21 items language detection test (20 items language + 1 items unknown)
+        - GREEN: 20 items language + unknown implementation, all tests passed
+        - REFACTOR: Optimize file inspection order, apply TypeScript priority principle
     """
     cwd_path = Path(cwd)
 
@@ -89,22 +89,22 @@ def detect_language(cwd: str) -> str:
 
 
 def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
-    """Git 명령어 실행 헬퍼 함수
+    """Git command execution helper function
 
-    Git 명령어를 안전하게 실행하고 출력을 반환합니다.
-    코드 중복을 제거하고 일관된 에러 처리를 제공합니다.
+    Safely execute Git commands and return output.
+    Eliminates code duplication and provides consistent error handling.
 
     Args:
-        args: Git 명령어 인자 리스트 (git은 자동 추가)
-        cwd: 실행 디렉토리 경로
-        timeout: 타임아웃 (초, 기본 2초)
+        args: Git command argument list (git adds automatically)
+        cwd: Execution directory path
+        timeout: Timeout (seconds, default 2 seconds)
 
     Returns:
-        Git 명령어 출력 (stdout, 앞뒤 공백 제거)
+        Git command output (stdout, removing leading and trailing spaces)
 
     Raises:
-        subprocess.TimeoutExpired: 타임아웃 초과
-        subprocess.CalledProcessError: Git 명령어 실패
+        subprocess.TimeoutExpired: Timeout exceeded
+        subprocess.CalledProcessError: Git command failed
 
     Examples:
         >>> _run_git_command(["branch", "--show-current"], ".")
@@ -122,22 +122,22 @@ def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
 
 
 def get_git_info(cwd: str) -> dict[str, Any]:
-    """Git 리포지토리 정보 수집
+    """Gather Git repository information
 
-    Git 리포지토리의 현재 상태를 조회합니다.
-    브랜치명, 커밋 해시, 변경사항 개수를 반환하며,
-    Git 리포지토리가 아닌 경우 빈 딕셔너리를 반환합니다.
+    View the current status of a Git repository.
+    Returns the branch name, commit hash, and number of changes.
+    If it is not a Git repository, it returns an empty dictionary.
 
     Args:
-        cwd: 프로젝트 루트 디렉토리 경로
+        cwd: Project root directory path
 
     Returns:
-        Git 정보 딕셔너리. 다음 키를 포함:
-        - branch: 현재 브랜치명 (str)
-        - commit: 현재 커밋 해시 (str, full hash)
-        - changes: 변경된 파일 개수 (int, staged + unstaged)
+        Git information dictionary. Includes the following keys:
+        - branch: Current branch name (str)
+        - commit: Current commit hash (str, full hash)
+        - changes: Number of changed files (int, staged + unstaged)
 
-        Git 리포지토리가 아니거나 조회 실패 시 빈 딕셔너리 {}
+        Empty dictionary {} if it is not a Git repository or the query fails.
 
     Examples:
         >>> get_git_info("/path/to/git/repo")
@@ -146,14 +146,14 @@ def get_git_info(cwd: str) -> dict[str, Any]:
         {}
 
     Notes:
-        - 타임아웃: 각 Git 명령어 2초
-        - 보안: subprocess.run(shell=False)로 안전한 실행
-        - 에러 처리: 모든 예외 시 빈 딕셔너리 반환
+        - Timeout: 2 seconds for each Git command
+        - Security: Safe execution with subprocess.run(shell=False)
+        - Error handling: Returns an empty dictionary in case of all exceptions
 
     TDD History:
-        - RED: 3개 시나리오 테스트 (Git 리포, 비 Git, 에러)
-        - GREEN: subprocess 기반 Git 명령어 실행 구현
-        - REFACTOR: 타임아웃 추가 (2초), 예외 처리 강화, 헬퍼 함수로 중복 제거
+        - RED: 3 items scenario test (Git repo, non-Git, error)
+        - GREEN: Implementation of subprocess-based Git command execution
+        - REFACTOR: Add timeout (2 seconds), strengthen exception handling, remove duplicates with helper function
     """
     try:
         # Check if it's a git repository
@@ -176,21 +176,21 @@ def get_git_info(cwd: str) -> dict[str, Any]:
 
 
 def count_specs(cwd: str) -> dict[str, int]:
-    """SPEC 파일 카운트 및 진행도 계산
+    """SPEC File count and progress calculation
 
-    .moai/specs/ 디렉토리를 탐색하여 SPEC 파일 개수와
-    완료 상태(status: completed)인 SPEC 개수를 집계합니다.
+    Browse the .moai/specs/ directory to find the number of SPEC Files and
+    Counts the number of SPECs with status: completed.
 
     Args:
-        cwd: 프로젝트 루트 디렉토리 경로
+        cwd: Project root directory path
 
     Returns:
-        SPEC 진행도 딕셔너리. 다음 키를 포함:
-        - completed: 완료된 SPEC 개수 (int)
-        - total: 전체 SPEC 개수 (int)
-        - percentage: 완료율 (int, 0~100)
+        SPEC progress dictionary. Includes the following keys:
+        - completed: Number of completed SPECs (int)
+        - total: total number of SPECs (int)
+        - percentage: completion percentage (int, 0~100)
 
-        .moai/specs/ 디렉토리가 없으면 모두 0
+        All 0 if .moai/specs/ directory does not exist
 
     Examples:
         >>> count_specs("/path/to/project")
@@ -199,14 +199,14 @@ def count_specs(cwd: str) -> dict[str, int]:
         {'completed': 0, 'total': 0, 'percentage': 0}
 
     Notes:
-        - SPEC 파일 위치: .moai/specs/SPEC-{ID}/spec.md
-        - 완료 조건: YAML front matter에 "status: completed" 포함
-        - 파싱 실패 시 해당 SPEC은 미완료로 간주
+        - SPEC File Location: .moai/specs/SPEC-{ID}/spec.md
+        - Completion condition: Include “status: completed” in YAML front matter
+        - If parsing fails, the SPEC is considered incomplete.
 
     TDD History:
-        - RED: 5개 시나리오 테스트 (0/0, 2/5, 5/5, 디렉토리 없음, 파싱 에러)
-        - GREEN: Path.iterdir()로 SPEC 탐색, YAML 파싱 구현
-        - REFACTOR: 예외 처리 강화, 퍼센트 계산 안전성 개선
+        - RED: 5 items scenario test (0/0, 2/5, 5/5, no directory, parsing error)
+        - GREEN: SPEC search with Path.iterdir(), YAML parsing implementation
+        - REFACTOR: Strengthened exception handling, improved percentage calculation safety
     """
     specs_dir = Path(cwd) / ".moai" / "specs"
 
@@ -236,7 +236,7 @@ def count_specs(cwd: str) -> dict[str, int]:
                     if "status: completed" in yaml_content:
                         completed += 1
         except (OSError, UnicodeDecodeError):
-            # 파일 읽기 실패 또는 인코딩 오류 - 미완료로 간주
+            # File read failure or encoding error - considered incomplete
             pass
 
     percentage = int(completed / total * 100) if total > 0 else 0

moai_adk/templates/.claude/hooks/alfred/handlers/__init__.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Event handlers for Alfred Hooks
 
-Claude Code 이벤트 핸들러들
+Claude Code Event Handlers
 """
 
 from .notification import handle_notification, handle_stop, handle_subagent_stop

moai_adk/templates/.claude/hooks/alfred/handlers/notification.py

@@ -1,24 +1,24 @@
 #!/usr/bin/env python3
 """Notification and control handlers
 
-Notification, Stop, SubagentStop 이벤트 처리
+Notification, Stop, SubagentStop event handling
 """
 
 from core import HookPayload, HookResult
 
 
 def handle_notification(payload: HookPayload) -> HookResult:
-    """Notification 이벤트 핸들러 (기본 구현)"""
+    """Notification event handler (default implementation)"""
     return HookResult()
 
 
 def handle_stop(payload: HookPayload) -> HookResult:
-    """Stop 이벤트 핸들러 (기본 구현)"""
+    """Stop event handler (default implementation)"""
     return HookResult()
 
 
 def handle_subagent_stop(payload: HookPayload) -> HookResult:
-    """SubagentStop 이벤트 핸들러 (기본 구현)"""
+    """SubagentStop event handler (default implementation)"""
     return HookResult()