vibego 0.2.11__tar.gz → 0.2.12__tar.gz

{vibego-0.2.11 → vibego-0.2.12}/PKG-INFO

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

{vibego-0.2.11 → vibego-0.2.12}/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,
@@ -3050,6 +3053,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
 
 
@@ -3992,6 +3998,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 +4160,175 @@ 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（延迟轮询）：180 秒间隔，最多 10 次，捕获长时间任务的后续输出
+
+    异常安全：使用 try...finally 确保状态清理。
+    """
     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 = 10
+    long_poll_interval = 180.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)
+            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 +5583,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 +5592,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 +5622,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 +5654,9 @@ async def on_task_desc_confirm_stage_text(message: Message, state: FSMContext) -
         )
         return
 
+    # 无效输入，提示用户
     await message.answer(
-        "当前处于确认阶段，请使用菜单中的按钮确认或重新输入。",
+        "当前处于确认阶段，请选择确认、重新输入或取消，可直接输入编号或点击键盘按钮：",
         reply_markup=_build_task_desc_confirm_keyboard(),
     )
 
@@ -6869,7 +7038,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)

{vibego-0.2.11 → vibego-0.2.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vibego"
-version = "0.2.11"
+version = "0.2.12"
 description = "vibego CLI：用于初始化与管理 Telegram Master Bot 的工具"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -39,3 +39,30 @@ include = ["vibego_cli", "tasks", "scripts"]
 [tool.setuptools.package-data]
 "vibego_cli" = ["data/*.txt"]
 "scripts" = ["*.sh", "models/*.sh"]
+
+[tool.bumpversion]
+current_version = "0.2.12"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "chore: bump version {current_version} → {new_version}"
+commit_args = ""
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+
+[[tool.bumpversion.files]]
+filename = "vibego_cli/__init__.py"
+search = '__version__ = "{current_version}"'
+replace = '__version__ = "{new_version}"'

vibego-0.2.12/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"

{vibego-0.2.11 → vibego-0.2.12}/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"

{vibego-0.2.11 → vibego-0.2.12}/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
 

{vibego-0.2.11 → vibego-0.2.12}/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

{vibego-0.2.11 → vibego-0.2.12}/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"