vibego 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

bot.py

@@ -219,7 +219,7 @@ SEND_RETRY_BASE_DELAY = float(os.environ.get("SEND_RETRY_BASE_DELAY", "0.5"))
 SEND_FAILURE_NOTICE_COOLDOWN = float(os.environ.get("SEND_FAILURE_NOTICE_COOLDOWN", "30"))
 SESSION_INITIAL_BACKTRACK_BYTES = int(os.environ.get("SESSION_INITIAL_BACKTRACK_BYTES", "16384"))
 ENABLE_PLAN_PROGRESS = (os.environ.get("ENABLE_PLAN_PROGRESS", "1").strip().lower() not in {"0", "false", "no", "off"})
-AUTO_COMPACT_THRESHOLD = max(_env_int("AUTO_COMPACT_THRESHOLD", 10), 0)
+AUTO_COMPACT_THRESHOLD = max(_env_int("AUTO_COMPACT_THRESHOLD", 0), 0)
 
 PLAN_STATUS_LABELS = {
     "completed": "✅",
@@ -967,6 +967,9 @@ async def _dispatch_prompt_to_model(
                 return True, session_path
             await asyncio.sleep(0.3)
 
+    # 中断旧的延迟轮询（如果存在）
+    await _interrupt_long_poll(chat_id)
+
     watcher_task = asyncio.create_task(
         _watch_and_notify(
             chat_id,
@@ -1200,6 +1203,118 @@ def _resolve_worker_target_chat_ids() -> List[int]:
     return sorted(targets)
 
 
+def _auto_record_chat_id(chat_id: int) -> None:
+    """首次收到消息时自动将 chat_id 记录到 state 文件。
+
+    仅在以下条件同时满足时写入：
+    1. STATE_FILE 环境变量已配置
+    2. state 文件存在
+    3. 当前项目在 state 中的 chat_id 为空
+    """
+    state_file_env = os.environ.get("STATE_FILE")
+    if not state_file_env:
+        return
+
+    state_path = Path(state_file_env).expanduser()
+    if not state_path.exists():
+        worker_log.debug(
+            "STATE_FILE 不存在，跳过自动记录 chat_id",
+            extra={**_session_extra(), "path": str(state_path)},
+        )
+        return
+
+    # 使用文件锁保证并发安全
+    lock_path = state_path.with_suffix(state_path.suffix + ".lock")
+    import fcntl
+
+    try:
+        with open(lock_path, "w", encoding="utf-8") as lock_file:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+
+            try:
+                # 读取当前 state
+                raw_state = json.loads(state_path.read_text(encoding="utf-8"))
+                if not isinstance(raw_state, dict):
+                    worker_log.warning(
+                        "STATE_FILE 格式异常，跳过自动记录",
+                        extra=_session_extra(),
+                    )
+                    return
+
+                # 检查当前项目的 chat_id
+                project_key = PROJECT_SLUG or PROJECT_NAME
+                if not project_key:
+                    worker_log.warning(
+                        "PROJECT_SLUG 和 PROJECT_NAME 均未设置，跳过自动记录",
+                        extra=_session_extra(),
+                    )
+                    return
+
+                project_state = raw_state.get(project_key)
+                if not isinstance(project_state, dict):
+                    # 项目不存在，创建新条目
+                    raw_state[project_key] = {
+                        "chat_id": chat_id,
+                        "model": ACTIVE_MODEL or "codex",
+                        "status": "running",
+                    }
+                    need_write = True
+                elif project_state.get("chat_id") is None:
+                    # chat_id 为空，更新
+                    project_state["chat_id"] = chat_id
+                    need_write = True
+                else:
+                    # chat_id 已存在，无需更新
+                    need_write = False
+
+                if need_write:
+                    # 写入更新后的 state
+                    tmp_path = state_path.with_suffix(state_path.suffix + ".tmp")
+                    tmp_path.write_text(
+                        json.dumps(raw_state, ensure_ascii=False, indent=4),
+                        encoding="utf-8",
+                    )
+                    tmp_path.replace(state_path)
+                    worker_log.info(
+                        "已自动记录 chat_id=%s 到 state 文件",
+                        chat_id,
+                        extra={**_session_extra(), "project": project_key},
+                    )
+                else:
+                    worker_log.debug(
+                        "chat_id 已存在，跳过自动记录",
+                        extra={**_session_extra(), "existing_chat_id": project_state.get("chat_id")},
+                    )
+
+            except json.JSONDecodeError as exc:
+                worker_log.error(
+                    "STATE_FILE 解析失败，跳过自动记录：%s",
+                    exc,
+                    extra=_session_extra(),
+                )
+            except Exception as exc:
+                worker_log.error(
+                    "自动记录 chat_id 失败：%s",
+                    exc,
+                    extra={**_session_extra(), "chat": chat_id},
+                )
+            finally:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+    except Exception as exc:
+        worker_log.error(
+            "获取文件锁失败：%s",
+            exc,
+            extra=_session_extra(),
+        )
+    finally:
+        # 清理锁文件
+        try:
+            if lock_path.exists():
+                lock_path.unlink()
+        except Exception:
+            pass
+
+
 async def _broadcast_worker_keyboard(bot: Bot) -> None:
     """启动时主动推送菜单，确保 Telegram 键盘同步。"""
     targets = _resolve_worker_target_chat_ids()
@@ -2654,7 +2769,8 @@ def _build_summary_prompt(
 ) -> str:
     """构造模型摘要提示词，要求携带请求标识。"""
 
-    task_code = _format_task_command(task.id)
+    # 摘要提示词是发送给模型的，使用纯文本格式，不需要 Markdown 转义
+    task_code = f"/{task.id}" if task.id else "-"
     title = task.title or "-"
     status_label = STATUS_LABELS.get(task.status, task.status)
     note_lines: list[str] = []
@@ -2817,8 +2933,9 @@ def _build_task_history_view(
     if total_items == 0:
         raise ValueError("暂无事件记录")
 
+    # 历史记录会被包裹在代码块中显示，使用纯文本格式，不需要 Markdown 转义
     title_text = normalize_newlines(task.title or "").strip() or "-"
-    title_display = _escape_markdown_text(title_text) if _IS_MARKDOWN_V2 else title_text
+    title_display = title_text
 
     digit_width = len(str(max(total_items, 1)))
     placeholder_page = "9" * digit_width
@@ -3050,6 +3167,9 @@ CHAT_DELIVERED_HASHES: Dict[int, Dict[str, set[str]]] = {}
 CHAT_DELIVERED_OFFSETS: Dict[int, Dict[str, set[int]]] = {}
 CHAT_REPLY_COUNT: Dict[int, Dict[str, int]] = {}
 CHAT_COMPACT_STATE: Dict[int, Dict[str, Dict[str, Any]]] = {}
+# 长轮询状态：用于延迟轮询机制
+CHAT_LONG_POLL_STATE: Dict[int, Dict[str, Any]] = {}
+CHAT_LONG_POLL_LOCK: Optional[asyncio.Lock] = None  # 在事件循环启动后初始化
 SUMMARY_REQUEST_TIMEOUT_SECONDS = 300.0
 
 
@@ -3644,7 +3764,19 @@ def _get_delivered_offsets(chat_id: int, session_key: str) -> set[int]:
     return CHAT_DELIVERED_OFFSETS.setdefault(chat_id, {}).setdefault(session_key, set())
 
 
-async def _deliver_pending_messages(chat_id: int, session_path: Path) -> bool:
+async def _deliver_pending_messages(
+    chat_id: int,
+    session_path: Path,
+    *,
+    add_completion_header: bool = True
+) -> bool:
+    """发送待处理的模型消息。
+
+    Args:
+        chat_id: Telegram 聊天 ID
+        session_path: 会话文件路径
+        add_completion_header: 是否添加"✅模型执行完成"前缀（快速轮询阶段为 True，延迟轮询为 False）
+    """
     session_key = str(session_path)
     previous_offset = SESSION_OFFSETS.get(session_key, 0)
     new_offset, events = _read_session_events(session_path)
@@ -3719,7 +3851,8 @@ async def _deliver_pending_messages(chat_id: int, session_path: Path) -> bool:
             last_committed_offset = event_offset
             SESSION_OFFSETS[session_key] = event_offset
             continue
-        formatted_text = _prepend_completion_header(text_to_send)
+        # 根据轮询阶段决定是否添加完成前缀
+        formatted_text = _prepend_completion_header(text_to_send) if add_completion_header else text_to_send
         payload_for_hash = _prepare_model_payload(formatted_text)
         initial_hash = hashlib.sha256(payload_for_hash.encode("utf-8", errors="ignore")).hexdigest()
         if initial_hash in delivered_hashes:
@@ -3830,22 +3963,24 @@ async def _deliver_pending_messages(chat_id: int, session_path: Path) -> bool:
         SESSION_OFFSETS[session_key] = max(last_committed_offset, new_offset)
 
     if delivered_response:
+        # 实际发送了消息，返回 True 表示本次调用成功发送
+        # 这样可以确保延迟轮询机制被正确触发
         if ENABLE_PLAN_PROGRESS and plan_active:
             worker_log.info(
-                "模型输出已发送，但计划仍在更新，继续监听",
+                "模型输出已发送，但计划仍在更新",
+                extra={
+                    **_session_extra(path=session_path),
+                    "chat": chat_id,
+                },
+            )
+        else:
+            worker_log.info(
+                "模型输出已发送且计划完成",
                 extra={
                     **_session_extra(path=session_path),
                     "chat": chat_id,
                 },
             )
-            return False
-        worker_log.info(
-            "模型输出已发送且计划完成",
-            extra={
-                **_session_extra(path=session_path),
-                "chat": chat_id,
-            },
-        )
         return True
 
     if ENABLE_PLAN_PROGRESS and not plan_active and final_response_sent:
@@ -3992,6 +4127,9 @@ async def _ensure_session_watcher(chat_id: int) -> Optional[Path]:
     if watcher is not None and watcher.done():
         CHAT_WATCHERS.pop(chat_id, None)
 
+    # 中断旧的延迟轮询（如果存在）
+    await _interrupt_long_poll(chat_id)
+
     CHAT_WATCHERS[chat_id] = asyncio.create_task(
         _watch_and_notify(
             chat_id,
@@ -4151,23 +4289,181 @@ async def _finalize_plan_progress(chat_id: int) -> None:
 
 
 
+async def _interrupt_long_poll(chat_id: int) -> None:
+    """
+    中断指定 chat 的延迟轮询。
+
+    当用户发送新消息时调用，确保旧的延迟轮询被终止，
+    为新的监听任务让路。
+
+    线程安全：使用 asyncio.Lock 保护状态访问。
+    """
+    if CHAT_LONG_POLL_LOCK is None:
+        # 锁未初始化（测试环境或启动早期）
+        return
+
+    async with CHAT_LONG_POLL_LOCK:
+        state = CHAT_LONG_POLL_STATE.get(chat_id)
+        if state is not None:
+            state["interrupted"] = True
+            worker_log.info(
+                "标记延迟轮询为待中断",
+                extra={"chat": chat_id},
+            )
+
+
 async def _watch_and_notify(chat_id: int, session_path: Path,
                             max_wait: float, interval: float):
+    """
+    监听会话文件并发送消息。
+
+    两阶段轮询机制：
+    - 阶段1（快速轮询）：interval 间隔（通常 0.3 秒），直到首次发送成功
+    - 阶段2（延迟轮询）：3 秒间隔，最多 600 次（持续 30 分钟），捕获长时间任务的后续输出
+
+    异常安全：使用 try...finally 确保状态清理。
+    中断机制：收到新 Telegram 消息时会设置 interrupted 标志，轮询自动停止。
+    """
     start = time.monotonic()
-    while True:
-        await asyncio.sleep(interval)
-        if max_wait > 0 and time.monotonic() - start > max_wait:
-            worker_log.warning(
-                "[session-map] chat=%s 长时间未获取到 Codex 输出，停止轮询",
-                chat_id,
-                extra=_session_extra(path=session_path),
-            )
-            return
-        if not session_path.exists():
-            continue
-        delivered = await _deliver_pending_messages(chat_id, session_path)
-        if delivered:
-            return
+    first_delivery_done = False
+    current_interval = interval  # 初始为快速轮询间隔（0.3 秒）
+    long_poll_rounds = 0
+    long_poll_max_rounds = 600  # 30 分钟 / 3 秒 = 600 次
+    long_poll_interval = 3.0  # 3 秒
+
+    try:
+        while True:
+            # 检查是否被新消息中断（使用锁保护）
+            if CHAT_LONG_POLL_LOCK is not None:
+                async with CHAT_LONG_POLL_LOCK:
+                    state = CHAT_LONG_POLL_STATE.get(chat_id)
+                    if state is not None and state.get("interrupted", False):
+                        worker_log.info(
+                            "延迟轮询被新消息中断",
+                            extra={
+                                **_session_extra(path=session_path),
+                                "chat": chat_id,
+                                "round": long_poll_rounds,
+                            },
+                        )
+                        return
+
+            await asyncio.sleep(current_interval)
+
+            # 检查超时（仅在快速轮询阶段）
+            if not first_delivery_done and max_wait > 0 and time.monotonic() - start > max_wait:
+                worker_log.warning(
+                    "[session-map] chat=%s 长时间未获取到 Codex 输出，停止轮询",
+                    chat_id,
+                    extra=_session_extra(path=session_path),
+                )
+                return
+
+            if not session_path.exists():
+                continue
+
+            try:
+                # 快速轮询阶段添加前缀，延迟轮询阶段不添加
+                delivered = await _deliver_pending_messages(
+                    chat_id,
+                    session_path,
+                    add_completion_header=not first_delivery_done
+                )
+            except Exception as exc:
+                worker_log.error(
+                    "消息发送时发生未预期异常",
+                    exc_info=exc,
+                    extra={
+                        **_session_extra(path=session_path),
+                        "chat": chat_id,
+                    },
+                )
+                delivered = False
+
+            # 首次发送成功，切换到延迟轮询模式
+            if delivered and not first_delivery_done:
+                first_delivery_done = True
+                current_interval = long_poll_interval
+                if CHAT_LONG_POLL_LOCK is not None:
+                    async with CHAT_LONG_POLL_LOCK:
+                        CHAT_LONG_POLL_STATE[chat_id] = {
+                            "active": True,
+                            "round": 0,
+                            "max_rounds": long_poll_max_rounds,
+                            "interrupted": False,
+                        }
+                worker_log.info(
+                    "首次发送成功，启动延迟轮询模式",
+                    extra={
+                        **_session_extra(path=session_path),
+                        "chat": chat_id,
+                        "interval": long_poll_interval,
+                        "max_rounds": long_poll_max_rounds,
+                    },
+                )
+                continue
+
+            # 延迟轮询阶段
+            if first_delivery_done:
+                if delivered:
+                    # 又收到新消息，重置轮询计数
+                    long_poll_rounds = 0
+                    if CHAT_LONG_POLL_LOCK is not None:
+                        async with CHAT_LONG_POLL_LOCK:
+                            state = CHAT_LONG_POLL_STATE.get(chat_id)
+                            if state is not None:
+                                state["round"] = 0
+                    worker_log.info(
+                        "延迟轮询中收到新消息，重置计数",
+                        extra={
+                            **_session_extra(path=session_path),
+                            "chat": chat_id,
+                        },
+                    )
+                else:
+                    # 无新消息，增加轮询计数
+                    long_poll_rounds += 1
+                    if CHAT_LONG_POLL_LOCK is not None:
+                        async with CHAT_LONG_POLL_LOCK:
+                            state = CHAT_LONG_POLL_STATE.get(chat_id)
+                            if state is not None:
+                                state["round"] = long_poll_rounds
+
+                    if long_poll_rounds >= long_poll_max_rounds:
+                        worker_log.info(
+                            "延迟轮询达到最大次数，停止监听",
+                            extra={
+                                **_session_extra(path=session_path),
+                                "chat": chat_id,
+                                "total_rounds": long_poll_rounds,
+                            },
+                        )
+                        return
+
+                    worker_log.debug(
+                        "延迟轮询中无新消息",
+                        extra={
+                            **_session_extra(path=session_path),
+                            "chat": chat_id,
+                            "round": f"{long_poll_rounds}/{long_poll_max_rounds}",
+                        },
+                    )
+                continue
+
+            # 快速轮询阶段：如果已发送消息，退出
+            if delivered:
+                return
+
+    finally:
+        # 确保无论如何都清理延迟轮询状态
+        if CHAT_LONG_POLL_LOCK is not None:
+            async with CHAT_LONG_POLL_LOCK:
+                if chat_id in CHAT_LONG_POLL_STATE:
+                    CHAT_LONG_POLL_STATE.pop(chat_id, None)
+                    worker_log.debug(
+                        "监听任务退出，已清理延迟轮询状态",
+                        extra={"chat": chat_id},
+                    )
 
 
 def _read_pointer_path(pointer: Path) -> Optional[Path]:
@@ -5422,7 +5718,7 @@ async def on_task_desc_input(message: Message, state: FSMContext) -> None:
 
 @router.message(TaskDescriptionStates.waiting_confirm)
 async def on_task_desc_confirm_stage_text(message: Message, state: FSMContext) -> None:
-    """处理任务描述确认阶段的菜单指令。"""
+    """处理任务描述确认阶段的菜单指令。支持按钮点击、数字编号和直接文本输入。"""
 
     data = await state.get_data()
     task_id = data.get("task_id")
@@ -5431,13 +5727,19 @@ async def on_task_desc_confirm_stage_text(message: Message, state: FSMContext) -
         await message.answer("会话已失效，请重新操作。", reply_markup=_build_worker_main_keyboard())
         return
 
-    token = _normalize_choice_token(message.text or "")
-    if _is_cancel_message(token) or token == _normalize_choice_token(TASK_DESC_CANCEL_TEXT):
+    # 使用 _resolve_reply_choice() 智能解析用户输入，支持数字编号、按钮文本和直接文本
+    options = [TASK_DESC_CONFIRM_TEXT, TASK_DESC_RETRY_TEXT, TASK_DESC_CANCEL_TEXT]
+    resolved = _resolve_reply_choice(message.text, options=options)
+    stripped = _strip_number_prefix((message.text or "").strip()).lower()
+
+    # 处理取消操作
+    if resolved == options[2] or _is_cancel_message(resolved) or stripped in {"取消"}:
         await state.clear()
         await message.answer("已取消编辑任务描述。", reply_markup=_build_worker_main_keyboard())
         return
 
-    if token == _normalize_choice_token(TASK_DESC_RETRY_TEXT):
+    # 处理重新输入操作
+    if resolved == options[1] or stripped in {"重新输入"}:
         task = await TASK_SERVICE.get_task(task_id)
         if task is None:
             await state.clear()
@@ -5455,7 +5757,8 @@ async def on_task_desc_confirm_stage_text(message: Message, state: FSMContext) -
         )
         return
 
-    if token == _normalize_choice_token(TASK_DESC_CONFIRM_TEXT):
+    # 处理确认更新操作
+    if resolved == options[0] or stripped in {"确认", "确认更新"}:
         new_description = data.get("new_description")
         if new_description is None:
             await state.set_state(TaskDescriptionStates.waiting_content)
@@ -5486,8 +5789,9 @@ async def on_task_desc_confirm_stage_text(message: Message, state: FSMContext) -
         )
         return
 
+    # 无效输入，提示用户
     await message.answer(
-        "当前处于确认阶段，请使用菜单中的按钮确认或重新输入。",
+        "当前处于确认阶段，请选择确认、重新输入或取消，可直接输入编号或点击键盘按钮：",
         reply_markup=_build_task_desc_confirm_keyboard(),
     )
 
@@ -6749,6 +7053,9 @@ async def on_edit_new_value(message: Message, state: FSMContext) -> None:
 
 @router.message(CommandStart())
 async def on_start(m: Message):
+    # 首次收到消息时自动记录 chat_id 到 state 文件
+    _auto_record_chat_id(m.chat.id)
+
     await m.answer(
         (
             f"Hello, {m.from_user.full_name}！\n"
@@ -6764,6 +7071,9 @@ async def on_start(m: Message):
 
 @router.message(F.text)
 async def on_text(m: Message):
+    # 首次收到消息时自动记录 chat_id 到 state 文件
+    _auto_record_chat_id(m.chat.id)
+
     prompt = (m.text or "").strip()
     if not prompt:
         return await m.answer("请输入非空提示词")
@@ -6869,7 +7179,9 @@ async def _ensure_worker_menu_button(bot: Bot) -> None:
         )
 
 async def main():
-    global _bot
+    global _bot, CHAT_LONG_POLL_LOCK
+    # 初始化长轮询锁
+    CHAT_LONG_POLL_LOCK = asyncio.Lock()
     _bot = build_bot()
     try:
         await ensure_telegram_connectivity(_bot)

scripts/bump_version.sh

@@ -0,0 +1,152 @@
+#!/usr/bin/env bash
+# 版本管理便捷脚本
+# 使用方式：
+#   ./scripts/bump_version.sh patch
+#   ./scripts/bump_version.sh minor
+#   ./scripts/bump_version.sh major
+#   ./scripts/bump_version.sh show
+#   ./scripts/bump_version.sh --help
+
+set -e
+
+# 项目根目录
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$PROJECT_ROOT"
+
+# bump-my-version 路径
+BUMP_CMD="/Users/david/.config/vibego/runtime/.venv/bin/bump-my-version"
+
+# 检查 bump-my-version 是否存在
+if [ ! -f "$BUMP_CMD" ]; then
+    echo "错误：找不到 bump-my-version"
+    echo "请先安装：pip install bump-my-version"
+    exit 1
+fi
+
+# 如果没有参数，显示帮助
+if [ $# -eq 0 ]; then
+    echo "用法："
+    echo "  $0 patch         递增补丁版本 (0.2.11 → 0.2.12)"
+    echo "                   自动提交：fix: bugfixes"
+    echo "  $0 minor         递增次版本 (0.2.11 → 0.3.0)"
+    echo "                   自动提交：feat: 添加新功能"
+    echo "  $0 major         递增主版本 (0.2.11 → 1.0.0)"
+    echo "                   自动提交：feat!: 重大变更"
+    echo "  $0 show          显示当前版本"
+    echo "  $0 --dry-run     预览变更（添加在 patch/minor/major 后）"
+    echo ""
+    echo "说明："
+    echo "  脚本会自动提交当前未提交的修改，然后递增版本号。"
+    echo "  如果不想自动提交，请在参数中添加 --no-auto-commit"
+    echo ""
+    echo "示例："
+    echo "  $0 patch                    # 自动提交修改并递增补丁版本"
+    echo "  $0 patch --dry-run         # 预览补丁版本递增（不会提交）"
+    echo "  $0 minor --no-auto-commit  # 仅递增版本，不自动提交当前修改"
+    exit 0
+fi
+
+# 处理 show 命令
+if [ "$1" = "show" ]; then
+    "$BUMP_CMD" show current_version
+    exit 0
+fi
+
+# 处理 --help
+if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+    "$BUMP_CMD" --help
+    exit 0
+fi
+
+# 检查是否禁用自动提交
+AUTO_COMMIT=true
+if [[ "$*" =~ "--no-auto-commit" ]]; then
+    AUTO_COMMIT=false
+fi
+
+# 检查是否是 dry-run
+DRY_RUN=false
+if [[ "$*" =~ "--dry-run" ]]; then
+    DRY_RUN=true
+fi
+
+# 获取版本类型
+VERSION_TYPE="$1"
+
+# 获取对应版本类型的 commit 消息
+get_commit_message() {
+    case "$1" in
+        patch)
+            echo "fix: bugfixes"
+            ;;
+        minor)
+            echo "feat: 添加新功能"
+            ;;
+        major)
+            echo "feat!: 重大变更"
+            ;;
+        *)
+            echo ""
+            ;;
+    esac
+}
+
+# 检查版本类型是否有效
+COMMIT_MSG=$(get_commit_message "$VERSION_TYPE")
+if [ -z "$COMMIT_MSG" ]; then
+    # 如果不是有效的版本类型，直接传递给 bump-my-version
+    "$BUMP_CMD" bump "$@"
+    exit 0
+fi
+
+# 显示当前版本
+echo "📦 当前版本：$("$BUMP_CMD" show current_version)"
+echo ""
+
+# 检查是否有未提交的修改
+if [ "$AUTO_COMMIT" = true ] && [ "$DRY_RUN" = false ]; then
+    if ! git diff-index --quiet HEAD -- 2>/dev/null; then
+        echo "📝 检测到未提交的修改，准备创建 commit..."
+        echo ""
+
+        echo "Commit 消息：$COMMIT_MSG"
+        echo ""
+
+        # 显示将要提交的文件
+        echo "将要提交的文件："
+        git status --short
+        echo ""
+
+        # 提交所有修改
+        git add .
+        git commit -m "$COMMIT_MSG"
+
+        echo "✅ 代码修改已提交"
+        echo ""
+    else
+        echo "ℹ️  没有未提交的修改，跳过自动 commit"
+        echo ""
+    fi
+fi
+
+# 执行版本递增
+echo "🚀 开始递增版本..."
+echo ""
+
+"$BUMP_CMD" bump "$@"
+
+echo ""
+echo "✅ 版本管理完成！"
+echo ""
+echo "📋 操作摘要："
+if [ "$AUTO_COMMIT" = true ] && [ "$DRY_RUN" = false ]; then
+    echo "   1. 已提交代码修改（如有）"
+    echo "   2. 已递增版本号"
+    echo "   3. 已创建版本 commit 和 tag"
+else
+    echo "   1. 已递增版本号"
+    echo "   2. 已创建版本 commit 和 tag"
+fi
+echo ""
+echo "💡 提示：如需推送到远程，请执行："
+echo "   git push && git push --tags"

scripts/models/claudecode.sh

@@ -20,6 +20,10 @@ claude_project_key_from_workdir() {
 model_configure() {
   MODEL_NAME="ClaudeCode"
   MODEL_WORKDIR="${CLAUDE_WORKDIR:-${MODEL_WORKDIR:-$ROOT_DIR}}"
+  # 默认关闭文件快照，避免孤儿 CLI 持续写入 jsonl
+  CLAUDE_DISABLE_FILE_CHECKPOINTING="${CLAUDE_DISABLE_FILE_CHECKPOINTING:-1}"
+  CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING="${CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING:-$CLAUDE_DISABLE_FILE_CHECKPOINTING}"
+  export CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING
   local project_key
   if [[ -n "${CLAUDE_PROJECT_KEY:-}" ]]; then
     project_key="$CLAUDE_PROJECT_KEY"

scripts/run_bot.sh

@@ -151,6 +151,9 @@ export TMUX_LOG="$MODEL_LOG"
 export PROJECT_NAME="$PROJECT_NAME"
 export LOG_DIR="$LOG_DIR"
 export ROOT_DIR="$SOURCE_ROOT"
+if [[ -n "${CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING:-}" ]]; then
+  export CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING
+fi
 
 "$SOURCE_ROOT/scripts/start_tmux_codex.sh" --kill >/dev/null
 

scripts/start_tmux_codex.sh

@@ -117,13 +117,20 @@ run_tmux pipe-pane -o -t "$SESSION_NAME" "$PIPE_CMD"
 
 # 同步环境变量到 tmux 服务端，避免复用旧会话时丢失设置
 run_tmux set-environment -t "$SESSION_NAME" DISABLE_UPDATE_PROMPT "${DISABLE_UPDATE_PROMPT:-true}"
+if [[ -n "${CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING:-}" ]]; then
+  run_tmux set-environment -t "$SESSION_NAME" CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING "${CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING}"
+fi
 
 if (( RESTART )); then
   run_tmux send-keys -t "$SESSION_NAME" C-c
   sleep 1
 fi
 
-printf -v FINAL_CMD 'env DISABLE_UPDATE_PROMPT=%q %s' "${DISABLE_UPDATE_PROMPT:-true}" "$MODEL_CMD"
+env_prefix="env $(printf '%q' "DISABLE_UPDATE_PROMPT=${DISABLE_UPDATE_PROMPT:-true}")"
+if [[ -n "${CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING:-}" ]]; then
+  env_prefix+=" $(printf '%q' "CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING=${CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING}")"
+fi
+printf -v FINAL_CMD '%s %s' "$env_prefix" "$MODEL_CMD"
 
 if (( SESSION_CREATED )) || (( FORCE_START )); then
   run_tmux send-keys -t "$SESSION_NAME" "$FINAL_CMD" C-m

scripts/stop_bot.sh

@@ -47,6 +47,62 @@ fi
 
 POINTER_BASENAME="${MODEL_POINTER_BASENAME:-current_session.txt}"
 
+graceful_shutdown_claudecode() {
+  local session="$1"
+  local timeout="${2:-10}"
+  if ! command -v tmux >/dev/null 2>&1; then
+    return 0
+  fi
+  if ! tmux -u has-session -t "$session" >/dev/null 2>&1; then
+    return 0
+  fi
+  local pane_ids=()
+  while IFS= read -r pane; do
+    [[ -z "$pane" ]] && continue
+    pane_ids+=("$pane")
+  done < <(tmux -u list-panes -t "$session" -F "#{pane_id}" 2>/dev/null || true)
+  (( ${#pane_ids[@]} )) || return 0
+
+  local current_cmd has_claude=0
+  for pane in "${pane_ids[@]}"; do
+    current_cmd=$(tmux -u display-message -p -t "$pane" '#{pane_current_command}' 2>/dev/null || echo "")
+    if [[ "$current_cmd" == claude* ]]; then
+      has_claude=1
+      break
+    fi
+  done
+  (( has_claude )) || return 0
+
+  printf '[stop-bot] 检测到 ClaudeCode 会话，尝试发送 /exit (session=%s)\n' "$session"
+  for pane in "${pane_ids[@]}"; do
+    tmux -u send-keys -t "$pane" Escape
+    tmux -u send-keys -t "$pane" C-u
+    tmux -u send-keys -t "$pane" "/exit" C-m
+  done
+
+  local end_time=$(( $(date +%s) + timeout ))
+  while tmux -u has-session -t "$session" >/dev/null 2>&1; do
+    local still_running=0
+    for pane in "${pane_ids[@]}"; do
+      current_cmd=$(tmux -u display-message -p -t "$pane" '#{pane_current_command}' 2>/dev/null || echo "")
+      if [[ "$current_cmd" == claude* ]]; then
+        still_running=1
+        break
+      fi
+    done
+    if (( still_running == 0 )); then
+      printf '[stop-bot] ClaudeCode 会话已响应 /exit (session=%s)\n' "$session"
+      break
+    fi
+    if (( $(date +%s) >= end_time )); then
+      printf '[stop-bot] ClaudeCode /exit 超时，将继续执行强制关闭 (session=%s)\n' "$session" >&2
+      break
+    fi
+    sleep 0.5
+  done
+  return 0
+}
+
 kill_tty_sessions() {
   local session="$1"
   if command -v tmux >/dev/null 2>&1 && tmux -u has-session -t "$session" >/dev/null 2>&1; then
@@ -64,8 +120,10 @@ kill_pid_file() {
   if [[ ! -f "$pid_file" ]]; then
     local fallback_dir
     fallback_dir="$(dirname "$pid_file")"
-    [[ -d "$fallback_dir" ]] && clear_session_files "$fallback_dir"
-    return
+    if [[ -d "$fallback_dir" ]]; then
+      clear_session_files "$fallback_dir"
+    fi
+    return 0
   fi
   local bot_pid
   bot_pid=$(cat "$pid_file")
@@ -79,7 +137,10 @@ kill_pid_file() {
   rm -f "$pid_file"
   local pid_dir
   pid_dir="$(dirname "$pid_file")"
-  [[ -d "$pid_dir" ]] && clear_session_files "$pid_dir"
+  if [[ -d "$pid_dir" ]]; then
+    clear_session_files "$pid_dir"
+  fi
+  return 0
 }
 
 stop_single_worker() {
@@ -88,9 +149,11 @@ stop_single_worker() {
   log_dir="$(log_dir_for "$model_name" "$project_name")"
   pid_file="$log_dir/bot.pid"
   tmux_session="$(tmux_session_for "$project_name")"
+  graceful_shutdown_claudecode "$tmux_session" 15 || true
   kill_tty_sessions "$tmux_session"
   kill_pid_file "$pid_file"
   clear_session_files "$log_dir"
+  return 0
 }
 
 stop_all_workers() {
@@ -109,6 +172,7 @@ stop_all_workers() {
     if [[ -n "$sessions" ]]; then
       while IFS= read -r sess; do
         [[ -z "$sess" ]] && continue
+        graceful_shutdown_claudecode "$sess" 15 || true
         tmux -u kill-session -t "$sess" >/dev/null 2>&1 || true
         stopped=1
       done <<<"$sessions"

{vibego-0.2.11.dist-info → vibego-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibego
-Version: 0.2.11
+Version: 0.2.13
 Summary: vibego CLI：用于初始化与管理 Telegram Master Bot 的工具
 Author: Hypha
 License-Expression: LicenseRef-Proprietary

{vibego-0.2.11.dist-info → vibego-0.2.13.dist-info}/RECORD

@@ -1,16 +1,17 @@
-bot.py,sha256=q_aRgSBen4XThKdExfa-6NeX9R_Mgs0UjXYx32rsGzo,249827
+bot.py,sha256=YsMdqha8MaJrnDJQwZ0GgQFrnoYKctV5es-RmbL-VeU,262371
 logging_setup.py,sha256=gvxHi8mUwK3IhXJrsGNTDo-DR6ngkyav1X-tvlBF_IE,4613
 master.py,sha256=Qz2NTapUexVvpQz8Y_pVhKd-uXkqp3M6oclzfAzIuGs,106497
 project_repository.py,sha256=UcthtSGOJK0cTE5bQCneo3xkomRG-kyc1N1QVqxeHIs,17577
 scripts/__init__.py,sha256=LVrXUkvWKoc6Sb47X5G0gbIxu5aJ2ARW-qJ14vwi5vM,65
+scripts/bump_version.sh,sha256=a4uB8V8Y5LPsoqTCdzQKsEE8HhwpBmqRaQInG52LDig,4089
 scripts/log_writer.py,sha256=8euoMlRo7cbtHApbcEoJnwzLABxti-ovJWFLRN1oDQw,3843
 scripts/master_healthcheck.py,sha256=-X0VVsZ0AXaOb7izxTO_oyu23g_1jsirNdGIcP8nrSI,8321
 scripts/requirements.txt,sha256=QSt30DSSSHtfucTFPpc7twk9kLS5rVLNTcvDiagxrZg,62
-scripts/run_bot.sh,sha256=rM2Op_l4mP9asT3VoTwGQuHocwaxiGyQp2l1PLegsY4,4481
+scripts/run_bot.sh,sha256=rN4K1nz041XBaUJmnBBKHS2cHmQf11vPNX8wf1hbVR4,4596
 scripts/start.sh,sha256=IsNjFWXX3qmFxx_7iiVEidTj9VHBUTkNNbsCPoNSL0E,6782
-scripts/start_tmux_codex.sh,sha256=4ko72SK7EDJmzXVuLBOz1_S1lLEmgIpLAVuD7mZhpdk,4018
+scripts/start_tmux_codex.sh,sha256=xyLv29p924q-ysxvZYAP3T6VrqLPBPMBWo9QP7cuL50,4438
 scripts/stop_all.sh,sha256=FOz07gi2CI9sMHxBb8XkqHtxRYs3jt1RYgGrEi-htVg,4086
-scripts/stop_bot.sh,sha256=b9vvrke5jeyO18SEBFZxQD09Gf65BgGzeKtpM8sa60Y,3677
+scripts/stop_bot.sh,sha256=ot6Sm0IYoXuRNslUVEflQmJKu5Agm-5xIUXXudJWyTM,5588
 scripts/test_deps_check.sh,sha256=AeSTucbNuNdOPSGvqVp0m31TVFDb0DmU8gSKg-Y5z2I,1696
 scripts/.venv/lib/python3.14/site-packages/pip/__init__.py,sha256=_lgs5Mfp0t7AGtI7sTVwxKWquz_vahWWH9kKO1cJusA,353
 scripts/.venv/lib/python3.14/site-packages/pip/__main__.py,sha256=WzbhHXTbSE6gBY19mNN9m4s5o_365LOvTYSgqgbdBhE,854
@@ -414,7 +415,7 @@ scripts/.venv/lib/python3.14/site-packages/pip/_vendor/urllib3/util/ssltransport
 scripts/.venv/lib/python3.14/site-packages/pip/_vendor/urllib3/util/timeout.py,sha256=cwq4dMk87mJHSBktK1miYJ-85G-3T3RmT20v7SFCpno,10168
 scripts/.venv/lib/python3.14/site-packages/pip/_vendor/urllib3/util/url.py,sha256=lCAE7M5myA8EDdW0sJuyyZhVB9K_j38ljWhHAnFaWoE,14296
 scripts/.venv/lib/python3.14/site-packages/pip/_vendor/urllib3/util/wait.py,sha256=fOX0_faozG2P7iVojQoE1mbydweNyTcm-hXEfFrTtLI,5403
-scripts/models/claudecode.sh,sha256=tCyvGVPUtewVPimC7q_QoDNkXypvZoSPTiRk8mf7DAw,1212
+scripts/models/claudecode.sh,sha256=k8153NH6O925VvhXh2rywVRje9CyUyIurn42EetZHEI,1526
 scripts/models/codex.sh,sha256=_vp-v4L4eNz20JC2JIw1npE0Qz-HBUpdzyxLAtqridU,457
 scripts/models/common.sh,sha256=Xx6BaVqWSxpZUUHf6s6u_rkfbNts0UePeA9J9uoC_HA,2168
 scripts/models/gemini.sh,sha256=0fychnJL4uQJ1_wuc8O2sAQ4K0q3v7_Ku_9EOgUdocI,449
@@ -424,14 +425,14 @@ tasks/constants.py,sha256=tS1kZxBIUm3JJUMHm25XI-KHNUZl5NhbbuzjzL_rF-c,299
 tasks/fsm.py,sha256=rKXXLEieQQU4r2z_CZUvn1_70FXiZXBBugF40gpe_tQ,1476
 tasks/models.py,sha256=N_qqRBo9xMSV0vbn4k6bLBXT8C_dp_oTFUxvdx16ZQM,2459
 tasks/service.py,sha256=w_S_aWiVqRXzXEpimLDsuCCCX2lB5uDkff9aKThBw9c,41916
-vibego_cli/__init__.py,sha256=9Jk4Uc0BhWjiJHoQ1kI0WHFB-tawfl43z4PnmF8S1Gg,310
+vibego_cli/__init__.py,sha256=HDuRE3BFyJQ0KL0Ozp34-WoYBjtGdy6lzYEt1AS7vyY,311
 vibego_cli/__main__.py,sha256=qqTrYmRRLe4361fMzbI3-CqpZ7AhTofIHmfp4ykrrBY,158
 vibego_cli/config.py,sha256=33WSORCfUIxrDtgASPEbVqVLBVNHh-RSFLpNy7tfc0s,2992
 vibego_cli/deps.py,sha256=1nRXI7Dd-S1hYE8DligzK5fIluQWETRUj4_OKL0DikQ,1419
 vibego_cli/main.py,sha256=e2W5Pb9U9rfmF-jNX9uIA3222lhM0GgcvSdFTDBZd2s,12086
 vibego_cli/data/worker_requirements.txt,sha256=QSt30DSSSHtfucTFPpc7twk9kLS5rVLNTcvDiagxrZg,62
-vibego-0.2.11.dist-info/METADATA,sha256=qdYmMPXO440tHnQCLv6SojrTvBsPqj2Pbi1sUrKp9KI,10475
-vibego-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vibego-0.2.11.dist-info/entry_points.txt,sha256=Lsy_zm-dlyxt8-9DL9blBReIwU2k22c8-kifr46ND1M,48
-vibego-0.2.11.dist-info/top_level.txt,sha256=R56CT3nW5H5v3ce0l3QDN4-C4qxTrNWzRTwrxnkDX4U,69
-vibego-0.2.11.dist-info/RECORD,,
+vibego-0.2.13.dist-info/METADATA,sha256=eaSYWnC-3iRHcqmq3ewae3njV2s53eWMwS1Rggkqrhg,10475
+vibego-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibego-0.2.13.dist-info/entry_points.txt,sha256=Lsy_zm-dlyxt8-9DL9blBReIwU2k22c8-kifr46ND1M,48
+vibego-0.2.13.dist-info/top_level.txt,sha256=R56CT3nW5H5v3ce0l3QDN4-C4qxTrNWzRTwrxnkDX4U,69
+vibego-0.2.13.dist-info/RECORD,,

vibego_cli/__init__.py

@@ -7,6 +7,6 @@ from __future__ import annotations
 
 __all__ = ["main", "__version__"]
 
-__version__ = "0.1.0"
+__version__ = "0.2.13"
 
 from .main import main  # noqa: E402