vibego 0.2.52__py3-none-any.whl → 1.0.0__py3-none-any.whl

master.py

@@ -1,10 +1,10 @@
 """Master bot controller.
 
-统一管理多个项目 worker：
-- 读取 `config/master.db`（自动同步 `config/projects.json`）获取项目配置
-- 维护 `state/state.json`，记录运行状态 / 当前模型 / 自动记录的 chat_id
-- 暴露 /projects、/run、/stop、/switch、/authorize 等命令
-- 调用 `scripts/run_bot.sh` / `scripts/stop_bot.sh` 控制 worker 进程
+Responsibilities:
+- Read `config/master.db` (kept in sync with `config/projects.json`) to load project configuration.
+- Maintain `state/state.json`, recording runtime status, the active model, and automatically captured chat IDs.
+- Expose the /projects, /run, /stop, /switch, and /authorize administrator commands.
+- Invoke `scripts/run_bot.sh` / `scripts/stop_bot.sh` to manage worker processes.
 """
 from __future__ import annotations
 
@@ -22,7 +22,8 @@ import textwrap
 import re
 import threading
 import unicodedata
-from datetime import datetime, timezone
+import urllib.request
+from datetime import datetime, timezone, timedelta
 from zoneinfo import ZoneInfo
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -57,30 +58,72 @@ from project_repository import ProjectRepository, ProjectRecord
 from tasks.fsm import ProjectDeleteStates
 from vibego_cli import __version__
 
+try:
+    from packaging.version import Version, InvalidVersion
+except ImportError:  # pragma: no cover
+    Version = None  # type: ignore[assignment]
+
+    class InvalidVersion(Exception):
+        """Placeholder exception, compatible with version parsing errors when packaging is missing. """
+
 ROOT_DIR = Path(__file__).resolve().parent
-CONFIG_PATH = Path(os.environ.get("MASTER_PROJECTS_PATH", ROOT_DIR / "config/projects.json"))
-CONFIG_DB_PATH = Path(os.environ.get("MASTER_PROJECTS_DB_PATH", ROOT_DIR / "config/master.db"))
-STATE_PATH = Path(os.environ.get("MASTER_STATE_PATH", ROOT_DIR / "state/state.json"))
+def _default_config_root() -> Path:
+    """
+    Parse the configuration root directory, be compatible with multiple environment variables and fall back to the XDG specification.
+
+    Priority:
+    1. MASTER_CONFIG_ROOT(for master.py use)
+    2. VIBEGO_CONFIG_DIR(CLI Entrance settings)
+    3. $XDG_CONFIG_HOME/vibego or ~/.config/vibego
+    """
+    override = os.environ.get("MASTER_CONFIG_ROOT") or os.environ.get("VIBEGO_CONFIG_DIR")
+    if override:
+        return Path(override).expanduser()
+    xdg_base = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(xdg_base).expanduser() if xdg_base else Path.home() / ".config"
+    return base / "vibego"
+
+
+CONFIG_ROOT = _default_config_root()
+CONFIG_DIR = CONFIG_ROOT / "config"
+STATE_DIR = CONFIG_ROOT / "state"
+LOG_DIR = CONFIG_ROOT / "logs"
+
+CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+STATE_DIR.mkdir(parents=True, exist_ok=True)
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+CONFIG_PATH = Path(os.environ.get("MASTER_PROJECTS_PATH", CONFIG_DIR / "projects.json"))
+CONFIG_DB_PATH = Path(os.environ.get("MASTER_PROJECTS_DB_PATH", CONFIG_DIR / "master.db"))
+STATE_PATH = Path(os.environ.get("MASTER_STATE_PATH", STATE_DIR / "state.json"))
 RUN_SCRIPT = ROOT_DIR / "scripts/run_bot.sh"
 STOP_SCRIPT = ROOT_DIR / "scripts/stop_bot.sh"
 
+UPDATE_STATE_PATH = STATE_DIR / "update_state.json"
+UPDATE_CHECK_INTERVAL = timedelta(hours=24)
+_UPDATE_STATE_LOCK = threading.Lock()
+
 
 def _get_restart_signal_path() -> Path:
     """
-    获取重启信号文件路径，使用健壮的默认值逻辑。
+    Get the restart signal file path, using robust default value logic.
 
-    优先级：
-    1. 环境变量 MASTER_RESTART_SIGNAL_PATH
-    2. 配置目录 $MASTER_CONFIG_ROOT/state/restart_signal.json
-    3. 代码目录 ROOT_DIR/state/restart_signal.json（兜底）
+    Priority:
+    1. Environment variable MASTER_RESTART_SIGNAL_PATH
+    2. Configuration directory $MASTER_CONFIG_ROOT/state/restart_signal.json
+    3. Code directory ROOT_DIR/state/restart_signal.json(full details)
 
-    这样可以确保 pipx 安装的版本和源码运行的版本使用同一个信号文件。
+    This ensures that the version installed by pipx and the version run from the source code use the same signal file.
     """
     if env_path := os.environ.get("MASTER_RESTART_SIGNAL_PATH"):
         return Path(env_path)
 
-    # 默认使用配置目录而非代码目录，确保跨安装方式的一致性
-    config_root = Path(os.environ.get("MASTER_CONFIG_ROOT", Path.home() / ".config/vibego"))
+    # Use the configuration directory instead of the code directory by default to ensure consistency across installation methods
+    config_root_raw = (
+        os.environ.get("MASTER_CONFIG_ROOT")
+        or os.environ.get("VIBEGO_CONFIG_DIR")
+    )
+    config_root = Path(config_root_raw).expanduser() if config_root_raw else _default_config_root()
     return config_root / "state/restart_signal.json"
 
 
@@ -90,18 +133,18 @@ LEGACY_RESTART_SIGNAL_PATHS: Tuple[Path, ...] = tuple(
     for path in (ROOT_DIR / "state/restart_signal.json",)
     if path != RESTART_SIGNAL_PATH
 )
-RESTART_SIGNAL_TTL = int(os.environ.get("MASTER_RESTART_SIGNAL_TTL", "1800"))  # 默认 30 分钟
+RESTART_SIGNAL_TTL = int(os.environ.get("MASTER_RESTART_SIGNAL_TTL", "1800"))  # Default 30 minutes
 LOCAL_TZ = ZoneInfo(os.environ.get("MASTER_TIMEZONE", "Asia/Shanghai"))
 JUMP_BUTTON_TEXT_WIDTH = 40
 
-_DEFAULT_LOG_ROOT = ROOT_DIR / "logs"
+_DEFAULT_LOG_ROOT = LOG_DIR
 LOG_ROOT_PATH = Path(os.environ.get("LOG_ROOT", str(_DEFAULT_LOG_ROOT))).expanduser()
 
 WORKER_HEALTH_TIMEOUT = float(os.environ.get("WORKER_HEALTH_TIMEOUT", "20"))
 WORKER_HEALTH_INTERVAL = float(os.environ.get("WORKER_HEALTH_INTERVAL", "0.5"))
 WORKER_HEALTH_LOG_TAIL = int(os.environ.get("WORKER_HEALTH_LOG_TAIL", "80"))
 HANDSHAKE_MARKERS = (
-    "Telegram 连接正常",
+    "Telegram The connection is OK",
 )
 DELETE_CONFIRM_TIMEOUT = int(os.environ.get("MASTER_DELETE_CONFIRM_TIMEOUT", "120"))
 
@@ -109,24 +152,25 @@ _ENV_FILE_RAW = os.environ.get("MASTER_ENV_FILE")
 MASTER_ENV_FILE = Path(_ENV_FILE_RAW).expanduser() if _ENV_FILE_RAW else None
 _ENV_LOCK = threading.Lock()
 
-MASTER_MENU_BUTTON_TEXT = "📂 项目列表"
-# 旧版本键盘的文案，用于兼容仍显示英文的客户端消息
+MASTER_MENU_BUTTON_TEXT = "📂 Project list"
+# Copywriting for the old version of the keyboard, for compatibility with client messages that still display in English
 MASTER_MENU_BUTTON_LEGACY_TEXTS: Tuple[str, ...] = ("📂 Projects",)
-# 允许触发项目列表的全部文案，优先匹配最新文案
+# All copywriting in the project list is allowed to be triggered, and the latest copywriting will be matched first.
 MASTER_MENU_BUTTON_ALLOWED_TEXTS: Tuple[str, ...] = (
     MASTER_MENU_BUTTON_TEXT,
     *MASTER_MENU_BUTTON_LEGACY_TEXTS,
 )
-MASTER_MANAGE_BUTTON_TEXT = "⚙️ 项目管理"
+MASTER_MANAGE_BUTTON_TEXT = "⚙️ Project Management"
 MASTER_MANAGE_BUTTON_ALLOWED_TEXTS: Tuple[str, ...] = (MASTER_MANAGE_BUTTON_TEXT,)
 MASTER_BOT_COMMANDS: List[Tuple[str, str]] = [
-    ("start", "启动 master 菜单"),
-    ("projects", "查看项目列表"),
-    ("run", "启动 worker"),
-    ("stop", "停止 worker"),
-    ("switch", "切换 worker 模型"),
-    ("authorize", "登记 chat"),
-    ("restart", "重启 master"),
+    ("start", "Start master menu"),
+    ("projects", "View project list"),
+    ("run", "Start worker"),
+    ("stop", "Stop worker"),
+    ("switch", "Switch worker model"),
+    ("authorize", "Register chat"),
+    ("restart", "Restart master"),
+    ("upgrade", "Upgrade vibego to the latest version"),
 ]
 MASTER_BROADCAST_MESSAGE = os.environ.get("MASTER_BROADCAST_MESSAGE", "")
 SWITCHABLE_MODELS: Tuple[Tuple[str, str], ...] = (
@@ -134,12 +178,12 @@ SWITCHABLE_MODELS: Tuple[Tuple[str, str], ...] = (
     ("claudecode", "⚙️ ClaudeCode"),
 )
 
-# Telegram 在不同客户端可能插入零宽字符或额外空白，提前归一化按钮文本。
+# Telegram Different clients may insert zero-width characters or extra whitespace to normalize button text in advance.
 ZERO_WIDTH_CHARACTERS: Tuple[str, ...] = ("\u200b", "\u200c", "\u200d", "\ufeff")
 
 
 def _normalize_button_text(text: str) -> str:
-    """归一化项目按钮文本，剔除零宽字符并统一大小写。"""
+    """Normalize item button text, strip out zero-width characters and unify case. """
 
     filtered = "".join(ch for ch in text if ch not in ZERO_WIDTH_CHARACTERS)
     compacted = re.sub(r"\s+", " ", filtered).strip()
@@ -150,11 +194,11 @@ MASTER_MENU_BUTTON_CANONICAL_NORMALIZED = _normalize_button_text(MASTER_MENU_BUT
 MASTER_MENU_BUTTON_ALLOWED_NORMALIZED = {
     _normalize_button_text(value) for value in MASTER_MENU_BUTTON_ALLOWED_TEXTS
 }
-MASTER_MENU_BUTTON_KEYWORDS: Tuple[str, ...] = ("项目列表", "project", "projects")
+MASTER_MENU_BUTTON_KEYWORDS: Tuple[str, ...] = ("Project list", "project", "projects")
 
 
 def _is_projects_menu_trigger(text: Optional[str]) -> bool:
-    """判断消息文本是否可触发项目列表展示。"""
+    """Determine whether the message text can trigger the display of the project list. """
 
     if not text:
         return False
@@ -167,13 +211,13 @@ def _is_projects_menu_trigger(text: Optional[str]) -> bool:
 
 
 def _text_equals_master_button(text: str) -> bool:
-    """判断文本是否等同于当前主按钮文案（允许空白差异）。"""
+    """Determine whether the text is equal to the current main button copy (blank differences are allowed). """
 
     return _normalize_button_text(text) == MASTER_MENU_BUTTON_CANONICAL_NORMALIZED
 
 
 def _build_master_main_keyboard() -> ReplyKeyboardMarkup:
-    """构造 Master Bot 主键盘，提供项目列表与管理入口。"""
+    """Construct the Master Bot main keyboard, providing project list and management entrance. """
     return ReplyKeyboardMarkup(
         keyboard=[
             [
@@ -186,20 +230,20 @@ def _build_master_main_keyboard() -> ReplyKeyboardMarkup:
 
 
 async def _ensure_master_menu_button(bot: Bot) -> None:
-    """同步 master 端聊天菜单按钮文本，修复旧客户端的缓存问题。"""
+    """Synchronize the chat menu button text on the master side and fix the cache problem of the old client. """
     try:
         await bot.set_chat_menu_button(
             menu_button=MenuButtonCommands(text=MASTER_MENU_BUTTON_TEXT),
         )
     except TelegramBadRequest as exc:
-        log.warning("设置聊天菜单失败：%s", exc)
+        log.warning("Failed to set chat menu: %s", exc)
     else:
-        log.info("聊天菜单已同步", extra={"text": MASTER_MENU_BUTTON_TEXT})
+        log.info("Chat menu has been synchronized", extra={"text": MASTER_MENU_BUTTON_TEXT})
 
 
 async def _ensure_master_commands(bot: Bot) -> None:
-    """同步 master 侧命令列表，确保新增/删除命令立即生效。"""
-    commands = [BotCommand(command=cmd, description=desc) for cmd, desc in MASTER_BOT_COMMANDS]
+    """Synchronize the command list on the master side to ensure that new/deleted commands take effect immediately. """
+    commands= [BotCommand(command=cmd, description=desc) for cmd, desc in MASTER_BOT_COMMANDS]
     scopes: List[Tuple[Optional[object], str]] = [
         (None, "default"),
         (BotCommandScopeAllPrivateChats(), "all_private"),
@@ -213,13 +257,13 @@ async def _ensure_master_commands(bot: Bot) -> None:
             else:
                 await bot.set_my_commands(commands, scope=scope)
         except TelegramBadRequest as exc:
-            log.warning("设置 master 命令失败：%s", exc, extra={"scope": label})
+            log.warning("Set master command failed: %s", exc, extra={"scope": label})
         else:
-            log.info("master 命令已同步", extra={"scope": label})
+            log.info("master Command synchronized", extra={"scope": label})
 
 
 def _collect_master_broadcast_targets(manager: MasterManager) -> List[int]:
-    """汇总需要推送键盘的 chat_id，避免重复广播。"""
+    """Summarize the chat_id that needs to be pushed to the keyboard to avoid repeated broadcasts. """
     targets: set[int] = set(manager.admin_ids or [])
     manager.refresh_state()
     for state in manager.state_store.data.values():
@@ -229,14 +273,14 @@ def _collect_master_broadcast_targets(manager: MasterManager) -> List[int]:
 
 
 async def _broadcast_master_keyboard(bot: Bot, manager: MasterManager) -> None:
-    """在 master 启动阶段主动推送菜单键盘，覆盖 Telegram 端缓存。"""
+    """During the master startup phase, the menu keyboard is actively pushed to overwrite the Telegram side cache. """
     targets = _collect_master_broadcast_targets(manager)
-    # 当广播消息为空时表示不再向管理员推送启动提示，满足“禁止发送 /task_list”需求。
+    # When the broadcast message is empty, it means that the startup prompt will no longer be pushed to the administrator, meeting the requirement of "prohibit sending /task_list".
     if not MASTER_BROADCAST_MESSAGE:
-        log.info("启动广播已禁用，跳过 master 键盘推送。")
+        log.info("Startup broadcast disabled, skipping master keyboard push. ")
         return
     if not targets:
-        log.info("无可推送的 master 聊天对象")
+        log.info("No master chat objects to push")
         return
     markup = _build_master_main_keyboard()
     for chat_id in targets:
@@ -247,25 +291,25 @@ async def _broadcast_master_keyboard(bot: Bot, manager: MasterManager) -> None:
                 reply_markup=markup,
             )
         except TelegramForbiddenError as exc:
-            log.warning("推送菜单被禁止：%s", exc, extra={"chat": chat_id})
+            log.warning("Push menu disabled: %s", exc, extra={"chat": chat_id})
         except TelegramBadRequest as exc:
-            log.warning("推送菜单失败：%s", exc, extra={"chat": chat_id})
+            log.warning("Push menu failed: %s", exc, extra={"chat": chat_id})
         except Exception as exc:
-            log.error("推送菜单异常：%s", exc, extra={"chat": chat_id})
+            log.error("Push menu exception: %s", exc, extra={"chat": chat_id})
         else:
-            log.info("已推送菜单至 chat_id=%s", chat_id)
+            log.info("Menu pushed to chat_id=%s", chat_id)
 
 
 def _ensure_numbered_markup(markup: Optional[InlineKeyboardMarkup]) -> Optional[InlineKeyboardMarkup]:
-    """对 InlineKeyboard 保持原始文案，不再自动追加编号。"""
+    """Keep the original copy for InlineKeyboard and no longer automatically append numbers. """
     return markup
 
 
 def _get_project_runtime_state(manager: "MasterManager", slug: str) -> Optional["ProjectState"]:
-    """归一化查询项目运行状态，避免误用 FSMContext。
+    """Normalize query project running status to avoid misuse of FSMContext.
 
-    这里集中处理 slug 大小写并注释说明原因，防止在路由中覆盖 aiogram
-    提供的 `FSMContext`（详见官方文档：https://docs.aiogram.dev/en/dev-3.x/dispatcher/fsm/context.html）。
+    Here we focus on handling the case of slug and commenting on the reasons to prevent overwriting aiogram in routing.
+    provided `FSMContext`(For details, please see the official documentation: https://docs.aiogram.dev/en/dev-3.x/dispatcher/fsm/context.html).
     """
 
     normalized = (slug or "").strip().lower()
@@ -281,7 +325,7 @@ def _get_project_runtime_state(manager: "MasterManager", slug: str) -> Optional[
 
 
 def _terminate_other_master_processes(grace: float = 3.0) -> None:
-    """在新 master 启动后终止其他残留 master 进程"""
+    """Terminate other remaining master processes after the new master starts"""
     existing: list[int] = []
     try:
         result = subprocess.run(
@@ -307,7 +351,7 @@ def _terminate_other_master_processes(grace: float = 3.0) -> None:
         except ProcessLookupError:
             continue
         except PermissionError as exc:
-            log.warning("终止残留 master 进程失败: %s", exc, extra={"pid": pid})
+            log.warning("Failed to terminate residual master process: %s", exc, extra={"pid": pid})
     if not existing:
         return
     deadline = time.monotonic() + grace
@@ -325,14 +369,14 @@ def _terminate_other_master_processes(grace: float = 3.0) -> None:
         except ProcessLookupError:
             continue
         except PermissionError as exc:
-            log.warning("强制终止 master 进程失败: %s", exc, extra={"pid": pid})
+            log.warning("Forced termination of master process failed: %s", exc, extra={"pid": pid})
     if existing:
-        log.info("清理其他 master 进程完成", extra={"terminated": existing, "force": list(alive)})
+        log.info("Cleaning up other master processes completed", extra={"terminated": existing, "force": list(alive)})
 
 
 
 def load_env(file: str = ".env") -> None:
-    """加载默认 .env 以及 MASTER_ENV_FILE 指向的配置。"""
+    """load default .env and the configuration pointed to by MASTER_ENV_FILE. """
 
     candidates: List[Path] = []
     if MASTER_ENV_FILE:
@@ -351,7 +395,7 @@ def load_env(file: str = ".env") -> None:
 
 
 def _collect_admin_targets() -> List[int]:
-    """汇总所有潜在管理员 chat_id，避免广播遗漏。"""
+    """Aggregate all potential admin chat_ids to avoid missing broadcasts. """
 
     if MANAGER is not None and getattr(MANAGER, "admin_ids", None):
         return sorted(MANAGER.admin_ids)
@@ -370,7 +414,7 @@ def _collect_admin_targets() -> List[int]:
 
 
 def _kill_existing_tmux(prefix: str) -> None:
-    """终止所有匹配前缀的 tmux 会话，避免多实例冲突。"""
+    """Terminate all tmux sessions matching the prefix to avoid multi-instance conflicts. """
 
     if shutil.which("tmux") is None:
         return
@@ -395,7 +439,7 @@ def _kill_existing_tmux(prefix: str) -> None:
 
 
 def _mask_proxy(url: str) -> str:
-    """隐藏代理 URL 中的凭据，仅保留主机与端口。"""
+    """Hide credentials in the proxy URL, leaving only the host and port. """
 
     if "@" not in url:
         return url
@@ -407,9 +451,9 @@ def _mask_proxy(url: str) -> str:
 
 
 def _parse_env_file(path: Path) -> Dict[str, str]:
-    """读取 .env 文件并返回键值映射。"""
+    """read .env file and returns a key-value map. """
 
-    result: Dict[str, str] = {}
+    result:Dict[str, str] = {}
     if not path.exists():
         return result
     try:
@@ -420,12 +464,12 @@ def _parse_env_file(path: Path) -> Dict[str, str]:
             key, value = line.split("=", 1)
             result[key.strip()] = value.strip()
     except Exception as exc:  # pylint: disable=broad-except
-        log.warning("解析 MASTER_ENV_FILE 失败: %s", exc, extra={"path": str(path)})
+        log.warning("Failed to parse MASTER_ENV_FILE: %s", exc, extra={"path": str(path)})
     return result
 
 
 def _dump_env_file(path: Path, values: Dict[str, str]) -> None:
-    """写入 .env，默认采用 600 权限。"""
+    """write .env,The default is 600 permissions. """
 
     try:
         path.parent.mkdir(parents=True, exist_ok=True)
@@ -436,11 +480,11 @@ def _dump_env_file(path: Path, values: Dict[str, str]) -> None:
         except PermissionError:
             pass
     except Exception as exc:  # pylint: disable=broad-except
-        log.warning("写入 MASTER_ENV_FILE 失败: %s", exc, extra={"path": str(path)})
+        log.warning("Failed to write to MASTER_ENV_FILE: %s", exc, extra={"path": str(path)})
 
 
 def _update_master_env(chat_id: Optional[int], user_id: Optional[int]) -> None:
-    """将最近一次 master 交互信息写入 .env。"""
+    """Write the latest master interaction information .env."""
 
     if not MASTER_ENV_FILE:
         return
@@ -464,7 +508,7 @@ def _update_master_env(chat_id: Optional[int], user_id: Optional[int]) -> None:
 
 
 def _format_project_line(cfg: "ProjectConfig", state: Optional[ProjectState]) -> str:
-    """格式化项目状态信息，用于日志与通知。"""
+    """Format project status information for logging and notifications. """
 
     status = state.status if state else "stopped"
     model = state.model if state else cfg.default_model
@@ -475,7 +519,7 @@ def _format_project_line(cfg: "ProjectConfig", state: Optional[ProjectState]) ->
 
 
 def _projects_overview(manager: MasterManager) -> Tuple[str, Optional[InlineKeyboardMarkup]]:
-    """根据当前项目状态生成概览文本与操作按钮。"""
+    """Generate overview text and action buttons based on the current project status. """
 
     builder = InlineKeyboardBuilder()
     button_count = 0
@@ -492,7 +536,7 @@ def _projects_overview(manager: MasterManager) -> Tuple[str, Optional[InlineKeyb
                     url=cfg.jump_url,
                 ),
                 InlineKeyboardButton(
-                    text=f"⛔️ 停止 ({current_model_label})",
+                    text=f"⛔️ Stop ({current_model_label})",
                     callback_data=f"project:stop:{cfg.project_slug}",
                 ),
             )
@@ -503,30 +547,248 @@ def _projects_overview(manager: MasterManager) -> Tuple[str, Optional[InlineKeyb
                     url=cfg.jump_url,
                 ),
                 InlineKeyboardButton(
-                    text=f"▶️ 启动 ({current_model_label})",
+                    text=f"▶️ Start ({current_model_label})",
                     callback_data=f"project:run:{cfg.project_slug}",
                 ),
             )
         button_count += 1
     builder.row(
-        InlineKeyboardButton(text="🚀 启动全部项目", callback_data="project:start_all:*")
+        InlineKeyboardButton(text="🚀 Start all projects", callback_data="project:start_all:*")
     )
     builder.row(
-        InlineKeyboardButton(text="⛔️ 停止全部项目", callback_data="project:stop_all:*")
+        InlineKeyboardButton(text="⛔️ Stop all projects", callback_data="project:stop_all:*")
     )
     builder.row(
-        InlineKeyboardButton(text="🔄 重启 Master", callback_data="project:restart_master:*")
+        InlineKeyboardButton(text="🔄 Restart Master", callback_data="project:restart_master:*")
     )
     markup = builder.as_markup()
     markup = _ensure_numbered_markup(markup)
-    log.info("项目概览生成按钮数量=%s", button_count)
+    log.info("Project overview generated button count=%s", button_count)
     if button_count == 0:
-        return "暂无项目配置，请在“⚙️ 项目管理”创建新项目后再尝试。", markup
-    return "请选择操作：", markup
+        return (
+            'No project configuration found. Open "⚙️ Project Management" to create a new project and try again.',
+            markup,
+        )
+    return "Please select an action:", markup
+
+
+def _utcnow() -> datetime:
+    """Returns the current time in UTC for easy serialization. """
+
+    return datetime.now(timezone.utc)
+
+
+def _parse_iso_datetime(value: Optional[str]) -> Optional[datetime]:
+    """Parse ISO8601 string into UTC time, return None in case of exception. """
+
+    if not value:
+        return None
+    try:
+        parsed=datetime.fromisoformat(value)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _load_update_state() -> Dict[str, Any]:
+    """Read update detection status, returning an empty dictionary on failure. """
+
+    with _UPDATE_STATE_LOCK:
+        if not UPDATE_STATE_PATH.exists():
+            return {}
+        try:
+            raw = UPDATE_STATE_PATH.read_text(encoding="utf-8")
+            state = json.loads(raw) if raw.strip() else {}
+            if not isinstance(state, dict):
+                state = {}
+            return state
+        except Exception as exc:  # pragma: no cover - It will only be triggered under extreme circumstances
+            log.warning("Failed to read update status: %s", exc)
+            return {}
+
+
+def _save_update_state(state: Dict[str, Any]) -> None:
+    """Persistent update state to ensure atomic writes. """
+
+    with _UPDATE_STATE_LOCK:
+        tmp_path = UPDATE_STATE_PATH.with_suffix(".tmp")
+        tmp_path.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp_path.replace(UPDATE_STATE_PATH)
+
+
+def _ensure_notified_list(state: Dict[str, Any]) -> List[int]:
+    """The notification list is guaranteed to exist in the state and a mutable reference is returned. """
+
+    notified = state.get("notified_chat_ids")
+    if isinstance(notified, list):
+        filtered = []
+        for item in notified:
+            try:
+                filtered.append(int(item))
+            except (TypeError, ValueError):
+                continue
+        state["notified_chat_ids"] = filtered
+        return filtered
+    state["notified_chat_ids"] = []
+    return state["notified_chat_ids"]
+
+
+async def _fetch_latest_version() -> Optional[str]:
+    """Query the latest version of vibego from PyPI, and return None when the network is abnormal. """
+
+    url=os.environ.get("VIBEGO_PYPI_JSON", "https://pypi.org/pypi/vibego/json")
+
+    def _request() -> Optional[str]:
+        try:
+            with urllib.request.urlopen(url, timeout=10) as resp:
+                payload = json.load(resp)
+        except Exception as exc:  # pragma: no cover - Triggered when network abnormality occurs
+            log.warning("Failed to get latest version of vibego: %s", exc)
+            return None
+        info = payload.get("info") if isinstance(payload, dict) else None
+        version = info.get("version") if isinstance(info, dict) else None
+        if isinstance(version, str) and version.strip():
+            return version.strip()
+        return None
+
+    return await asyncio.to_thread(_request)
+
+
+def _is_newer_version(latest: str, current: str) -> bool:
+    """Compare version numbers and use packaging parsing first. """
+
+    if not latest or latest == current:
+        return False
+    if Version is not None:
+        try:
+            return Version(latest) > Version(current)
+        except InvalidVersion:
+            pass
+    # Fallback strategy: segment comparison by semantic version
+    def _split(value: str) -> Tuple[int, ...]:
+        parts: List[int] = []
+        for chunk in value.replace("-", ".").split("."):
+            if not chunk:
+                continue
+            if chunk.isdigit():
+                parts.append(int(chunk))
+            else:
+                return tuple(parts)
+        return tuple(parts)
+
+    return _split(latest) > _split(current)
+
+
+async def _ensure_update_state(force: bool = False) -> Dict[str, Any]:
+    """Refresh the update status on demand, and trigger a network request every 24 hours by default. """
+
+    state = _load_update_state()
+    now = _utcnow()
+    last_check = _parse_iso_datetime(state.get("last_check"))
+    need_check = force or last_check is None or (now - last_check) >= UPDATE_CHECK_INTERVAL
+    if not need_check:
+        return state
+
+    latest = await _fetch_latest_version()
+    state["last_check"] = now.isoformat()
+    if latest:
+        previous = state.get("latest_version")
+        state["latest_version"] = latest
+        if previous != latest:
+            # Reset the notification record when a new version appears to avoid missing reminders
+            state["last_notified_version"] = ""
+            state["notified_chat_ids"] = []
+            state["last_notified_at"] = None
+    _save_update_state(state)
+    return state
+
+
+async def _maybe_notify_update(
+    bot: Bot,
+    chat_id: int,
+    *,
+    force_check: bool = False,
+    state: Optional[Dict[str, Any]] = None,
+) -> bool:
+    """Send a reminder if a new version is detected and the current chat has not been notified. """
+
+    current_state = state if state is not None else await _ensure_update_state(force=force_check)
+    latest = current_state.get("latest_version")
+    if not isinstance(latest, str) or not latest.strip():
+        return False
+    latest = latest.strip()
+    if not _is_newer_version(latest, __version__):
+        return False
+
+    notified_ids = _ensure_notified_list(current_state)
+    if chat_id in notified_ids:
+        return False
+
+    message = (
+        f"The latest vibego version v{latest} has been detected and the current running version is v{__version__}. \n"
+        "Send /upgrade to automatically perform the upgrade and restart the service. "
+    )
+    try:
+        await bot.send_message(chat_id=chat_id, text=message)
+    except Exception as exc:
+        log.warning("Failed to send upgrade reminder (chat=%s): %s", chat_id, exc)
+        return False
+
+    notified_ids.append(chat_id)
+    current_state["last_notified_version"] = latest
+    current_state["last_notified_at"] = _utcnow().isoformat()
+    _save_update_state(current_state)
+    return True
+
+
+async def _notify_update_to_targets(bot: Bot, targets: Sequence[int], *, force_check: bool = False) -> None:
+    """Push available updates to administrators in bulk. """
+
+    if not targets:
+        return
+    state = await _ensure_update_state(force=force_check)
+    sent = 0
+    for chat_id in targets:
+        if await _maybe_notify_update(bot, chat_id, state=state):
+            sent += 1
+    if sent:
+        log.info("Upgrade reminder has been pushed to %s administrators", sent)
+
+
+def _trigger_upgrade_pipeline() -> Tuple[bool, Optional[str]]:
+    """Trigger the pipx upgrade process and run it in the background. """
+
+    command = "pipx upgrade vibego && vibego stop && vibego start"
+    try:
+        subprocess.Popen(
+            ["/bin/bash", "-lc", command],
+            cwd=str(ROOT_DIR),
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        log.info("Upgrade command triggered: %s", command)
+        return True, None
+    except Exception as exc:
+        log.error("Failed to trigger upgrade command: %s", exc)
+        return False, str(exc)
+
+
+async def _periodic_update_check(bot: Bot) -> None:
+    """The background periodically checks for version updates and notifies the administrator. """
+
+    await asyncio.sleep(10)
+    while True:
+        try:
+            await _notify_update_to_targets(bot, _collect_admin_targets(), force_check=True)
+        except Exception as exc:  # pragma: no cover - Use for downtime debugging
+            log.error("Automatic version detection failed: %s", exc)
+        await asyncio.sleep(int(UPDATE_CHECK_INTERVAL.total_seconds()))
 
 
 def _detect_proxy() -> Tuple[Optional[str], Optional[BasicAuth], Optional[str]]:
-    """从环境变量解析可用的代理配置。"""
+    """Resolve available proxy configurations from environment variables. """
 
     candidates = [
         ("TELEGRAM_PROXY", os.environ.get("TELEGRAM_PROXY")),
@@ -556,14 +818,14 @@ def _detect_proxy() -> Tuple[Optional[str], Optional[BasicAuth], Optional[str]]:
         if parsed.port:
             netloc += f":{parsed.port}"
         proxy_raw = parsed._replace(netloc=netloc, path="", params="", query="", fragment="").geturl()
-    log.info("使用代理(%s): %s", source, _mask_proxy(proxy_raw))
+    log.info("Use proxy(%s): %s", source, _mask_proxy(proxy_raw))
     return proxy_raw, auth, source
 
 
 def _sanitize_slug(text: str) -> str:
-    """将任意字符串转换为 project_slug 可用的短标签。"""
+    """Convert an arbitrary string into a short tag usable by project_slug. """
 
-    slug = text.lower().replace(" ", "-")
+    slug=text.lower().replace(" ", "-")
     slug = slug.replace("/", "-").replace("\\", "-")
     slug = slug.strip("-")
     return slug or "project"
@@ -571,7 +833,7 @@ def _sanitize_slug(text: str) -> str:
 
 @dataclass
 class ProjectConfig:
-    """描述单个项目的静态配置。"""
+    """Describes the static configuration of a single project. """
 
     bot_name: str
     bot_token: str
@@ -582,31 +844,31 @@ class ProjectConfig:
     legacy_name: Optional[str] = None
 
     def __post_init__(self) -> None:
-        """保证 bot 名称合法，去除多余前缀与空白。"""
+        """Make sure the bot name is legal and remove redundant prefixes and spaces. """
 
         clean_name = self.bot_name.strip()
-        if clean_name.startswith("@"):  # 允许配置中直接写带@
+        if clean_name.startswith("@"):  # Allow direct writing with @ in the configuration
             clean_name = clean_name[1:]
         clean_name = clean_name.strip()
         if not clean_name:
-            raise ValueError("bot_name 不能为空")
+            raise ValueError("bot_name cannot be empty")
         self.bot_name = clean_name
 
     @property
     def display_name(self) -> str:
-        """返回展示用的 bot 名称。"""
+        """Returns the bot name used for display. """
 
         return self.bot_name
 
     @property
     def jump_url(self) -> str:
-        """生成跳转到 Telegram Bot 的链接。"""
+        """Generate a link to Telegram Bot. """
 
         return f"https://t.me/{self.bot_name}"
 
     @classmethod
     def from_dict(cls, data: dict) -> "ProjectConfig":
-        """从 JSON 字典构造 ProjectConfig 实例。"""
+        """Constructs a ProjectConfig instance from a JSON dictionary. """
 
         raw_bot_name = data.get("bot_name") or data.get("name")
         if not raw_bot_name:
@@ -630,21 +892,21 @@ class ProjectConfig:
 
 @dataclass
 class ProjectState:
-    """表示项目当前运行状态，由 StateStore 持久化。"""
+    """Represents the current running status of the project, which is persisted by StateStore. """
 
-    model: str
+    model:str
     status: str = "stopped"
     chat_id: Optional[int] = None
 
 
 class StateStore:
-    """负责维护项目运行状态的文件持久化。"""
+    """Responsible for maintaining file persistence of project running status. """
 
     def __init__(self, path: Path, configs: Dict[str, ProjectConfig]):
-        """初始化状态存储，加载已有 state 文件并对缺失项使用默认值。"""
+        """Initialize the state store, loading existing state files and using default values ​​for missing items. """
 
         self.path = path
-        self.configs = configs  # key 使用 project_slug
+        self.configs = configs  # key Use project_slug
         self.data: Dict[str, ProjectState] = {}
         self.refresh()
         self.save()
@@ -654,13 +916,13 @@ class StateStore:
         configs: Dict[str, ProjectConfig],
         preserve: Optional[Dict[str, ProjectState]] = None,
     ) -> None:
-        """更新配置映射，新增项目时写入默认状态，删除项目时移除记录。"""
+        """Update the configuration mapping, write the default state when adding a new item, and remove the record when deleting an item. """
         self.configs = configs
-        # 移除已删除项目的状态
+        # Remove deleted item status
         for slug in list(self.data.keys()):
             if slug not in configs:
                 del self.data[slug]
-        # 为新增项目补充默认状态
+        # Supplement the default status for new projects
         for slug, cfg in configs.items():
             if slug not in self.data:
                 self.data[slug] = ProjectState(
@@ -673,13 +935,13 @@ class StateStore:
         self.save()
 
     def refresh(self) -> None:
-        """从 state 文件重新加载所有项目状态。"""
+        """Reload all project states from state files. """
 
         if self.path.exists():
             try:
                 raw = json.loads(self.path.read_text(encoding="utf-8"))
             except json.JSONDecodeError:
-                log.warning("无法解析 state 文件 %s，使用空状态", self.path)
+                log.warning("Unable to parse state file %s, using empty state", self.path)
                 raw = {}
         else:
             raw = {}
@@ -699,7 +961,7 @@ class StateStore:
             self.data[slug] = ProjectState(model=model, status=status, chat_id=chat_id_value)
 
     def save(self) -> None:
-        """将当前内存状态写入磁盘文件。"""
+        """Write the current memory state to a disk file. """
 
         self.path.parent.mkdir(parents=True, exist_ok=True)
         payload = {
@@ -720,7 +982,7 @@ class StateStore:
         status: Optional[str] = None,
         chat_id: Optional[int] = None,
     ) -> None:
-        """更新指定项目的状态并立即持久化。"""
+        """Updates the state of the specified project and makes it persist immediately. """
 
         state = self.data[slug]
         if model is not None:
@@ -733,10 +995,10 @@ class StateStore:
 
 
 class MasterManager:
-    """封装项目配置、状态持久化与前置检查等核心逻辑。"""
+    """Encapsulates core logic such as project configuration, state persistence, and pre-checking. """
 
     def __init__(self, configs: List[ProjectConfig], *, state_store: StateStore):
-        """构建 manager，并基于配置建立 slug/mention 索引。"""
+        """Build the manager and build the slug/mention index based on the configuration. """
 
         self.configs = configs
         self._slug_index: Dict[str, ProjectConfig] = {cfg.project_slug: cfg for cfg in configs}
@@ -751,23 +1013,23 @@ class MasterManager:
         self.admin_ids = {int(x) for x in admins.split(",") if x.strip().isdigit()}
 
     def require_project(self, name: str) -> ProjectConfig:
-        """根据项目名或 @bot 名查找配置，找不到时报错。"""
+        """Search the configuration based on the project name or @bot name, and an error will be reported if it cannot be found. """
 
         cfg = self._resolve_project(name)
         if not cfg:
-            raise ValueError(f"未知项目 {name}")
+            raise ValueError(f"Unknown item {name}")
         return cfg
 
     def require_project_by_slug(self, slug: str) -> ProjectConfig:
-        """根据 project_slug 查找配置。"""
+        """Find configuration based on project_slug. """
 
         cfg = self._slug_index.get(slug)
         if not cfg:
-            raise ValueError(f"未知项目 {slug}")
+            raise ValueError(f"Unknown item {slug}")
         return cfg
 
     def _resolve_project(self, identifier: str) -> Optional[ProjectConfig]:
-        """在 slug/mention 索引中寻找匹配的项目配置。"""
+        """Look for matching project configurations in the slug/mention index. """
 
         if not identifier:
             return None
@@ -778,7 +1040,7 @@ class MasterManager:
             return self._slug_index[raw]
         if raw in self._mention_index:
             return self._mention_index[raw]
-        if raw.startswith("@"):  # 允许用户直接输入 @bot_name
+        if raw.startswith("@"):  # Allow users to enter @bot_name directly
             stripped = raw[1:]
             if stripped in self._mention_index:
                 return self._mention_index[stripped]
@@ -793,7 +1055,7 @@ class MasterManager:
         configs: List[ProjectConfig],
         preserve: Optional[Dict[str, ProjectState]] = None,
     ) -> None:
-        """刷新项目配置索引，便于在新增/删除后立即生效。"""
+        """Refresh the project configuration index so that it takes effect immediately after addition/deletion. """
         self.configs = configs
         self._slug_index = {cfg.project_slug: cfg for cfg in configs}
         self._mention_index = {}
@@ -805,23 +1067,23 @@ class MasterManager:
         self.state_store.reset_configs({cfg.project_slug: cfg for cfg in configs}, preserve=preserve)
 
     def refresh_state(self) -> None:
-        """从磁盘重新加载项目运行状态。"""
+        """Reload project running status from disk. """
 
         self.state_store.refresh()
 
     def list_states(self) -> Dict[str, ProjectState]:
-        """返回当前所有项目的状态字典。"""
+        """Returns a dictionary of statuses for all current projects. """
 
         return self.state_store.data
 
     def is_authorized(self, chat_id: int) -> bool:
-        """检查给定 chat_id 是否在管理员名单中。"""
+        """Checks whether the given chat_id is in the list of administrators. """
 
         return not self.admin_ids or chat_id in self.admin_ids
 
     @staticmethod
     def _format_issue_message(title: str, issues: Sequence[str]) -> str:
-        """按照项目自检的结果拼装 Markdown 文本。"""
+        """Assemble Markdown text according to the results of the project self-test. """
 
         lines: List[str] = []
         for issue in issues:
@@ -831,35 +1093,35 @@ class MasterManager:
                 lines.extend(f"  {line}" for line in rest)
             else:
                 lines.append(f"- {issue}")
-        joined = "\n".join(lines) if lines else "- 无"
+        joined = "\n".join(lines) if lines else "- None"
         return f"{title}\n{joined}"
 
     def _collect_prerequisite_issues(self, cfg: ProjectConfig, model: str) -> List[str]:
-        """检查模型启动前的依赖条件，返回所有未满足的项。"""
+        """Check the dependency conditions before starting the model and return all unsatisfied items. """
 
         issues: List[str] = []
         workdir_raw = (cfg.workdir or "").strip()
         if not workdir_raw:
             issues.append(
-                "未配置 workdir，请通过项目管理功能为该项目设置工作目录"
+                "The workdir is not configured, please set the working directory for the project through the project management function"
             )
             expanded_dir = None
         else:
             expanded = Path(os.path.expandvars(os.path.expanduser(workdir_raw)))
             if not expanded.exists():
-                issues.append(f"工作目录不存在: {workdir_raw}")
+                issues.append(f"Working directory does not exist: {workdir_raw}")
                 expanded_dir = None
             elif not expanded.is_dir():
-                issues.append(f"工作目录不是文件夹: {workdir_raw}")
+                issues.append(f"Working directory is not a folder: {workdir_raw}")
                 expanded_dir = None
             else:
                 expanded_dir = expanded
 
         if not cfg.bot_token:
-            issues.append("bot_token 未配置，请通过项目管理功能补充该字段")
+            issues.append("bot_token Not configured, please supplement this field through the project management function")
 
         if shutil.which("tmux") is None:
-            issues.append("未检测到 tmux，可通过 'brew install tmux' 安装")
+            issues.append("tmux not detected, installable via 'brew install tmux'")
 
         model_lower = (model or "").lower()
         model_cmd = os.environ.get("MODEL_CMD")
@@ -877,13 +1139,13 @@ class MasterManager:
             except ValueError:
                 executable = None
             if executable and shutil.which(executable) is None:
-                issues.append(f"未检测到模型命令 {executable}，请确认已安装")
+                issues.append(f"Model command {executable} not detected, please confirm it is installed")
         elif model_lower != "gemini":
-            issues.append("未找到模型命令配置，无法启动 worker")
+            issues.append("Model command configuration not found, unable to start worker")
 
         if expanded_dir is None and workdir_raw:
             log.debug(
-                "工作目录校验失败",
+                "Working directory verification failed",
                 extra={"project": cfg.project_slug, "workdir": workdir_raw},
             )
 
@@ -891,7 +1153,7 @@ class MasterManager:
 
     @staticmethod
     def _pid_alive(pid: int) -> bool:
-        """检测指定 PID 的进程是否仍在运行。"""
+        """Detects whether the process with the specified PID is still running. """
 
         try:
             os.kill(pid, 0)
@@ -903,7 +1165,7 @@ class MasterManager:
             return True
 
     def _log_tail(self, path: Path, *, lines: int = WORKER_HEALTH_LOG_TAIL) -> str:
-        """读取日志文件尾部，协助诊断启动失败原因。"""
+        """Read the tail of the log file to help diagnose the cause of startup failure. """
 
         if not path.exists():
             return ""
@@ -912,7 +1174,7 @@ class MasterManager:
                 data = fh.readlines()
         except Exception as exc:
             log.warning(
-                "读取日志失败: %s",
+                "Failed to read log: %s",
                 exc,
                 extra={"log_path": str(path)},
             )
@@ -923,7 +1185,7 @@ class MasterManager:
         return "".join(tail).rstrip()
 
     def _log_contains_handshake(self, path: Path) -> bool:
-        """判断日志中是否包含 Telegram 握手成功的标记。"""
+        """Determine whether the log contains a successful Telegram handshake mark. """
 
         if not path.exists():
             return False
@@ -931,7 +1193,7 @@ class MasterManager:
             text = path.read_text(encoding="utf-8", errors="ignore")
         except Exception as exc:
             log.warning(
-                "读取日志失败: %s",
+                "Failed to read log: %s",
                 exc,
                 extra={"log_path": str(path)},
             )
@@ -939,9 +1201,9 @@ class MasterManager:
         return any(marker in text for marker in HANDSHAKE_MARKERS)
 
     async def _health_check_worker(self, cfg: ProjectConfig, model: str) -> Optional[str]:
-        """验证 worker 启动后的健康状态，返回失败描述。"""
+        """Verify the health status of the worker after it is started and return a failure description. """
 
-        log_dir = LOG_ROOT_PATH / model / cfg.project_slug
+        log_dir = LOG_ROOT_PATH/model/cfg.project_slug
         pid_path = log_dir / "bot.pid"
         run_log = log_dir / "run_bot.log"
 
@@ -958,14 +1220,14 @@ class MasterManager:
                             break
                 except ValueError:
                     log.warning(
-                        "pid 文件 %s 内容异常",
+                        "pid The content of file %s is abnormal",
                         str(pid_path),
                         extra={"content": pid_path.read_text(encoding="utf-8", errors="ignore")},
                     )
                     last_seen_pid = None
                 except Exception as exc:
                     log.warning(
-                        "读取 pid 文件失败: %s",
+                        "Failed to read pid file: %s",
                         exc,
                         extra={"pid_path": str(pid_path)},
                     )
@@ -977,31 +1239,31 @@ class MasterManager:
 
         issues: List[str] = []
         if last_seen_pid is None:
-            issues.append("未检测到 bot.pid 或内容为空")
+            issues.append("Bot not detected.pid Or the content is empty")
         else:
             if self._pid_alive(last_seen_pid):
                 issues.append(
-                    f"worker 进程 {last_seen_pid} 未在 {WORKER_HEALTH_TIMEOUT:.1f}s 内完成 Telegram 握手"
+                    f"worker Process {last_seen_pid} is not in {WORKER_HEALTH_TIMEOUT:.1f}s Complete Telegram handshake"
                 )
             else:
-                issues.append(f"worker 进程 {last_seen_pid} 已退出")
+                issues.append(f"worker Process {last_seen_pid} has exited")
 
         log_tail = self._log_tail(run_log)
         if log_tail:
             issues.append(
-                "最近日志:\n" + textwrap.indent(log_tail, prefix="  ")
+                "Recent logs:\n" + textwrap.indent(log_tail, prefix="  ")
             )
 
         if not issues:
             return None
 
         return self._format_issue_message(
-            f"{cfg.display_name} 启动失败",
+            f"{cfg.display_name} Startup failed",
             issues,
         )
 
     async def run_worker(self, cfg: ProjectConfig, model: Optional[str] = None) -> str:
-        """启动指定项目的 worker，并返回运行模型名称。"""
+        """Starts a worker for the specified project and returns the running model name. """
 
         self.refresh_state()
         state = self.state_store.data[cfg.project_slug]
@@ -1009,11 +1271,11 @@ class MasterManager:
         issues = self._collect_prerequisite_issues(cfg, target_model)
         if issues:
             message = self._format_issue_message(
-                f"{cfg.display_name} 启动失败，缺少必要依赖或配置",
+                f"{cfg.display_name} Startup failed, missing necessary dependencies or configuration",
                 issues,
             )
             log.error(
-                "启动前自检失败: %s",
+                "Pre-start self-test failed: %s",
                 message,
                 extra={"project": cfg.project_slug, "model": target_model},
             )
@@ -1034,7 +1296,7 @@ class MasterManager:
         )
         cmd = [str(RUN_SCRIPT), "--model", target_model, "--project", cfg.project_slug]
         log.info(
-            "启动 worker: %s (model=%s, chat_id=%s)",
+            "Start worker: %s (model=%s, chat_id=%s)",
             cfg.display_name,
             target_model,
             chat_id_env,
@@ -1057,15 +1319,15 @@ class MasterManager:
         combined_output = "".join(output_chunks).strip()
         if rc != 0:
             tail_lines = "\n".join(combined_output.splitlines()[-20:]) if combined_output else ""
-            issues = [f"run_bot.sh 退出码 {rc}"]
+            issues = [f"run_bot.sh Exit code {rc}"]
             if tail_lines:
-                issues.append("脚本输出:\n  " + "\n  ".join(tail_lines.splitlines()))
+                issues.append("Script output:\n " + "\n ".join(tail_lines.splitlines()))
             message = self._format_issue_message(
-                f"{cfg.display_name} 启动失败",
+                f"{cfg.display_name} Startup failed",
                 issues,
             )
             log.error(
-                "worker 启动失败: %s",
+                "worker Startup failed: %s",
                 message,
                 extra={"project": cfg.project_slug, "model": target_model},
             )
@@ -1074,7 +1336,7 @@ class MasterManager:
         if health_issue:
             self.state_store.update(cfg.project_slug, status="stopped")
             log.error(
-                "worker 健康检查失败: %s",
+                "worker Health check failed: %s",
                 health_issue,
                 extra={"project": cfg.project_slug, "model": target_model},
             )
@@ -1084,7 +1346,7 @@ class MasterManager:
         return target_model
 
     async def stop_worker(self, cfg: ProjectConfig, *, update_state: bool = True) -> None:
-        """停止指定项目的 worker，必要时刷新状态。"""
+        """Stops the worker for the specified project and refreshes the status if necessary. """
 
         self.refresh_state()
         state = self.state_store.data[cfg.project_slug]
@@ -1094,24 +1356,24 @@ class MasterManager:
         await proc.wait()
         if update_state:
             self.state_store.update(cfg.project_slug, status="stopped")
-        log.info("已停止 worker: %s", cfg.display_name, extra={"project": cfg.project_slug})
+        log.info("Stopped worker: %s", cfg.display_name, extra={"project": cfg.project_slug})
 
     async def stop_all(self, *, update_state: bool = False) -> None:
-        """依次停止所有项目的 worker。"""
+        """Stop workers for all projects in sequence. """
 
         for cfg in self.configs:
             try:
                 await self.stop_worker(cfg, update_state=update_state)
             except Exception as exc:
                 log.warning(
-                    "停止 %s 时出错: %s",
+                    "Error stopping %s: %s",
                     cfg.display_name,
                     exc,
                     extra={"project": cfg.project_slug},
                 )
 
     async def run_all(self) -> None:
-        """启动所有尚未运行的项目 worker。"""
+        """Start all project workers that are not already running. """
 
         self.refresh_state()
         errors: List[str] = []
@@ -1123,7 +1385,7 @@ class MasterManager:
                 await self.run_worker(cfg)
             except Exception as exc:
                 log.warning(
-                    "启动 %s 时出错: %s",
+                    "Error starting %s: %s",
                     cfg.display_name,
                     exc,
                     extra={"project": cfg.project_slug},
@@ -1131,24 +1393,24 @@ class MasterManager:
                 errors.append(f"{cfg.display_name}: {exc}")
         if errors:
             raise RuntimeError(
-                self._format_issue_message("部分项目启动失败", errors)
+                self._format_issue_message("Some projects failed to start", errors)
             )
 
     async def restore_running(self) -> None:
-        """根据 state 文件恢复上一轮仍在运行的 worker。"""
+        """Resume the workers that were still running in the previous round according to the state file. """
 
         self.refresh_state()
         for slug, state in self.state_store.data.items():
             if state.status == "running":
                 cfg = self._slug_index.get(slug)
                 if not cfg:
-                    log.warning("状态文件包含未知项目: %s", slug)
+                    log.warning("Status file contains unknown item: %s", slug)
                     continue
                 try:
                     await self.run_worker(cfg, model=state.model)
                 except Exception as exc:
                     log.error(
-                        "恢复 %s 失败: %s",
+                        "Restore %s failed: %s",
                         cfg.display_name,
                         exc,
                         extra={"project": cfg.project_slug, "model": state.model},
@@ -1156,16 +1418,16 @@ class MasterManager:
                     self.state_store.update(slug, status="stopped")
 
     def update_chat_id(self, slug: str, chat_id: int) -> None:
-        """记录或更新项目的 chat_id 绑定信息。"""
+        """Record or update the chat_id binding information of the project. """
 
         cfg = self._resolve_project(slug)
         if not cfg:
-            raise ValueError(f"未知项目 {slug}")
+            raise ValueError(f"Unknown item {slug}")
         self.state_store.update(cfg.project_slug, chat_id=chat_id)
         log.info(
-            "记录 %s 的 chat_id=%s",
-            cfg.display_name,
+            "Recorded chat_id=%s for %s",
             chat_id,
+            cfg.display_name,
             extra={"project": cfg.project_slug},
         )
 
@@ -1177,7 +1439,7 @@ ProjectField = Literal["bot_name", "bot_token", "project_slug", "default_model",
 
 @dataclass
 class ProjectWizardSession:
-    """记录单个聊天的项目管理对话状态。"""
+    """Record project management conversation status for a single chat. """
 
     chat_id: int
     user_id: int
@@ -1208,27 +1470,27 @@ PROJECT_MODEL_CHOICES: Tuple[str, ...] = ("codex", "claudecode", "gemini")
 PROJECT_WIZARD_SESSIONS: Dict[int, ProjectWizardSession] = {}
 PROJECT_WIZARD_LOCK = asyncio.Lock()
 PROJECT_FIELD_PROMPTS_CREATE: Dict[ProjectField, str] = {
-    "bot_name": "请输入 bot 名称（不含 @，仅字母、数字、下划线或点）：",
-    "bot_token": "请输入 Telegram Bot Token（格式类似 123456:ABCdef）：",
-    "project_slug": "请输入项目 slug（用于日志目录，留空自动根据 bot 名生成）：",
-    "default_model": "请输入默认模型（codex/claudecode/gemini，留空采用 codex）：",
-    "workdir": "请输入 worker 工作目录绝对路径（可留空稍后补全）：",
-    "allowed_chat_id": "请输入预设 chat_id（可留空，暂不支持多个）：",
+    "bot_name": "Please enter a bot name (without @, only letters, numbers, underscores or dots):",
+    "bot_token": "Please enter Telegram Bot Token (format similar to 123456:ABCdef):",
+    "project_slug": "Please enter the project slug (for the log directory, leave it blank to automatically generate based on the bot name): ",
+    "default_model": "Please enter the default model (codex/claudecode/gemini, leave it blank to use codex):",
+    "workdir": "Please enter the absolute path of the worker's working directory (you can leave it blank and complete it later): ",
+    "allowed_chat_id": "Please enter the default chat_id (can be left blank, multiple are not supported at the moment): ",
 }
 PROJECT_FIELD_PROMPTS_EDIT: Dict[ProjectField, str] = {
-    "bot_name": "请输入新的 bot 名（不含 @，发送 - 保持当前值：{current}）：",
-    "bot_token": "请输入新的 Bot Token（发送 - 保持当前值）：",
-    "project_slug": "请输入新的项目 slug（发送 - 保持当前值：{current}）：",
-    "default_model": "请输入新的默认模型（codex/claudecode/gemini，发送 - 保持当前值：{current}）：",
-    "workdir": "请输入新的工作目录（发送 - 保持当前值：{current}，可留空改为未设置）：",
-    "allowed_chat_id": "请输入新的 chat_id（发送 - 保持当前值：{current}，留空表示取消预设）：",
+    "bot_name": "Please enter a new bot name (without @, send - keep current value: {current}):",
+    "bot_token": "Please enter new Bot Token (send - keep current value):",
+    "project_slug": "Please enter new item slug (send - keep current value: {current}):",
+    "default_model": "Please enter new default model (codex/claudecode/gemini, send - keep current value: {current}):",
+    "workdir": "Please enter a new working directory (send - keep current value: {current}, can be left blank to not set): ",
+    "allowed_chat_id": "Please enter a new chat_id (Send - keep current value: {current}, leave blank to cancel default):",
 }
 
 
 def _ensure_repository() -> ProjectRepository:
-    """获取项目仓库实例，未初始化时抛出异常。"""
+    """Get the project warehouse instance and throw an exception if it is not initialized. """
     if PROJECT_REPOSITORY is None:
-        raise RuntimeError("项目仓库未初始化")
+        raise RuntimeError("Project warehouse is not initialized")
     return PROJECT_REPOSITORY
 
 
@@ -1237,7 +1499,7 @@ def _reload_manager_configs(
     *,
     preserve: Optional[Dict[str, ProjectState]] = None,
 ) -> List[ProjectConfig]:
-    """重新加载项目配置，并可选地保留指定状态映射。"""
+    """Reloads the project configuration and optionally preserves the specified state mapping. """
     repository = _ensure_repository()
     records = repository.list_projects()
     configs = [ProjectConfig.from_dict(record.to_dict()) for record in records]
@@ -1250,10 +1512,10 @@ def _validate_field_value(
     field_name: ProjectField,
     raw_text: str,
 ) -> Tuple[Optional[Any], Optional[str]]:
-    """校验字段输入，返回转换后的值与错误信息。"""
+    """Verify field input and return the converted value and error message. """
     text = raw_text.strip()
     repository = _ensure_repository()
-    # 编辑流程允许使用 "-" 保持原值
+    # The editing process allows the use of "-" to maintain the original value
     if session.mode == "edit" and text == "-":
         return session.data.get(field_name), None
 
@@ -1263,44 +1525,44 @@ def _validate_field_value(
     if field_name == "bot_name":
         candidate = text.lstrip("@").strip()
         if not candidate:
-            return None, "bot 名不能为空"
+            return None, "bot name cannot be empty"
         if not re.fullmatch(r"[A-Za-z0-9_.]{5,64}", candidate):
-            return None, "bot 名仅允许 5-64 位字母、数字、下划线或点"
+            return None, "bot Names only allow 5-64 letters, numbers, underscores or dots"
         existing = repository.get_by_bot_name(candidate)
         if existing and (session.mode == "create" or existing.project_slug != session.original_slug):
-            return None, "该 bot 名已被其它项目占用"
+            return None, "The bot name is already occupied by another project"
         return candidate, None
 
     if field_name == "bot_token":
         if not re.fullmatch(r"\d+:[A-Za-z0-9_-]{20,128}", text):
-            return None, "Bot Token 格式不正确，请确认输入"
+            return None, "Bot Token The format is incorrect, please confirm your input"
         return text, None
 
     if field_name == "project_slug":
         candidate = _sanitize_slug(text or session.data.get("bot_name", ""))
         if not candidate:
-            return None, "无法生成有效的 slug，请重新输入"
+            return None, "Unable to generate a valid slug, please re-enter"
         existing = repository.get_by_slug(candidate)
         if existing and (session.mode == "create" or existing.project_slug != session.original_slug):
-            return None, "该 slug 已存在，请更换其它名称"
+            return None, "The slug already exists, please change it to another name"
         return candidate, None
 
     if field_name == "default_model":
         candidate = text.lower() if text else "codex"
         if candidate not in PROJECT_MODEL_CHOICES:
-            return None, f"默认模型仅支持 {', '.join(PROJECT_MODEL_CHOICES)}"
+            return None, f"The default model only supports {', '.join(PROJECT_MODEL_CHOICES)}"
         return candidate, None
 
     if field_name == "workdir":
         expanded = os.path.expandvars(os.path.expanduser(text))
         path = Path(expanded)
         if not path.exists() or not path.is_dir():
-            return None, f"目录不存在或不可用：{text}"
+            return None, f"Directory does not exist or is unavailable: {text}"
         return str(path), None
 
     if field_name == "allowed_chat_id":
         if not re.fullmatch(r"-?\d+", text):
-            return None, "chat_id 需为整数，可留空跳过"
+            return None, "chat_id It needs to be an integer and can be left blank to skip"
         return int(text), None
 
     return text, None
@@ -1309,12 +1571,12 @@ def _validate_field_value(
 def _format_field_prompt(
     session: ProjectWizardSession, field_name: ProjectField
 ) -> Tuple[str, Optional[InlineKeyboardMarkup]]:
-    """根据流程生成字段提示语与可选操作键盘。"""
+    """Generate field prompts and optional operation keyboard according to the process. """
 
     if session.mode == "edit":
         current_value = session.data.get(field_name)
         if current_value is None:
-            display = "未设置"
+            display = "Not set"
         elif field_name == "bot_token":
             display = f"{str(current_value)[:6]}***"
         else:
@@ -1334,7 +1596,7 @@ def _format_field_prompt(
     if skip_enabled:
         builder = InlineKeyboardBuilder()
         builder.button(
-            text="跳过此项",
+            text="Skip this",
             callback_data=f"project:wizard:skip:{field_name}",
         )
         markup = builder.as_markup()
@@ -1349,7 +1611,7 @@ async def _send_field_prompt(
     *,
     prefix: str = "",
 ) -> None:
-    """向用户发送当前字段的提示语与可选跳过按钮。"""
+    """Sends the user a prompt and optional skip button for the current field. """
 
     prompt, markup = _format_field_prompt(session, field_name)
     if prefix:
@@ -1360,7 +1622,7 @@ async def _send_field_prompt(
 
 
 def _session_to_record(session: ProjectWizardSession) -> ProjectRecord:
-    """将会话数据转换为 ProjectRecord，编辑时保留 legacy_name。"""
+    """Convert session data to ProjectRecord, preserving legacy_name when editing. """
     legacy_name = session.original_record.legacy_name if session.original_record else None
     return ProjectRecord(
         bot_name=session.data["bot_name"],
@@ -1378,14 +1640,14 @@ async def _commit_wizard_session(
     manager: MasterManager,
     message: Message,
 ) -> bool:
-    """提交会话数据并执行仓库写入。"""
+    """Commits session data and performs warehouse writes. """
     repository = _ensure_repository()
     record = _session_to_record(session)
     try:
         if session.mode == "create":
             repository.insert_project(record)
             _reload_manager_configs(manager)
-            summary_prefix = "新增项目成功 ✅"
+            summary_prefix = "Added project successfully ✅"
         elif session.mode == "edit":
             original_slug = session.original_slug or record.project_slug
             preserve: Optional[Dict[str, ProjectState]] = None
@@ -1396,23 +1658,23 @@ async def _commit_wizard_session(
             if original_slug != record.project_slug and original_slug in manager.state_store.data:
                 del manager.state_store.data[original_slug]
             _reload_manager_configs(manager, preserve=preserve)
-            summary_prefix = "项目已更新 ✅"
+            summary_prefix = "Project has been updated ✅"
         else:
             return False
     except Exception as exc:
-        log.error("项目写入失败: %s", exc, extra={"mode": session.mode})
-        await message.answer(f"保存失败：{exc}")
+        log.error("Project write failed: %s", exc, extra={"mode": session.mode})
+        await message.answer(f"Save failed: {exc}")
         return False
 
-    workdir_desc = record.workdir or "未设置"
-    chat_desc = record.allowed_chat_id if record.allowed_chat_id is not None else "未设置"
+    workdir_desc=record.workdir or "Not set"
+    chat_desc=record.allowed_chat_id if record.allowed_chat_id is not None else "Not set"
     summary = (
         f"{summary_prefix}\n"
-        f"bot：@{record.bot_name}\n"
-        f"slug：{record.project_slug}\n"
-        f"模型：{record.default_model}\n"
-        f"工作目录：{workdir_desc}\n"
-        f"chat_id：{chat_desc}"
+        f"bot:@{record.bot_name}\n"
+        f"slug:{record.project_slug}\n"
+        f"Model: {record.default_model}\n"
+        f"Working directory: {workdir_desc}\n"
+        f"chat_id:{chat_desc}"
     )
     await message.answer(summary)
     await _send_projects_overview_to_chat(message.bot, message.chat.id, manager)
@@ -1425,16 +1687,16 @@ async def _advance_wizard_session(
     message: Message,
     text: str,
     *,
-    prefix: str = "已记录 ✅",
+    prefix: str = "Recorded ✅",
 ) -> bool:
-    """推进项目管理流程，校验输入并触发后续步骤。"""
+    """Advance the project management process, validate inputs and trigger subsequent steps. """
 
     if session.step_index >= len(session.fields):
-        await message.answer("流程已完成，如需再次修改请重新开始。")
+        await message.answer("The process has been completed. If you need to modify it again, please start again. ")
         return True
 
     if not session.fields:
-        await message.answer("流程配置异常，请重新开始。")
+        await message.answer("The process configuration is abnormal, please start again. ")
         async with PROJECT_WIZARD_LOCK:
             PROJECT_WIZARD_SESSIONS.pop(message.chat.id, None)
         return True
@@ -1442,7 +1704,7 @@ async def _advance_wizard_session(
     field_name = session.fields[session.step_index]
     value, error = _validate_field_value(session, field_name, text)
     if error:
-        await message.answer(f"{error}\n请重新输入：")
+        await message.answer(f"{error}\nPlease re-enter:")
         return True
 
     session.data[field_name] = value
@@ -1463,25 +1725,28 @@ async def _advance_wizard_session(
         await _send_field_prompt(session, next_field, message, prefix=prefix)
         return True
 
-    # 所有字段已填写，执行写入
+    # All fields are filled in, perform writing
     success = await _commit_wizard_session(session, manager, message)
     async with PROJECT_WIZARD_LOCK:
         PROJECT_WIZARD_SESSIONS.pop(message.chat.id, None)
 
     if success:
-        await message.answer("项目管理流程已完成。")
+        await message.answer("The project management process is complete. ")
     return True
 
 
 async def _start_project_create(callback: CallbackQuery, manager: MasterManager) -> None:
-    """启动新增项目流程。"""
+    """Start the new project process. """
     if callback.message is None or callback.from_user is None:
         return
     chat_id = callback.message.chat.id
     user_id = callback.from_user.id
     async with PROJECT_WIZARD_LOCK:
         if chat_id in PROJECT_WIZARD_SESSIONS:
-            await callback.answer("当前会话已有流程进行中，请先完成或发送“取消”。", show_alert=True)
+            await callback.answer(
+                'There is already a project wizard in progress for this chat. Complete it first or send "Cancel".',
+                show_alert=True,
+            )
             return
         session = ProjectWizardSession(
             chat_id=chat_id,
@@ -1490,9 +1755,9 @@ async def _start_project_create(callback: CallbackQuery, manager: MasterManager)
             fields=PROJECT_WIZARD_FIELDS_CREATE,
         )
         PROJECT_WIZARD_SESSIONS[chat_id] = session
-    await callback.answer("开始新增项目流程")
+    await callback.answer("Started the new-project wizard.")
     await callback.message.answer(
-        "已进入新增项目流程，随时可发送“取消”终止。",
+        'The new-project wizard is now active. Send "Cancel" at any time to abort.',
     )
     first_field = session.fields[0]
     await _send_field_prompt(session, first_field, callback.message)
@@ -1503,19 +1768,22 @@ async def _start_project_edit(
     cfg: ProjectConfig,
     manager: MasterManager,
 ) -> None:
-    """启动项目编辑流程。"""
+    """Start the project editing process. """
     if callback.message is None or callback.from_user is None:
         return
     repository = _ensure_repository()
     record = repository.get_by_slug(cfg.project_slug)
     if record is None:
-        await callback.answer("未找到项目配置", show_alert=True)
+        await callback.answer("Project configuration not found", show_alert=True)
         return
     chat_id = callback.message.chat.id
     user_id = callback.from_user.id
     async with PROJECT_WIZARD_LOCK:
         if chat_id in PROJECT_WIZARD_SESSIONS:
-            await callback.answer("当前会话已有流程进行中，请先完成或发送“取消”。", show_alert=True)
+            await callback.answer(
+                'There is already a project wizard in progress for this chat. Complete it first or send "Cancel".',
+                show_alert=True,
+            )
             return
         session = ProjectWizardSession(
             chat_id=chat_id,
@@ -1534,26 +1802,26 @@ async def _start_project_edit(
             "allowed_chat_id": record.allowed_chat_id,
         }
         PROJECT_WIZARD_SESSIONS[chat_id] = session
-    await callback.answer("开始编辑项目")
+    await callback.answer("Started the edit-project wizard.")
     await callback.message.answer(
-        f"已进入编辑流程：{cfg.display_name}，随时可发送“取消”终止。",
+        f'Entered the editing wizard for {cfg.display_name}. Send "Cancel" at any time to abort.',
     )
     field_name = session.fields[0]
     await _send_field_prompt(session, field_name, callback.message)
 
 
 def _build_delete_confirmation_keyboard(slug: str) -> InlineKeyboardMarkup:
-    """构建删除确认用的按钮键盘。"""
+    """Build a button keyboard for deletion confirmation. """
     builder = InlineKeyboardBuilder()
     builder.row(
         InlineKeyboardButton(
-            text="确认删除 ✅",
+            text="Confirm deletion ✅",
             callback_data=f"project:delete_confirm:{slug}",
         )
     )
     builder.row(
         InlineKeyboardButton(
-            text="取消",
+            text="Cancel",
             callback_data="project:delete_cancel",
         )
     )
@@ -1567,23 +1835,23 @@ async def _start_project_delete(
     manager: MasterManager,
     state: FSMContext,
 ) -> None:
-    """启动删除项目的确认流程。"""
+    """Initiates the confirmation process for deleting the item. """
     if callback.message is None or callback.from_user is None:
         return
     repository = _ensure_repository()
     original_record = repository.get_by_slug(cfg.project_slug)
     original_slug = original_record.project_slug if original_record else cfg.project_slug
-    # 删除前再次读取运行态，避免 FSM 上下文被误覆盖
+    # Read the running state again before deleting to avoid accidentally overwriting the FSM context.
     project_runtime_state = _get_project_runtime_state(manager, cfg.project_slug)
     if project_runtime_state and project_runtime_state.status == "running":
-        await callback.answer("请先停止该项目的 worker 后再删除。", show_alert=True)
+        await callback.answer("Please stop the worker of this project before deleting it.", show_alert=True)
         return
     current_state = await state.get_state()
     if current_state == ProjectDeleteStates.confirming.state:
         data = await state.get_data()
         existing_slug = str(data.get("project_slug", "")).lower()
         if existing_slug == cfg.project_slug.lower():
-            await callback.answer("当前删除流程已在确认中，请使用按钮完成操作。", show_alert=True)
+            await callback.answer("The current deletion process is being confirmed, please use the buttons to finish the operation.", show_alert=True)
             return
         await state.clear()
     await state.set_state(ProjectDeleteStates.confirming)
@@ -1596,10 +1864,10 @@ async def _start_project_delete(
         bot_name=cfg.bot_name,
     )
     markup = _build_delete_confirmation_keyboard(cfg.project_slug)
-    await callback.answer("删除确认已发送")
+    await callback.answer("Deletion confirmation sent")
     await callback.message.answer(
-        f"确认删除项目 {cfg.display_name}？此操作不可恢复。\n"
-        f"请在 {DELETE_CONFIRM_TIMEOUT} 秒内使用下方按钮确认或取消。",
+        f"Confirm deletion of project {cfg.display_name}? This action cannot be undone.\n"
+        f"Use the buttons below to confirm or cancel within {DELETE_CONFIRM_TIMEOUT} seconds.",
         reply_markup=markup,
     )
 
@@ -1608,7 +1876,7 @@ async def _handle_wizard_message(
     message: Message,
     manager: MasterManager,
 ) -> bool:
-    """处理项目管理流程中的用户输入。"""
+    """Handle user input in the project management process. """
     if message.chat is None or message.from_user is None:
         return False
     chat_id = message.chat.id
@@ -1617,26 +1885,26 @@ async def _handle_wizard_message(
     if session is None:
         return False
     if message.from_user.id != session.user_id:
-        await message.answer("仅流程发起者可以继续操作。")
+        await message.answer("Only the process initiator can proceed. ")
         return True
     text = (message.text or "").strip()
-    if text.lower() in {"取消", "cancel", "/cancel"}:
+    if text.lower() in {"Cancel", "cancel", "/cancel"}:
         async with PROJECT_WIZARD_LOCK:
             PROJECT_WIZARD_SESSIONS.pop(chat_id, None)
-        await message.answer("已取消项目管理流程。")
+        await message.answer("The project management process has been cancelled. ")
         return True
 
     return await _advance_wizard_session(session, manager, message, text)
 router = Router()
 log = create_logger("master", level_env="MASTER_LOG_LEVEL", stderr_env="MASTER_STDERR")
 
-# 重启状态锁与标记，避免重复触发
+# Restart state locks and markers to avoid repeated triggering
 _restart_lock: Optional[asyncio.Lock] = None
 _restart_in_progress: bool = False
 
 
 def _ensure_restart_lock() -> asyncio.Lock:
-    """延迟创建 asyncio.Lock，确保在事件循环内初始化"""
+    """Lazily create the restart lock, ensuring it is initialised inside the event loop."""
     global _restart_lock
     if _restart_lock is None:
         _restart_lock = asyncio.Lock()
@@ -1644,7 +1912,7 @@ def _ensure_restart_lock() -> asyncio.Lock:
 
 
 def _log_update(message: Message, *, override_user: Optional[User] = None) -> None:
-    """记录每条更新并同步 MASTER_ENV_FILE 中的最近聊天信息。"""
+    """Log every update and sync recent chat messages in MASTER_ENV_FILE. """
 
     user = override_user or message.from_user
     username = user.username if user and user.username else None
@@ -1661,45 +1929,45 @@ def _log_update(message: Message, *, override_user: Optional[User] = None) -> No
 
 
 def _safe_remove(path: Path, *, retries: int = 3) -> None:
-    """安全移除文件，支持重试机制
+    """Safely remove files and support retry mechanism
 
     Args:
-        path: 要删除的文件路径
-        retries: 最大重试次数（默认 3 次）
+        path: the path of the file to be deleted
+        retries: Maximum number of retries (default 3)
     """
     if not path.exists():
-        log.debug("文件不存在，无需删除", extra={"path": str(path)})
+        log.debug("The file does not exist, no need to delete it", extra={"path": str(path)})
         return
 
     for attempt in range(retries):
         try:
             path.unlink()
-            log.info("重启信号文件已删除", extra={"path": str(path), "attempt": attempt + 1})
+            log.info("The restart signal file has been deleted", extra={"path": str(path), "attempt": attempt + 1})
             return
         except FileNotFoundError:
-            log.debug("文件已被其他进程删除", extra={"path": str(path)})
+            log.debug("The file has been deleted by another process", extra={"path": str(path)})
             return
         except Exception as exc:
             if attempt < retries - 1:
                 log.warning(
-                    "删除文件失败，将重试 (attempt %d/%d): %s",
+                    "Failed to delete file, will try again (attempt %d/%d): %s",
                     attempt + 1,
                     retries,
                     exc,
                     extra={"path": str(path)}
                 )
                 import time
-                time.sleep(0.1)  # 等待 100ms 后重试
+                time.sleep(0.1)  # Wait 100ms and try again
             else:
                 log.error(
-                    "删除文件失败，已达最大重试次数: %s",
+                    "Failed to delete file, maximum number of retries reached: %s",
                     exc,
                     extra={"path": str(path), "retries": retries}
                 )
 
 
 def _write_restart_signal(message: Message, *, override_user: Optional[User] = None) -> None:
-    """将重启请求信息写入 signal 文件，供新 master 启动后读取"""
+    """Write the restart request information to the signal file for the new master to read after starting """
     now_local = datetime.now(LOCAL_TZ)
     actor = override_user or message.from_user
     payload = {
@@ -1716,7 +1984,7 @@ def _write_restart_signal(message: Message, *, override_user: Optional[User] = N
     )
     tmp_path.replace(RESTART_SIGNAL_PATH)
     log.info(
-        "已记录重启信号: chat_id=%s user_id=%s 文件=%s",
+        "Logged restart signal: chat_id=%s user_id=%s file=%s",
         payload["chat_id"],
         payload["user_id"],
         RESTART_SIGNAL_PATH,
@@ -1725,7 +1993,7 @@ def _write_restart_signal(message: Message, *, override_user: Optional[User] = N
 
 
 def _read_restart_signal() -> Tuple[Optional[dict], Optional[Path]]:
-    """读取并验证重启 signal，兼容历史路径并处理异常/超时情况"""
+    """Read and verify restart signals, be compatible with historical paths and handle exceptions/timeouts"""
     candidates: Tuple[Path, ...] = (RESTART_SIGNAL_PATH, *LEGACY_RESTART_SIGNAL_PATHS)
     for path in candidates:
         if not path.exists():
@@ -1733,9 +2001,9 @@ def _read_restart_signal() -> Tuple[Optional[dict], Optional[Path]]:
         try:
             raw = json.loads(path.read_text(encoding="utf-8"))
             if not isinstance(raw, dict):
-                raise ValueError("signal payload 必须是对象")
+                raise ValueError("signal payload Must be an object")
         except Exception as exc:
-            log.error("读取重启信号失败: %s", exc, extra={"path": str(path)})
+            log.error("Failed to read restart signal: %s", exc, extra={"path": str(path)})
             _safe_remove(path)
             continue
 
@@ -1749,7 +2017,7 @@ def _read_restart_signal() -> Tuple[Optional[dict], Optional[Path]]:
                 age_seconds = (datetime.now(timezone.utc) - ts_utc).total_seconds()
                 if age_seconds > RESTART_SIGNAL_TTL:
                     log.info(
-                        "重启信号超时，忽略",
+                        "Restart signal timed out, ignored",
                         extra={
                             "path": str(path),
                             "age_seconds": age_seconds,
@@ -1759,11 +2027,11 @@ def _read_restart_signal() -> Tuple[Optional[dict], Optional[Path]]:
                     _safe_remove(path)
                     continue
             except Exception as exc:
-                log.warning("解析重启信号时间戳失败: %s", exc, extra={"path": str(path)})
+                log.warning("Failed to parse restart signal timestamp: %s", exc, extra={"path": str(path)})
 
         if path != RESTART_SIGNAL_PATH:
             log.info(
-                "从兼容路径读取重启信号",
+                "Read restart signal from compatible path",
                 extra={"path": str(path), "primary": str(RESTART_SIGNAL_PATH)},
             )
         return raw, path
@@ -1772,22 +2040,22 @@ def _read_restart_signal() -> Tuple[Optional[dict], Optional[Path]]:
 
 
 async def _notify_restart_success(bot: Bot) -> None:
-    """在新 master 启动时读取 signal 并通知触发者（改进版：支持超时检测和详细诊断）"""
-    restart_expected = os.environ.pop("MASTER_RESTART_EXPECTED", None)
+    """Read the signal and notify the triggerer when the new master starts (improved version: supports timeout detection and detailed diagnosis)"""
+    restart_expected=os.environ.pop("MASTER_RESTART_EXPECTED", None)
     payload, signal_path = _read_restart_signal()
 
-    # 定义重启健康检查阈值（2 分钟）
-    RESTART_HEALTHY_THRESHOLD = 120  # 秒
-    RESTART_WARNING_THRESHOLD = 60   # 超过 1 分钟发出警告
+    # Define restart health check thresholds (2 minutes)
+    RESTART_HEALTHY_THRESHOLD = 120 # seconds
+    RESTART_WARNING_THRESHOLD = 60 # Warn after more than 1 minute
 
     if not payload:
         if restart_expected:
             targets = _collect_admin_targets()
             log.warning(
-                "启动时未检测到重启信号文件，将向管理员发送兜底提醒", extra={"targets": targets}
+                "If the restart signal file is not detected during startup, a cryptic reminder will be sent to the administrator.", extra={"targets": targets}
             )
             if targets:
-                # 检查启动日志是否有错误信息
+                # Check the startup log for error messages
                 error_log_dir = LOG_ROOT_PATH
                 error_log_hint = ""
                 try:
@@ -1795,23 +2063,23 @@ async def _notify_restart_success(bot: Bot) -> None:
                     if error_logs:
                         latest_error_log = error_logs[0]
                         if latest_error_log.stat().st_size > 0:
-                            error_log_hint = f"\n⚠️ 发现错误日志：{latest_error_log}"
+                            error_log_hint = f"\n⚠️ Error log found: {latest_error_log}"
                 except Exception:
                     pass
 
                 text_lines = [
-                    "⚠️ Master 已重新上线，但未找到重启触发者信息。",
+                    "⚠️ Master It's back online, but no information about the restart trigger was found. ",
                     "",
-                    "可能原因：",
-                    "1. 重启信号文件写入失败",
-                    "2. 信号文件已超时被清理（TTL=30分钟）",
-                    "3. 文件系统权限问题",
-                    "4. start.sh 启动失败后被清理",
+                    "Possible reasons: ",
+                    "1. Restart signal file writing failed",
+                    "2. The signal file has timed out and been cleared (TTL=30 minutes)",
+                    "3. File system permission issues",
+                    "4. start.sh Cleaned up after failed startup",
                     "",
-                    "建议检查：",
-                    f"- 启动日志: {LOG_ROOT_PATH / 'start.log'}",
-                    f"- 运行日志: {LOG_ROOT_PATH / 'vibe.log'}",
-                    f"- 信号文件: {RESTART_SIGNAL_PATH}",
+                    "Recommended to check: ",
+                    f"- Startup log: {LOG_ROOT_PATH / 'start.log'}",
+                    f"- Running log: {LOG_ROOT_PATH / 'vibe.log'}",
+                    f"- Signal file: {RESTART_SIGNAL_PATH}",
                 ]
                 if error_log_hint:
                     text_lines.append(error_log_hint)
@@ -1820,18 +2088,18 @@ async def _notify_restart_success(bot: Bot) -> None:
                 for chat in targets:
                     try:
                         await bot.send_message(chat_id=chat, text=text)
-                        log.info("兜底重启通知已发送", extra={"chat": chat})
+                        log.info("The complete restart notification has been sent", extra={"chat": chat})
                     except Exception as exc:
-                        log.error("发送兜底重启通知失败: %s", exc, extra={"chat": chat})
+                        log.error("Failed to send full restart notification: %s", exc, extra={"chat": chat})
         else:
-            log.info("启动时未检测到重启信号文件，可能是正常启动。")
+            log.info("The restart signal file was not detected during startup. It may be a normal startup. ")
         return
 
     chat_id_raw = payload.get("chat_id")
     try:
         chat_id = int(chat_id_raw)
     except (TypeError, ValueError):
-        log.error("重启信号 chat_id 非法: %s", chat_id_raw)
+        log.error("Restart signal chat_id is illegal: %s", chat_id_raw)
         targets = (signal_path, RESTART_SIGNAL_PATH, *LEGACY_RESTART_SIGNAL_PATHS)
         for candidate in targets:
             if candidate is None:
@@ -1845,7 +2113,7 @@ async def _notify_restart_success(bot: Bot) -> None:
     timestamp_fmt: Optional[str] = None
     restart_duration: Optional[int] = None
 
-    # 计算重启耗时
+    # Calculate restart time
     if timestamp:
         try:
             ts = datetime.fromisoformat(timestamp)
@@ -1854,36 +2122,36 @@ async def _notify_restart_success(bot: Bot) -> None:
             ts_local = ts.astimezone(LOCAL_TZ)
             timestamp_fmt = ts_local.strftime("%Y-%m-%d %H:%M:%S %Z")
 
-            # 计算重启耗时（秒）
+            # Calculate restart time (seconds)
             now = datetime.now(LOCAL_TZ)
             restart_duration = int((now - ts_local).total_seconds())
         except Exception as exc:
-            log.warning("解析重启时间失败: %s", exc)
+            log.warning("Failed to parse restart time: %s", exc)
 
     details = []
     if username:
-        details.append(f"触发人：@{username}")
+        details.append(f"Trigger: @{username}")
     elif user_id:
-        details.append(f"触发人ID：{user_id}")
+        details.append(f"Trigger ID: {user_id}")
     if timestamp_fmt:
-        details.append(f"请求时间：{timestamp_fmt}")
+        details.append(f"Request time:{timestamp_fmt}")
 
-    # 添加重启耗时信息和健康状态
+    # Add restart time-consuming information and health status
     message_lines = []
     if restart_duration is not None:
         if restart_duration <= RESTART_WARNING_THRESHOLD:
-            message_lines.append(f"master 已重新上线 ✅（耗时 {restart_duration}秒）")
+            message_lines.append(f"master Back online ✅(It took {restart_duration} seconds)")
         elif restart_duration <= RESTART_HEALTHY_THRESHOLD:
-            message_lines.append(f"⚠️ master 已重新上线（耗时 {restart_duration}秒，略慢）")
-            details.append("💡 建议：检查依赖安装是否触发了重新下载")
+            message_lines.append(f"⚠️ master Back online (took {restart_duration} seconds, slightly slower)")
+            details.append("💡 Suggestion: Check if dependency installation triggers a re-download")
         else:
-            message_lines.append(f"⚠️ master 已重新上线（耗时 {restart_duration}秒，异常缓慢）")
-            details.append("⚠️ 重启耗时过长，建议检查：")
-            details.append("  - 网络连接是否正常")
-            details.append("  - 依赖安装是否卡住")
-            details.append(f"  - 启动日志: {LOG_ROOT_PATH / 'start.log'}")
+            message_lines.append(f"⚠️ master Back online (took {restart_duration} seconds, unusually slow)")
+            details.append("⚠️ Restarting takes too long, please check: ")
+            details.append("  - Is the network connection normal?")
+            details.append("  - Whether the dependency installation is stuck")
+            details.append(f"  - Startup log: {LOG_ROOT_PATH / 'start.log'}")
     else:
-        message_lines.append("master 已重新上线 ✅")
+        message_lines.append("master Back online ✅")
 
     if details:
         message_lines.extend(details)
@@ -1893,10 +2161,10 @@ async def _notify_restart_success(bot: Bot) -> None:
     try:
         await bot.send_message(chat_id=chat_id, text=text)
     except Exception as exc:
-        log.error("发送重启成功通知失败: %s", exc, extra={"chat": chat_id})
+        log.error("Failed to send restart successful notification: %s", exc, extra={"chat": chat_id})
     else:
-        # 重启成功后不再附带项目列表，避免高频重启时产生额外噪音
-        log.info("重启成功通知已发送", extra={"chat": chat_id, "duration": restart_duration})
+        # After a successful restart, the project list will no longer be included to avoid extra noise during high-frequency restarts.
+        log.info("Restart successful notification has been sent", extra={"chat": chat_id, "duration": restart_duration})
     finally:
         candidates = (signal_path, RESTART_SIGNAL_PATH, *LEGACY_RESTART_SIGNAL_PATHS)
         for candidate in candidates:
@@ -1906,33 +2174,33 @@ async def _notify_restart_success(bot: Bot) -> None:
 
 
 async def _ensure_manager() -> MasterManager:
-    """确保 MANAGER 已初始化，未初始化时抛出异常。"""
+    """Make sure MANAGER is initialized, throw an exception if it is not initialized. """
 
     global MANAGER
     if MANAGER is None:
-        raise RuntimeError("Master manager 未初始化")
+        raise RuntimeError("Master manager is not initialized")
     return MANAGER
 
 
 async def _process_restart_request(
-    message: Message,
+    message: message,
     *,
     trigger_user: Optional[User] = None,
     manager: Optional[MasterManager] = None,
 ) -> None:
-    """响应 /restart 请求，写入重启信号并触发脚本。"""
+    """Respond to /restart requests, write restart signals and trigger scripts. """
 
     if manager is None:
         manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
 
     lock = _ensure_restart_lock()
     async with lock:
-        global _restart_in_progress
+        global_restart_in_progress
         if _restart_in_progress:
-            await message.answer("已有重启请求在执行，请稍候再试。")
+            await message.answer("A restart request is already being executed, please try again later. ")
             return
         _restart_in_progress = True
 
@@ -1940,7 +2208,7 @@ async def _process_restart_request(
     if not start_script.exists():
         async with lock:
             _restart_in_progress = False
-        await message.answer("未找到 ./start.sh，无法执行重启。")
+        await message.answer("not found ./start.sh,Unable to perform restart. ")
         return
 
     signal_error: Optional[str] = None
@@ -1948,14 +2216,14 @@ async def _process_restart_request(
         _write_restart_signal(message, override_user=trigger_user)
     except Exception as exc:
         signal_error = str(exc)
-        log.error("记录重启信号异常: %s", exc)
+        log.error("Record restart signal exception: %s", exc)
 
     notice = (
-        "已收到重启指令，运行期间 master 会短暂离线，重启后所有 worker 需稍后手动启动。"
+        "The restart command has been received. The master will be temporarily offline during operation. After restarting, all workers need to be started manually later. "
     )
     if signal_error:
         notice += (
-            "\n⚠️ 重启信号写入失败，可能无法在重启完成后自动通知。原因: "
+            "\n⚠️ The restart signal writing failed and may not be automatically notified after the restart is completed. Reason: "
             f"{signal_error}"
         )
 
@@ -1966,18 +2234,18 @@ async def _process_restart_request(
 
 @router.message(CommandStart())
 async def cmd_start(message: Message) -> None:
-    """处理 /start 命令，返回项目概览与状态。"""
+    """Handles the /start command and returns project overview and status. """
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
     manager.refresh_state()
     await message.answer(
-        f"Master bot 已启动（v{__version__}）。\n"
-        f"已登记项目: {len(manager.configs)} 个。\n"
-        "使用 /projects 查看状态，/run 或 /stop 控制 worker。",
+        f"Master bot Started (v{__version__}). \n"
+        f"Registered items: {len(manager.configs)} indivual. \n"
+        "Use /projects to view status, /run or /stop to control workers. ",
         reply_markup=_build_master_main_keyboard(),
     )
     await _send_projects_overview_to_chat(
@@ -1989,8 +2257,8 @@ async def cmd_start(message: Message) -> None:
 
 
 async def _perform_restart(message: Message, start_script: Path) -> None:
-    """异步执行 ./start.sh，若失败则回滚标记并通知管理员"""
-    global _restart_in_progress
+    """Asynchronous execution ./start.sh,If it fails, roll back the mark and notify the administrator """
+    global_restart_in_progress
     lock = _ensure_restart_lock()
     bot = message.bot
     chat_id = message.chat.id
@@ -2001,41 +2269,41 @@ async def _perform_restart(message: Message, start_script: Path) -> None:
     try:
         await bot.send_message(
             chat_id=chat_id,
-            text="开始重启，当前 master 将退出并重新拉起，请稍候。",
+            text="Start restarting, the current master will exit and restart, please wait. ",
         )
     except Exception as notice_exc:
         notice_error = notice_exc
-        log.warning("发送启动通知失败: %s", notice_exc)
+        log.warning("Failed to send startup notification: %s", notice_exc)
     try:
-        # 使用 DEVNULL 避免继承当前 stdout/stderr，防止父进程退出导致 start.sh 写入管道时触发 BrokenPipe。
-        proc = subprocess.Popen(
+        # Use DEVNULL to avoid inheriting the current stdout/stderr and prevent the parent process from exiting and causing start.sh BrokenPipe is triggered when writing to the pipe.
+        proc=subprocess.Popen(
             ["/bin/bash", str(start_script)],
             cwd=str(ROOT_DIR),
             env=env,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
         )
-        log.info("已触发 start.sh 进行重启，pid=%s", proc.pid if proc else "-")
+        log.info("start triggered.sh Restart, pid=%s", proc.pid if proc else "-")
     except Exception as exc:
-        log.error("执行 ./start.sh 失败: %s", exc)
+        log.error("implement ./start.sh Failure: %s", exc)
         async with lock:
             _restart_in_progress = False
         try:
-            await bot.send_message(chat_id=chat_id, text=f"执行 ./start.sh 失败：{exc}")
+            await bot.send_message(chat_id=chat_id, text=f"implement ./start.sh Failure: {exc}")
         except Exception as send_exc:
-            log.error("发送重启失败通知时出错: %s", send_exc)
+            log.error("Error sending restart failure notification: %s", send_exc)
         return
     else:
         if notice_error:
-            log.warning("启动通知未送达，已继续执行 start.sh")
+            log.warning("The startup notification was not delivered and execution of start has continued..sh")
         async with lock:
             _restart_in_progress = False
-            log.debug("重启执行中，已提前重置状态标记")
+            log.debug("Restart execution, status flag has been reset in advance")
 
 
 @router.message(Command("restart"))
 async def cmd_restart(message: Message) -> None:
-    """处理 /restart 命令，触发 master 重启。"""
+    """Process the /restart command to trigger a master restart. """
 
     _log_update(message)
     await _process_restart_request(message)
@@ -2047,16 +2315,17 @@ async def _send_projects_overview_to_chat(
     manager: MasterManager,
     reply_to_message_id: Optional[int] = None,
 ) -> None:
-    """向指定聊天发送项目概览及操作按钮。"""
+    """Send project overview and action buttons to the specified chat. """
 
+    await _maybe_notify_update(bot, chat_id)
     manager.refresh_state()
     try:
         text, markup = _projects_overview(manager)
     except Exception as exc:
-        log.exception("生成项目概览失败: %s", exc)
+        log.exception("Failed to generate project overview: %s", exc)
         await bot.send_message(
             chat_id=chat_id,
-            text="项目列表生成失败，请稍后再试。",
+            text="Project list generation failed, please try again later. ",
             reply_to_message_id=reply_to_message_id,
         )
         return
@@ -2068,28 +2337,28 @@ async def _send_projects_overview_to_chat(
             reply_to_message_id=reply_to_message_id,
         )
     except TelegramBadRequest as exc:
-        log.error("发送项目概览失败: %s", exc)
+        log.error("Failed to send project overview: %s", exc)
         await bot.send_message(
             chat_id=chat_id,
             text=text,
             reply_to_message_id=reply_to_message_id,
         )
     except Exception as exc:
-        log.exception("发送项目概览触发异常: %s", exc)
+        log.exception("Sending project overview triggers exception: %s", exc)
         await bot.send_message(
             chat_id=chat_id,
             text=text,
             reply_to_message_id=reply_to_message_id,
         )
     else:
-        log.info("已发送项目概览，按钮=%s", "无" if markup is None else "有")
+        log.info("Project overview sent, button=%s", "None" if markup is None else "yes")
 
 
 async def _refresh_project_overview(
     message: Optional[Message],
     manager: MasterManager,
 ) -> None:
-    """在原消息上刷新项目概览，无法编辑时发送新消息。"""
+    """Refresh the project overview on the original message and send a new message if editing is not possible. """
 
     if message is None:
         return
@@ -2097,26 +2366,26 @@ async def _refresh_project_overview(
     try:
         text, markup = _projects_overview(manager)
     except Exception as exc:
-        log.exception("刷新项目概览失败: %s", exc)
+        log.exception("Failed to refresh project overview: %s", exc)
         return
     try:
         await message.edit_text(text, reply_markup=markup)
     except TelegramBadRequest as exc:
-        log.warning("编辑项目概览失败，将发送新消息: %s", exc)
+        log.warning("Failed to edit project overview, new message will be sent: %s", exc)
         try:
             await message.answer(text, reply_markup=markup)
         except Exception as send_exc:
-            log.exception("发送项目概览失败: %s", send_exc)
+            log.exception("Failed to send project overview: %s", send_exc)
 
 
 @router.message(Command("projects"))
 async def cmd_projects(message: Message) -> None:
-    """处理 /projects 命令，返回最新项目概览。"""
+    """Processes the /projects command, returning an overview of the latest projects. """
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
     await _send_projects_overview_to_chat(
         message.bot,
@@ -2126,14 +2395,35 @@ async def cmd_projects(message: Message) -> None:
     )
 
 
+@router.message(Command("upgrade"))
+async def cmd_upgrade(message: Message) -> None:
+    """Handle /upgrade command, trigger pipx upgrade and restart service. """
+
+    _log_update(message)
+    manager = await _ensure_manager()
+    if not manager.is_authorized(message.chat.id):
+        await message.answer("Not authorized.")
+        return
+
+    success, error = _trigger_upgrade_pipeline()
+    if success:
+        notice = (
+            "Triggered `pipx upgrade vibego && vibego stop && vibego start`.\n"
+            "The master will restart briefly during the upgrade process, please use /start to verify the status later. "
+        )
+        await message.answer(notice, parse_mode="Markdown")
+    else:
+        await message.answer(f"Failed to trigger upgrade command: {error}")
+
+
 async def _run_and_reply(message: Message, action: str, coro) -> None:
-    """执行异步操作并统一回复成功或失败提示。"""
+    """Perform asynchronous operations and uniformly reply with success or failure prompts. """
 
     try:
         result = await coro
     except Exception as exc:
-        log.error("%s 失败: %s", action, exc)
-        await message.answer(f"{action} 失败: {exc}")
+        log.error("%s Failure: %s", action, exc)
+        await message.answer(f"{action} Failure: {exc}")
     else:
         reply_text: str
         reply_markup: Optional[InlineKeyboardMarkup] = None
@@ -2142,26 +2432,26 @@ async def _run_and_reply(message: Message, action: str, coro) -> None:
             if len(result) > 1:
                 reply_markup = result[1]
         else:
-            reply_text = result if isinstance(result, str) else f"{action} 完成"
+            reply_text = result if isinstance(result, str) else f"{action} Complete"
         await message.answer(reply_text, reply_markup=_ensure_numbered_markup(reply_markup))
 
 
 @router.callback_query(F.data.startswith("project:"))
 async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
-    """处理项目管理相关的回调按钮。"""
+    """Handle callback buttons related to project management. """
 
     manager = await _ensure_manager()
     user_id = callback.from_user.id if callback.from_user else None
     if user_id is None or not manager.is_authorized(user_id):
-        await callback.answer("未授权。", show_alert=True)
+        await callback.answer("Not authorized.", show_alert=True)
         return
     data = callback.data or ""
-    # 跳过删除确认/取消，让专用处理器接管，避免误判为未知操作。
+    # Skip deletion confirmation/cancellation and let the dedicated processor take over to avoid misjudgment of unknown operations.
     if data.startswith("project:delete_confirm:") or data == "project:delete_cancel":
         raise SkipHandler()
     parts = data.split(":")
     if len(parts) < 3:
-        await callback.answer("无效操作", show_alert=True)
+        await callback.answer("Invalid operation", show_alert=True)
         return
     _, action, *rest = parts
     identifier = rest[0] if rest else "*"
@@ -2176,7 +2466,7 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         project_slug = "*"
 
     if action == "refresh":
-        # 刷新列表属于全局操作，不依赖具体项目 slug
+        # Refreshing the list is a global operation and does not depend on specific project slugs.
         if callback.message:
             _reload_manager_configs(manager)
             manager.refresh_state()
@@ -2194,23 +2484,23 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         else:
             cfg = manager.require_project_by_slug(project_slug)
     except ValueError:
-        await callback.answer("未知项目", show_alert=True)
+        await callback.answer("Unknown project", show_alert=True)
         return
 
-    # 关键：避免覆盖 aiogram 传入的 FSMContext，因此运行态单独保存在 project_runtime_state 中
+    # Key: Avoid overwriting the FSMContext passed in by aiogram, so the running state is saved separately in project_runtime_state
     project_runtime_state = _get_project_runtime_state(manager, cfg.project_slug) if cfg else None
     model_name_map = dict(SWITCHABLE_MODELS)
 
     if cfg:
         log.info(
-            "按钮操作请求: user=%s action=%s project=%s",
+            "Button operation request: user=%s action=%s project=%s",
             user_id,
             action,
             cfg.display_name,
             extra={"project": cfg.project_slug},
         )
     else:
-        log.info("按钮操作请求: user=%s action=%s 所有项目", user_id, action)
+        log.info("Button action request: user=%s action=%s all items", user_id, action)
 
     if action == "switch_all":
         builder = InlineKeyboardBuilder()
@@ -2223,25 +2513,25 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
             )
         builder.row(
             InlineKeyboardButton(
-                text="⬅️ 取消",
+                text="⬅️ Cancel",
                 callback_data="project:refresh:*",
             )
         )
         await callback.answer()
         await callback.message.answer(
-            "请选择全局模型：",
+            "Please select a global model:",
             reply_markup=_ensure_numbered_markup(builder.as_markup()),
         )
         return
 
     if action == "manage":
         if cfg is None or callback.message is None:
-            await callback.answer("未知项目", show_alert=True)
+            await callback.answer("Unknown project", show_alert=True)
             return
         builder = InlineKeyboardBuilder()
         builder.row(
             InlineKeyboardButton(
-                text="📝 编辑",
+                text="📝 edit",
                 callback_data=f"project:edit:{cfg.project_slug}",
             )
         )
@@ -2252,19 +2542,19 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         current_model_label = model_name_map.get(current_model_key, current_model_value or current_model_key or "-")
         builder.row(
             InlineKeyboardButton(
-                text=f"🧠 切换模型（当前模型 {current_model_label}）",
+                text=f"🧠 Switch model (current model {current_model_label})",
                 callback_data=f"project:switch_prompt:{cfg.project_slug}",
             )
         )
         builder.row(
             InlineKeyboardButton(
-                text="🗑 删除",
+                text="🗑 delete",
                 callback_data=f"project:delete:{cfg.project_slug}",
             )
         )
         builder.row(
             InlineKeyboardButton(
-                text="⬅️ 返回项目列表",
+                text="⬅️ Return to project list",
                 callback_data="project:refresh:*",
             )
         )
@@ -2272,30 +2562,30 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         _ensure_numbered_markup(markup)
         await callback.answer()
         await callback.message.answer(
-            f"项目 {cfg.display_name} 的管理操作：",
+            f"Project {cfg.display_name} management options:",
             reply_markup=markup,
         )
         return
 
     if action == "switch_prompt":
         if cfg is None or callback.message is None:
-            await callback.answer("未知项目", show_alert=True)
+            await callback.answer("Unknown project", show_alert=True)
             return
         current_model = (
             project_runtime_state.model if project_runtime_state else cfg.default_model
         ).lower()
         builder = InlineKeyboardBuilder()
         for value, label in SWITCHABLE_MODELS:
-            prefix = "✅ " if current_model == value else ""
-            builder.row(
-                InlineKeyboardButton(
-                    text=f"{prefix}{label}",
-                    callback_data=f"project:switch_to:{value}:{cfg.project_slug}",
-                )
+            prefix = "[active] " if current_model == value else ""
+        builder.row(
+            InlineKeyboardButton(
+                text=f"{prefix}{label}",
+                callback_data=f"project:switch_to:{value}:{cfg.project_slug}",
             )
+        )
         builder.row(
             InlineKeyboardButton(
-                text="⬅️ 返回项目列表",
+                text="⬅️ Return to project list",
                 callback_data="project:refresh:*",
             )
         )
@@ -2303,21 +2593,21 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         _ensure_numbered_markup(markup)
         await callback.answer()
         await callback.message.answer(
-            f"请选择 {cfg.display_name} 要使用的模型：",
+            f"Select a model for {cfg.display_name}:",
             reply_markup=markup,
         )
         return
 
     if action == "edit":
         if cfg is None:
-            await callback.answer("未知项目", show_alert=True)
+            await callback.answer("Unknown project", show_alert=True)
             return
         await _start_project_edit(callback, cfg, manager)
         return
 
     if action == "delete":
         if cfg is None:
-            await callback.answer("未知项目", show_alert=True)
+            await callback.answer("Unknown project", show_alert=True)
             return
         await _start_project_delete(callback, cfg, manager, state)
         return
@@ -2327,31 +2617,31 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         return
 
     if action == "restart_master":
-        await callback.answer("已收到重启指令")
+        await callback.answer("Restart command received")
 
     try:
         if action == "stop_all":
             await manager.stop_all(update_state=True)
-            log.info("按钮操作成功: user=%s 停止全部项目", user_id)
+            log.info("Button operation successful: user=%s Stop all projects", user_id)
         elif action == "start_all":
-            # 为所有项目自动记录启动者的 chat_id
+            # Automatically record the initiator's chat_id for all projects
             if callback.message and callback.message.chat:
                 for project_cfg in manager.configs:
                     current_state = manager.state_store.data.get(project_cfg.project_slug)
                     if not current_state or not current_state.chat_id:
                         manager.update_chat_id(project_cfg.project_slug, callback.message.chat.id)
                         log.info(
-                            "自动记录 chat_id: project=%s, chat_id=%s",
+                            "Automatically record chat_id: project=%s, chat_id=%s",
                             project_cfg.project_slug,
                             callback.message.chat.id,
                             extra={"project": project_cfg.project_slug, "chat_id": callback.message.chat.id},
                         )
             await manager.run_all()
-            log.info("按钮操作成功: user=%s 启动全部项目", user_id)
-            await callback.answer("全部项目已启动，正在刷新列表…")
+            log.info("Button operation successful: user=%s Start all projects", user_id)
+            await callback.answer("All projects have been started and the list is being refreshed...")
         elif action == "restart_master":
             if callback.message is None:
-                log.error("重启按钮回调缺少 message 对象", extra={"user": user_id})
+                log.error("Restart button callback is missing message object", extra={"user": user_id})
                 return
             _log_update(callback.message, override_user=callback.from_user)
             await _process_restart_request(
@@ -2359,44 +2649,44 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
                 trigger_user=callback.from_user,
                 manager=manager,
             )
-            log.info("按钮操作成功: user=%s 重启 master", user_id)
-            return  # 重启后不刷新项目列表，避免产生额外噪音
+            log.info("Button operation successful: user=%s Restart master", user_id)
+            return  # Do not refresh the project list after restarting to avoid additional noise
         elif action == "run":
-            # 自动记录启动者的 chat_id
+            # Automatically record the chat_id of the initiator
             if callback.message and callback.message.chat:
                 current_state = manager.state_store.data.get(cfg.project_slug)
                 if not current_state or not current_state.chat_id:
                     manager.update_chat_id(cfg.project_slug, callback.message.chat.id)
                     log.info(
-                        "自动记录 chat_id: project=%s, chat_id=%s",
+                        "Automatically record chat_id: project=%s, chat_id=%s",
                         cfg.project_slug,
                         callback.message.chat.id,
                         extra={"project": cfg.project_slug, "chat_id": callback.message.chat.id},
                     )
             chosen = await manager.run_worker(cfg)
             log.info(
-                "按钮操作成功: user=%s 启动 %s (model=%s)",
+                "Button operation successful: user=%s starts %s (model=%s)",
                 user_id,
                 cfg.display_name,
                 chosen,
                 extra={"project": cfg.project_slug, "model": chosen},
             )
-            await callback.answer("项目已启动，正在刷新列表…")
+            await callback.answer("The project has been started, refreshing the list...")
         elif action == "stop":
             await manager.stop_worker(cfg)
             log.info(
-                "按钮操作成功: user=%s 停止 %s",
+                "Button operation successful: user=%s Stop %s",
                 user_id,
                 cfg.display_name,
                 extra={"project": cfg.project_slug},
             )
-            await callback.answer("项目已停止，正在刷新列表…")
+            await callback.answer("The project has been stopped, refreshing the list...")
         elif action == "switch_all_to":
             model_map = dict(SWITCHABLE_MODELS)
             if target_model not in model_map:
-                await callback.answer("不支持的模型", show_alert=True)
+                await callback.answer("Unsupported model", show_alert=True)
                 return
-            await callback.answer("全局切换中，请稍候…")
+            await callback.answer("Global switching, please wait...")
             errors: list[tuple[str, str]] = []
             updated: list[str] = []
             for project_cfg in manager.configs:
@@ -2412,18 +2702,18 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
             if errors:
                 failure_lines = "\n".join(f"- {name}: {err}" for name, err in errors)
                 message_text = (
-                    f"已尝试将全部项目模型切换为 {label}，但部分项目执行失败：\n{failure_lines}"
+                    f"An attempt was made to switch all project models to {label}, but execution failed for some projects:\n{failure_lines}"
                 )
                 log.warning(
-                    "全局模型切换部分失败: user=%s model=%s failures=%s",
+                    "Global model switching partial failure: user=%s model=%s failures=%s",
                     user_id,
                     target_model,
                     [name for name, _ in errors],
                 )
             else:
-                message_text = f"所有项目模型已切换为 {label}，并保持停止状态。"
+                message_text = f"All project models have been switched to {label} and remain stopped. "
                 log.info(
-                    "按钮操作成功: user=%s 全部切换模型至 %s",
+                    "Button operation successful: user=%s Switch all models to %s",
                     user_id,
                     target_model,
                 )
@@ -2431,17 +2721,17 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
         elif action == "switch_to":
             model_map = dict(SWITCHABLE_MODELS)
             if target_model not in model_map:
-                await callback.answer("不支持的模型", show_alert=True)
+                await callback.answer("Unsupported model", show_alert=True)
                 return
             state = manager.state_store.data.get(cfg.project_slug)
             previous_model = state.model if state else cfg.default_model
             was_running = bool(state and state.status == "running")
-            # 自动记录 chat_id（如果还没有的话）
+            # Automatically record chat_id if not already available
             if callback.message and callback.message.chat:
                 if not state or not state.chat_id:
                     manager.update_chat_id(cfg.project_slug, callback.message.chat.id)
                     log.info(
-                        "模型切换时自动记录 chat_id: project=%s, chat_id=%s",
+                        "Automatically record chat_id when switching models: project=%s, chat_id=%s",
                         cfg.project_slug,
                         callback.message.chat.id,
                         extra={"project": cfg.project_slug, "chat_id": callback.message.chat.id},
@@ -2461,44 +2751,44 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
                         await manager.run_worker(cfg, model=previous_model)
                     except Exception as restore_exc:
                         log.error(
-                            "模型切换失败且恢复失败: %s",
+                            "Model switch failed and recovery failed: %s",
                             restore_exc,
                             extra={"project": cfg.project_slug, "model": previous_model},
                         )
                 raise
             else:
                 if was_running:
-                    await callback.answer(f"已切换至 {model_map.get(chosen, chosen)}")
+                    await callback.answer(f"Switched to {model_map.get(chosen, chosen)}")
                     log.info(
-                        "按钮操作成功: user=%s 将 %s 切换至 %s",
+                        "Button operation successful: user=%s switches %s to %s",
                         user_id,
                         cfg.display_name,
                         chosen,
                         extra={"project": cfg.project_slug, "model": chosen},
                     )
                 else:
-                    await callback.answer(f"默认模型已更新为 {model_map.get(chosen, chosen)}")
+                    await callback.answer(f"The default model has been updated to {model_map.get(chosen, chosen)}")
                     log.info(
-                        "按钮操作成功: user=%s 更新 %s 默认模型为 %s",
+                        "Button operation successful: user=%s updates %s and the default model is %s",
                         user_id,
                         cfg.display_name,
                         chosen,
                         extra={"project": cfg.project_slug, "model": chosen},
                     )
         else:
-            await callback.answer("未知操作", show_alert=True)
+            await callback.answer("Unknown operation", show_alert=True)
             return
     except Exception as exc:
         log.error(
-            "按钮操作失败: action=%s project=%s error=%s",
+            "Button operation failed: action=%s project=%s error=%s",
             action,
             (cfg.display_name if cfg else "*"),
             exc,
             extra={"project": cfg.project_slug if cfg else "*"},
         )
         if callback.message:
-            await callback.message.answer(f"操作失败: {exc}")
-        await callback.answer("操作失败", show_alert=True)
+            await callback.message.answer(f"Operation failed: {exc}")
+        await callback.answer("Operation failed", show_alert=True)
         return
 
     await _refresh_project_overview(callback.message, manager)
@@ -2506,16 +2796,16 @@ async def on_project_action(callback: CallbackQuery, state: FSMContext) -> None:
 
 @router.message(Command("run"))
 async def cmd_run(message: Message) -> None:
-    """处理 /run 命令，启动指定项目并可选切换模型。"""
+    """Processes the /run command, starting the specified project and optionally switching models. """
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
-    parts = message.text.split()
+    parts=message.text.split()
     if len(parts) < 2:
-        await message.answer("用法: /run <project> [model]")
+        await message.answer("Usage: /run <project> [model]")
         return
     project_raw = parts[1]
     model = parts[2] if len(parts) >= 3 else None
@@ -2526,26 +2816,26 @@ async def cmd_run(message: Message) -> None:
         return
 
     async def runner():
-        """调用 manager.run_worker 启动项目并返回提示文本。"""
+        """call manager.run_worker Start the project and return the prompt text. """
 
         chosen = await manager.run_worker(cfg, model=model)
-        return f"已启动 {cfg.display_name} (model={chosen})"
+        return f"Started {cfg.display_name} (model={chosen})"
 
-    await _run_and_reply(message, "启动", runner())
+    await _run_and_reply(message, "start up", runner())
 
 
 @router.message(Command("stop"))
 async def cmd_stop(message: Message) -> None:
-    """处理 /stop 命令，停止指定项目。"""
+    """Process the /stop command to stop the specified project. """
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
-    parts = message.text.split()
+    parts=message.text.split()
     if len(parts) < 2:
-        await message.answer("用法: /stop <project>")
+        await message.answer("Usage: /stop <project>")
         return
     project_raw = parts[1]
     try:
@@ -2555,26 +2845,26 @@ async def cmd_stop(message: Message) -> None:
         return
 
     async def stopper():
-        """停止指定项目并更新状态。"""
+        """Stops the specified project and updates the status. """
 
         await manager.stop_worker(cfg, update_state=True)
-        return f"已停止 {cfg.display_name}"
+        return f"Stopped {cfg.display_name}"
 
-    await _run_and_reply(message, "停止", stopper())
+    await _run_and_reply(message, "stop", stopper())
 
 
 @router.message(Command("switch"))
 async def cmd_switch(message: Message) -> None:
-    """处理 /switch 命令，停机后以新模型重启项目。"""
+    """Handle the /switch command and restart the project with the new model after shutdown. """
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
-    parts = message.text.split()
+    parts=message.text.split()
     if len(parts) < 3:
-        await message.answer("用法: /switch <project> <model>")
+        await message.answer("Usage: /switch <project> <model>")
         return
     project_raw, model = parts[1], parts[2]
     try:
@@ -2584,31 +2874,31 @@ async def cmd_switch(message: Message) -> None:
         return
 
     async def switcher():
-        """重新启动项目并切换到新的模型。"""
+        """Restart the project and switch to the new model. """
 
         await manager.stop_worker(cfg, update_state=True)
         chosen = await manager.run_worker(cfg, model=model)
-        return f"已切换 {cfg.display_name} 至 {chosen}"
+        return f"Switched {cfg.display_name} to {chosen}"
 
-    await _run_and_reply(message, "切换", switcher())
+    await _run_and_reply(message, "switch", switcher())
 
 
 @router.message(Command("authorize"))
 async def cmd_authorize(message: Message) -> None:
-    """处理 /authorize 命令，为项目登记 chat_id。"""
+    """Process the /authorize command to register the chat_id for the project. """
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
-    parts = message.text.split()
+    parts=message.text.split()
     if len(parts) < 3:
-        await message.answer("用法: /authorize <project> <chat_id>")
+        await message.answer("Usage: /authorize <project> <chat_id>")
         return
     project_raw, chat_raw = parts[1], parts[2]
     if not chat_raw.isdigit():
-        await message.answer("chat_id 需要是数字")
+        await message.answer("chat_id Needs to be a number")
         return
     chat_id = int(chat_raw)
     try:
@@ -2618,13 +2908,13 @@ async def cmd_authorize(message: Message) -> None:
         return
     manager.update_chat_id(cfg.project_slug, chat_id)
     await message.answer(
-        f"已记录 {cfg.display_name} 的 chat_id={chat_id}"
+        f"Logged {cfg.display_name} of chat_id={chat_id}"
     )
 
 
 @router.callback_query(F.data.startswith("project:wizard:skip:"))
 async def on_project_wizard_skip(callback: CallbackQuery) -> None:
-    """处理向导中的“跳过此项”按钮。"""
+    """Handle the "Skip this" button in the wizard. """
 
     if callback.message is None or callback.message.chat is None:
         return
@@ -2632,48 +2922,48 @@ async def on_project_wizard_skip(callback: CallbackQuery) -> None:
     async with PROJECT_WIZARD_LOCK:
         session = PROJECT_WIZARD_SESSIONS.get(chat_id)
     if session is None:
-        await callback.answer("当前没有进行中的项目流程。", show_alert=True)
+        await callback.answer("There are currently no ongoing project processes. ", show_alert=True)
         return
     if session.step_index >= len(session.fields):
-        await callback.answer("当前流程已结束。", show_alert=True)
+        await callback.answer("The current process has ended. ", show_alert=True)
         return
     _, _, field = callback.data.partition("project:wizard:skip:")
     current_field = session.fields[session.step_index]
     if field != current_field:
-        await callback.answer("当前步骤已变更，请按最新提示操作。", show_alert=True)
+        await callback.answer("The current steps have been changed, please follow the latest prompts. ", show_alert=True)
         return
     manager = await _ensure_manager()
-    await callback.answer("已跳过")
+    await callback.answer("skipped")
     await _advance_wizard_session(
         session,
         manager,
         callback.message,
         "",
-        prefix="已跳过 ✅",
+        prefix="skipped ✅",
     )
 
 
 @router.message(F.text.func(_is_projects_menu_trigger))
 async def on_master_projects_button(message: Message) -> None:
-    """处理常驻键盘触发的项目概览请求。"""
+    """Handle project overview requests triggered by resident keyboard. """
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
     requested_text = message.text or ""
     reply_to_message_id: Optional[int] = message.message_id
     if not _text_equals_master_button(requested_text):
         log.info(
-            "收到旧版项目列表按钮，准备刷新聊天键盘",
+            "Received an outdated project list button; refreshing the chat keyboard.",
             extra={"text": requested_text, "chat_id": message.chat.id},
         )
         await message.answer(
-            "主菜单按钮已更新为“📂 项目列表”，当前会话已同步最新文案。",
+            'The main menu button is now "📂 Project List"; the session text has been synchronised.',
             reply_markup=_build_master_main_keyboard(),
             reply_to_message_id=reply_to_message_id,
         )
-        # 已推送最新键盘，后续回复无需继续引用原消息，避免重复引用提示
+        # The latest keyboard has been pushed. There is no need to continue to quote the original message in subsequent replies to avoid repeated citation prompts.
         reply_to_message_id = None
     await _send_projects_overview_to_chat(
         message.bot,
@@ -2685,14 +2975,14 @@ async def on_master_projects_button(message: Message) -> None:
 
 @router.message(F.text.in_(MASTER_MANAGE_BUTTON_ALLOWED_TEXTS))
 async def on_master_manage_button(message: Message) -> None:
-    """处理常驻键盘的项目管理入口。"""
+    """Handle the project management entry for the resident keyboard. """
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
     builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text="➕ 新增项目", callback_data="project:create:*"))
+    builder.row(InlineKeyboardButton(text="➕ New project", callback_data="project:create:*"))
     model_name_map = dict(SWITCHABLE_MODELS)
     for cfg in manager.configs:
         state = manager.state_store.data.get(cfg.project_slug)
@@ -2701,42 +2991,42 @@ async def on_master_manage_button(message: Message) -> None:
         current_model_label = model_name_map.get(current_model_key, current_model_value or current_model_key or "-")
         builder.row(
             InlineKeyboardButton(
-                text=f"⚙️ 管理 {cfg.display_name}",
+                text=f"⚙️ Manage {cfg.display_name}",
                 callback_data=f"project:manage:{cfg.project_slug}",
             ),
             InlineKeyboardButton(
-                text=f"🧠 切换模型（当前模型 {current_model_label}）",
+                text=f"🧠 Switch model (current model {current_model_label})",
                 callback_data=f"project:switch_prompt:{cfg.project_slug}",
             ),
         )
     builder.row(
         InlineKeyboardButton(
-            text="🔁 全部切换模型",
+            text="🔁 Switch all models",
             callback_data="project:switch_all:*",
         )
     )
-    builder.row(InlineKeyboardButton(text="📂 返回列表", callback_data="project:refresh:*"))
+    builder.row(InlineKeyboardButton(text="📂 Return to list", callback_data="project:refresh:*"))
     markup = builder.as_markup()
     _ensure_numbered_markup(markup)
     await message.answer(
-        "请选择要管理的项目，或点击“➕ 新增项目”创建新的 worker。",
+        'Select a project to manage, or tap "➕ New project" to create a new worker.',
         reply_markup=markup,
     )
 
 
 @router.message()
 async def cmd_fallback(message: Message) -> None:
-    """兜底处理器：尝试继续向导，否则提示可用命令。"""
+    """Fallback handler: resume the wizard when possible; otherwise prompt for the available commands."""
 
     _log_update(message)
     manager = await _ensure_manager()
     if not manager.is_authorized(message.chat.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
     handled = await _handle_wizard_message(message, manager)
     if handled:
         return
-    await message.answer("未识别的命令，请使用 /projects /run /stop /switch /authorize。")
+    await message.answer("Unrecognized command, please use /projects /run /stop /switch /authorize. ")
 
 
 
@@ -2747,15 +3037,15 @@ def _delete_project_with_fallback(
     original_slug: str,
     bot_name: str,
 ) -> Tuple[Optional[Exception], List[Tuple[str, Exception]]]:
-    """尝试以多种标识删除项目，提升大小写与别名兼容性。"""
+    """Try deleting items with multiple identifiers to improve case and alias compatibility. """
 
     attempts: List[Tuple[str, Exception]] = []
 
     def _attempt(candidate: str) -> Optional[Exception]:
-        """实际执行删除，失败返回异常供后续兜底。"""
+        """The deletion is actually executed, and an exception is returned on failure for subsequent clarification. """
         slug = (candidate or "").strip()
         if not slug:
-            return ValueError("slug 为空")
+            return ValueError("slug is empty")
         try:
             repository.delete_project(slug)
         except ValueError as delete_exc:
@@ -2792,29 +3082,29 @@ def _delete_project_with_fallback(
 
 @router.callback_query(F.data.startswith("project:delete_confirm:"))
 async def on_project_delete_confirm(callback: CallbackQuery, state: FSMContext) -> None:
-    """处理删除确认按钮的回调逻辑。"""
+    """Handle the callback logic for deleting the confirmation button. """
     manager = await _ensure_manager()
     user_id = callback.from_user.id if callback.from_user else None
     if user_id is None or not manager.is_authorized(user_id):
-        await callback.answer("未授权。", show_alert=True)
+        await callback.answer("Not authorized.", show_alert=True)
         return
     if callback.message is None:
-        await callback.answer("无效操作", show_alert=True)
+        await callback.answer("Invalid operation", show_alert=True)
         return
     parts = callback.data.split(":", 2)
     if len(parts) != 3:
-        await callback.answer("无效操作", show_alert=True)
+        await callback.answer("Invalid operation", show_alert=True)
         return
     target_slug = parts[2]
     log.info(
-        "删除确认回调: user=%s slug=%s",
+        "Delete confirmation callback: user=%s slug=%s",
         user_id,
         target_slug,
         extra={"project": target_slug},
     )
     current_state = await state.get_state()
     if current_state != ProjectDeleteStates.confirming.state:
-        await callback.answer("确认流程已过期，请重新发起删除。", show_alert=True)
+        await callback.answer("The confirmation process has expired, please initiate the deletion again. ", show_alert=True)
         return
     data = await state.get_data()
     stored_slug = str(data.get("project_slug", "")).strip()
@@ -2824,11 +3114,11 @@ async def on_project_delete_confirm(callback: CallbackQuery, state: FSMContext)
             await callback.message.edit_reply_markup(reply_markup=None)
         except TelegramBadRequest:
             pass
-        await callback.answer("确认信息已失效，请重新发起删除。", show_alert=True)
+        await callback.answer("The confirmation information has expired, please initiate deletion again. ", show_alert=True)
         return
     initiator_id = data.get("initiator_id")
     if initiator_id and initiator_id != user_id:
-        await callback.answer("仅流程发起者可以确认删除。", show_alert=True)
+        await callback.answer("Only the process initiator can confirm the deletion. ", show_alert=True)
         return
     expires_at = float(data.get("expires_at") or 0)
     if expires_at and time.time() > expires_at:
@@ -2837,7 +3127,7 @@ async def on_project_delete_confirm(callback: CallbackQuery, state: FSMContext)
             await callback.message.edit_reply_markup(reply_markup=None)
         except TelegramBadRequest:
             pass
-        await callback.answer("确认已超时，请重新发起删除。", show_alert=True)
+        await callback.answer("The confirmation has timed out, please initiate deletion again. ", show_alert=True)
         return
     repository = _ensure_repository()
     original_slug = str(data.get("original_slug") or "").strip()
@@ -2850,15 +3140,15 @@ async def on_project_delete_confirm(callback: CallbackQuery, state: FSMContext)
     )
     if error is not None:
         log.error(
-            "删除项目失败: %s",
+            "Failed to delete item: %s",
             error,
             extra={
                 "slug": stored_slug,
                 "attempts": [slug for slug, _ in attempts],
             },
         )
-        await callback.answer("删除失败，请稍后重试。", show_alert=True)
-        await callback.message.answer(f"删除失败：{error}")
+        await callback.answer("Deletion failed, please try again later. ", show_alert=True)
+        await callback.message.answer(f"Delete failed: {error}")
         return
     await state.clear()
     try:
@@ -2867,35 +3157,35 @@ async def on_project_delete_confirm(callback: CallbackQuery, state: FSMContext)
         pass
     _reload_manager_configs(manager)
     display_name = data.get("display_name") or stored_slug
-    await callback.answer("项目已删除")
-    await callback.message.answer(f"项目 {display_name} 已删除 ✅")
+    await callback.answer("Project deleted.")
+    await callback.message.answer(f"Project {display_name} deleted ✅")
     await _send_projects_overview_to_chat(callback.message.bot, callback.message.chat.id, manager)
 
 
 @router.callback_query(F.data == "project:delete_cancel")
 async def on_project_delete_cancel(callback: CallbackQuery, state: FSMContext) -> None:
-    """处理删除流程的取消按钮。"""
+    """Cancel button that handles the deletion process. """
     manager = await _ensure_manager()
     user_id = callback.from_user.id if callback.from_user else None
     if user_id is None or not manager.is_authorized(user_id):
-        await callback.answer("未授权。", show_alert=True)
+        await callback.answer("Not authorized.", show_alert=True)
         return
     if callback.message is None:
-        await callback.answer("无效操作", show_alert=True)
+        await callback.answer("Invalid operation", show_alert=True)
         return
     current_state = await state.get_state()
     if current_state != ProjectDeleteStates.confirming.state:
-        await callback.answer("当前没有待确认的删除流程。", show_alert=True)
+        await callback.answer("There are currently no pending deletion processes. ", show_alert=True)
         return
     data = await state.get_data()
     log.info(
-        "删除取消回调: user=%s slug=%s",
+        "Delete cancellation callback: user=%s slug=%s",
         user_id,
         data.get("project_slug"),
     )
     initiator_id = data.get("initiator_id")
     if initiator_id and initiator_id != user_id:
-        await callback.answer("仅流程发起者可以取消删除。", show_alert=True)
+        await callback.answer("Only the process initiator can cancel the deletion. ", show_alert=True)
         return
     expires_at = float(data.get("expires_at") or 0)
     if expires_at and time.time() > expires_at:
@@ -2904,7 +3194,7 @@ async def on_project_delete_cancel(callback: CallbackQuery, state: FSMContext) -
             await callback.message.edit_reply_markup(reply_markup=None)
         except TelegramBadRequest:
             pass
-        await callback.answer("确认已超时，请重新发起删除。", show_alert=True)
+        await callback.answer("The confirmation has timed out, please initiate deletion again. ", show_alert=True)
         return
     await state.clear()
     try:
@@ -2912,22 +3202,22 @@ async def on_project_delete_cancel(callback: CallbackQuery, state: FSMContext) -
     except TelegramBadRequest:
         pass
     display_name = data.get("display_name") or data.get("project_slug") or ""
-    await callback.answer("删除流程已取消")
-    await callback.message.answer(f"已取消删除项目 {display_name}。")
+    await callback.answer("Deletion cancelled.")
+    await callback.message.answer(f"Deletion cancelled for project {display_name}.")
 
 
 @router.message(ProjectDeleteStates.confirming)
 async def on_project_delete_text(message: Message, state: FSMContext) -> None:
-    """兼容旧版交互，允许通过文本指令确认或取消删除。"""
+    """Compatible with older interactions, allowing text commands to confirm or cancel deletion. """
     manager = await _ensure_manager()
-    user = message.from_user
+    user=message.from_user
     if user is None or not manager.is_authorized(user.id):
-        await message.answer("未授权。")
+        await message.answer("Not authorized.")
         return
     data = await state.get_data()
     initiator_id = data.get("initiator_id")
     if initiator_id and initiator_id != user.id:
-        await message.answer("仅流程发起者可以继续此删除流程。")
+        await message.answer("Only the process initiator can proceed with this deletion process. ")
         return
     expires_at = float(data.get("expires_at") or 0)
     if expires_at and time.time() > expires_at:
@@ -2938,18 +3228,18 @@ async def on_project_delete_text(message: Message, state: FSMContext) -> None:
                 await prompt.edit_reply_markup(reply_markup=None)
             except TelegramBadRequest:
                 pass
-        await message.answer("确认已超时，请重新发起删除。")
+        await message.answer("The confirmation has timed out, please initiate deletion again. ")
         return
 
     raw_text = (message.text or "").strip()
     if not raw_text:
-        await message.answer("请使用按钮或输入“确认删除”/“取消”完成操作。")
+        await message.answer('Use the buttons or type "Confirm deletion" / "Cancel" to finish the operation.')
         return
     normalized = raw_text.casefold().strip()
-    normalized = normalized.rstrip("。.!？?")
+    normalized = normalized.rstrip("..!??")
     normalized_compact = normalized.replace(" ", "")
-    confirm_tokens = {"确认删除", "确认", "confirm", "y", "yes"}
-    cancel_tokens = {"取消", "cancel", "n", "no"}
+    confirm_tokens = {"confirm deletion", "confirm", "y", "yes"}
+    cancel_tokens = {"cancel", "n", "no"}
 
     if normalized in cancel_tokens or normalized_compact in cancel_tokens:
         await state.clear()
@@ -2960,21 +3250,21 @@ async def on_project_delete_text(message: Message, state: FSMContext) -> None:
             except TelegramBadRequest:
                 pass
         display_name = data.get("display_name") or data.get("project_slug") or ""
-        await message.answer(f"已取消删除项目 {display_name}。")
+        await message.answer(f"Deletion cancelled for project {display_name}.")
         return
 
     if not (
         normalized in confirm_tokens
         or normalized_compact in confirm_tokens
-        or normalized.startswith("确认删除")
+        or normalized.startswith("Confirm deletion")
     ):
-        await message.answer("请输入“确认删除”或通过按钮完成操作。")
+        await message.answer('Type "Confirm deletion" or use the buttons to finish the operation.')
         return
 
     stored_slug = str(data.get("project_slug", "")).strip()
     if not stored_slug:
         await state.clear()
-        await message.answer("删除流程状态异常，请重新发起删除。")
+        await message.answer("The deletion process status is abnormal, please initiate deletion again. ")
         return
     original_slug = str(data.get("original_slug") or "").strip()
     bot_name = str(data.get("bot_name") or "").strip()
@@ -2987,14 +3277,14 @@ async def on_project_delete_text(message: Message, state: FSMContext) -> None:
     )
     if error is not None:
         log.error(
-            "删除项目失败(文本确认): %s",
+            "Failed to delete item (text confirmation): %s",
             error,
             extra={
                 "slug": stored_slug,
                 "attempts": [slug for slug, _ in attempts],
             },
         )
-        await message.answer(f"删除失败：{error}")
+        await message.answer(f"Delete failed: {error}")
         return
 
     await state.clear()
@@ -3006,34 +3296,34 @@ async def on_project_delete_text(message: Message, state: FSMContext) -> None:
             pass
     _reload_manager_configs(manager)
     display_name = data.get("display_name") or stored_slug
-    await message.answer(f"项目 {display_name} 已删除 ✅")
+    await message.answer(f"Item {display_name} deleted ✅")
     await _send_projects_overview_to_chat(message.bot, message.chat.id, manager)
 
 
 
 async def bootstrap_manager() -> MasterManager:
-    """初始化项目仓库、状态存储与 manager，启动前清理旧 worker。"""
+    """Initialize the project warehouse, state storage and manager, and clean up old workers before starting. """
 
     load_env()
-    tmux_prefix = os.environ.get("TMUX_SESSION_PREFIX", "vibe")
+    tmux_prefix=os.environ.get("TMUX_SESSION_PREFIX", "vibe")
     _kill_existing_tmux(tmux_prefix)
     try:
         repository = ProjectRepository(CONFIG_DB_PATH, CONFIG_PATH)
     except Exception as exc:
-        log.error("初始化项目仓库失败: %s", exc)
+        log.error("Failed to initialize project repository: %s", exc)
         sys.exit(1)
 
     records = repository.list_projects()
     if not records:
-        log.warning("项目配置为空，将以空项目列表启动。")
+        log.warning("The project configuration is empty and will start with an empty project list. ")
 
-    configs = [ProjectConfig.from_dict(record.to_dict()) for record in records]
+    configs= [ProjectConfig.from_dict(record.to_dict()) for record in records]
 
     state_store = StateStore(STATE_PATH, {cfg.project_slug: cfg for cfg in configs})
     manager = MasterManager(configs, state_store=state_store)
 
     await manager.stop_all(update_state=True)
-    log.info("已清理历史 tmux 会话，worker 需手动启动。")
+    log.info("The historical tmux session has been cleared, and the worker needs to be started manually. ")
 
     global MANAGER
     global PROJECT_REPOSITORY
@@ -3043,13 +3333,13 @@ async def bootstrap_manager() -> MasterManager:
 
 
 async def main() -> None:
-    """master.py 的异步入口，完成 bot 启动与调度器绑定。"""
+    """master.py The asynchronous entry completes the bot startup and binding to the scheduler. """
 
     manager = await bootstrap_manager()
 
-    # 诊断日志：记录重启信号文件路径，便于排查问题
+    # Diagnosis log: record the restart signal file path to facilitate troubleshooting
     log.info(
-        "重启信号文件路径: %s (存在: %s)",
+        "Restart signal file path: %s (Exists: %s)",
         RESTART_SIGNAL_PATH,
         RESTART_SIGNAL_PATH.exists(),
         extra={
@@ -3061,7 +3351,7 @@ async def main() -> None:
 
     master_token = os.environ.get("MASTER_BOT_TOKEN")
     if not master_token:
-        log.error("MASTER_BOT_TOKEN 未设置")
+        log.error("MASTER_BOT_TOKEN not set")
         sys.exit(1)
 
     proxy_url, proxy_auth, _ = _detect_proxy()
@@ -3081,10 +3371,11 @@ async def main() -> None:
     dp.include_router(router)
     dp.startup.register(_notify_restart_success)
 
-    log.info("Master 已启动，监听管理员指令。")
+    log.info("Master Started, listening for administrator commands. ")
     await _ensure_master_menu_button(bot)
     await _ensure_master_commands(bot)
     await _broadcast_master_keyboard(bot, manager)
+    asyncio.create_task(_periodic_update_check(bot))
     await dp.start_polling(bot)
 
 
@@ -3093,4 +3384,4 @@ if __name__ == "__main__":
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        log.info("Master 停止")
+        log.info("Master stop")