vibego 1.0.2__py3-none-any.whl → 1.0.11__py3-none-any.whl

bot.py

@@ -248,6 +248,7 @@ CODEX_SESSION_FILE_PATH = os.environ.get("CODEX_SESSION_FILE_PATH", "").strip()
 CODEX_SESSIONS_ROOT = os.environ.get("CODEX_SESSIONS_ROOT", "").strip()
 MODEL_SESSION_ROOT = os.environ.get("MODEL_SESSION_ROOT", "").strip()
 MODEL_SESSION_GLOB = os.environ.get("MODEL_SESSION_GLOB", "rollout-*.jsonl").strip() or "rollout-*.jsonl"
+SESSION_LOCK_FILE_PATH = os.environ.get("SESSION_LOCK_FILE_PATH", "").strip()
 SESSION_POLL_TIMEOUT = float(os.environ.get("SESSION_POLL_TIMEOUT", "2"))
 WATCH_MAX_WAIT = float(os.environ.get("WATCH_MAX_WAIT", "0"))
 WATCH_INTERVAL = float(os.environ.get("WATCH_INTERVAL", "2"))
@@ -257,6 +258,7 @@ SEND_FAILURE_NOTICE_COOLDOWN = float(os.environ.get("SEND_FAILURE_NOTICE_COOLDOW
 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", 0), 0)
+SESSION_LOCK_REQUIRED = (os.environ.get("SESSION_LOCK_REQUIRED", "1").strip().lower() not in {"0", "false", "no", "off"})
 
 PLAN_STATUS_LABELS = {
     "completed": "✅",
@@ -956,7 +958,7 @@ async def _send_session_ack(
     model_label = (ACTIVE_MODEL or "Model").strip() or "Model"
     session_id = session_path.stem if session_path else "unknown"
     prompt_message = (
-        f"💭 {model_label} is processing. Listening for model output...\n"
+        f"💭 {model_label} is Thinking... Listening for model output...\n"
         f"sessionId : {session_id}"
     )
     ack_message = await _reply_to_chat(
@@ -1036,52 +1038,84 @@ async def _dispatch_prompt_to_model(
     if CODEX_SESSION_FILE_PATH:
         pointer_path = resolve_path(CODEX_SESSION_FILE_PATH)
 
-    if pointer_path is not None and session_path is None:
-        session_path = _read_pointer_path(pointer_path)
+    lock_session = _read_session_lock_path()
+    lock_required = _is_session_lock_enforced()
+    if lock_session is not None:
+        if session_path is None:
+            worker_log.info(
+                "[session-map] chat=%s use lock session %s",
+                chat_id,
+                lock_session,
+                extra=_session_extra(path=lock_session),
+            )
+        elif session_path != lock_session:
+            worker_log.info(
+                "[session-map] chat=%s override session with lock %s",
+                chat_id,
+                lock_session,
+                extra=_session_extra(path=lock_session),
+            )
+        _sync_pointer_with_lock(pointer_path, lock_session)
+        session_path = lock_session
+    else:
         if session_path is not None:
             worker_log.info(
-                "[session-map] chat=%s pointer -> %s",
+                "[session-map] chat=%s reuse session %s",
                 chat_id,
                 session_path,
                 extra=_session_extra(path=session_path),
             )
-    elif session_path is not None:
-        worker_log.info(
-            "[session-map] chat=%s reuse session %s",
-            chat_id,
-            session_path,
-            extra=_session_extra(path=session_path),
-        )
+        elif lock_required:
+            await _reply_to_chat(
+                chat_id,
+                _session_lock_missing_message(),
+                reply_to=reply_to,
+            )
+            worker_log.error(
+                "[session-lock] Session lock required but missing",
+                extra={"chat": chat_id, "lock_file": SESSION_LOCK_FILE_PATH or "-"},
+            )
+            return False, None
+        else:
+            if pointer_path is not None and session_path is None:
+                session_path = _read_pointer_path(pointer_path)
+                if session_path is not None:
+                    worker_log.info(
+                        "[session-map] chat=%s pointer -> %s",
+                        chat_id,
+                        session_path,
+                        extra=_session_extra(path=session_path),
+                    )
 
-    target_cwd = CODEX_WORKDIR if CODEX_WORKDIR else None
-    if pointer_path is not None:
-        current_cwd = _read_session_meta_cwd(session_path) if session_path else None
-        if session_path is None or (target_cwd and current_cwd != target_cwd):
-            latest = _find_latest_rollout_for_cwd(pointer_path, target_cwd)
-            if latest is not None:
-                try:
-                    SESSION_OFFSETS[str(latest)] = latest.stat().st_size
-                except FileNotFoundError:
-                    SESSION_OFFSETS[str(latest)] = 0
-                _update_pointer(pointer_path, latest)
-                session_path = latest
-                worker_log.info(
-                    "[session-map] chat=%s switch to cwd-matched %s",
-                    chat_id,
-                    session_path,
-                    extra=_session_extra(path=session_path),
-                )
-        if _is_claudecode_model():
-            fallback = _find_latest_claudecode_rollout(pointer_path)
-            if fallback is not None and fallback != session_path:
-                _update_pointer(pointer_path, fallback)
-                session_path = fallback
-                worker_log.info(
-                    "[session-map] chat=%s fallback to ClaudeCode session %s",
-                    chat_id,
-                    session_path,
-                    extra=_session_extra(path=session_path),
-                )
+            target_cwd = CODEX_WORKDIR if CODEX_WORKDIR else None
+            if pointer_path is not None:
+                current_cwd = _read_session_meta_cwd(session_path) if session_path else None
+                if session_path is None or (target_cwd and current_cwd != target_cwd):
+                    latest = _find_latest_rollout_for_cwd(pointer_path, target_cwd)
+                    if latest is not None:
+                        try:
+                            SESSION_OFFSETS[str(latest)] = latest.stat().st_size
+                        except FileNotFoundError:
+                            SESSION_OFFSETS[str(latest)] = 0
+                        _update_pointer(pointer_path, latest)
+                        session_path = latest
+                        worker_log.info(
+                            "[session-map] chat=%s (lock disabled) switch to cwd-matched %s",
+                            chat_id,
+                            session_path,
+                            extra=_session_extra(path=session_path),
+                        )
+                if _is_claudecode_model():
+                    fallback = _find_latest_claudecode_rollout(pointer_path)
+                    if fallback is not None and fallback != session_path:
+                        _update_pointer(pointer_path, fallback)
+                        session_path = fallback
+                        worker_log.info(
+                            "[session-map] chat=%s (lock disabled) fallback to ClaudeCode session %s",
+                            chat_id,
+                            session_path,
+                            extra=_session_extra(path=session_path),
+                        )
 
     needs_session_wait = session_path is None
     if needs_session_wait and pointer_path is None:
@@ -1820,8 +1854,33 @@ BOT_COMMANDS: list[tuple[str, str]] = [
 COMMAND_KEYWORDS: set[str] = {command for command, _ in BOT_COMMANDS}
 COMMAND_KEYWORDS.update({"task_child", "task_children", "task_delete"})
 
-WORKER_MENU_BUTTON_TEXT = "📋 Task List"
-WORKER_CREATE_TASK_BUTTON_TEXT = "➕ Create Task"
+def _button_text_variants(env_key: str, fallback: Sequence[str]) -> tuple[str, ...]:
+    """Return button label candidates sourced from env or fallback list."""
+
+    raw = (os.environ.get(env_key) or "").strip()
+    if not raw:
+        return tuple(fallback)
+    variants = []
+    for segment in raw.split("|"):
+        cleaned = segment.strip()
+        if cleaned and cleaned not in variants:
+            variants.append(cleaned)
+    return tuple(variants or fallback)
+
+
+WORKER_MENU_BUTTON_TEXT_VARIANTS = _button_text_variants(
+    "WORKER_MENU_BUTTON_TEXTS",
+    ("📋 Task List", "📋 任务列表"),
+)
+WORKER_CREATE_TASK_BUTTON_TEXT_VARIANTS = _button_text_variants(
+    "WORKER_CREATE_TASK_BUTTON_TEXTS",
+    ("➕ Create Task", "➕ 创建任务"),
+)
+
+WORKER_MENU_BUTTON_TEXT = WORKER_MENU_BUTTON_TEXT_VARIANTS[0]
+WORKER_CREATE_TASK_BUTTON_TEXT = WORKER_CREATE_TASK_BUTTON_TEXT_VARIANTS[0]
+WORKER_MENU_BUTTON_TEXT_SET = set(WORKER_MENU_BUTTON_TEXT_VARIANTS)
+WORKER_CREATE_TASK_BUTTON_TEXT_SET = set(WORKER_CREATE_TASK_BUTTON_TEXT_VARIANTS)
 
 TASK_ID_VALID_PATTERN = re.compile(r"^TASK_[A-Z0-9_]+$")
 TASK_ID_USAGE_TIP = "Invalid task ID format. Use patterns like TASK_0001."
@@ -2335,6 +2394,9 @@ MODEL_PUSH_SUPPLEMENT_STATUSES: set[str] = {
     "research",
     "test",
 }
+PUSH_MODEL_SUPPLEMENT_IN_PROGRESS_TEXT = (
+    "A supplementary description prompt is already active. Please respond or tap Skip/Cancel."
+)
 
 SUMMARY_COMMAND_PREFIX = "/task_summary_request_"
 SUMMARY_COMMAND_ALIASES: tuple[str, ...] = (
@@ -3010,6 +3072,9 @@ async def _build_history_context_for_model(task_id: str) -> tuple[str, int]:
     return "\n".join(trimmed_lines), len(trimmed_lines)
 
 
+SKIPPED_TASK_HISTORY_ACTIONS: set[str] = {"push_model", "summary_request"}
+
+
 async def _log_task_action(
     task_id: str,
     *,
@@ -3023,11 +3088,20 @@ async def _log_task_action(
 ) -> None:
     """Encapsulate task event writing and record logs when exceptions occur to avoid interrupting the main process."""
 
+    action_token = (action or "").strip()
+    if action_token in SKIPPED_TASK_HISTORY_ACTIONS:
+        worker_log.debug(
+            "Skipped logging task action in history: task_id=%s action=%s",
+            task_id,
+            action_token,
+            extra=_session_extra(),
+        )
+        return
     data_payload: Optional[Dict[str, Any]]
     if payload is None:
-        data_payload = {"action": action}
+        data_payload = {"action": action_token}
     else:
-        data_payload = {"action": action, **payload}
+        data_payload = {"action": action_token, **payload}
     try:
         await TASK_SERVICE.log_task_event(
             task_id,
@@ -4298,29 +4372,12 @@ async def _log_model_reply_event(
     session_path: Path,
     event_offset: int,
 ) -> None:
-    """Write model responses to Task history."""
+    """Model replies are no longer persisted to history."""
 
-    trimmed = _trim_history_value(content, limit=HISTORY_DISPLAY_VALUE_LIMIT)
-    payload = {
-        "model": ACTIVE_MODEL or "",
-        "session": str(session_path),
-        "offset": event_offset,
-    }
-    if content:
-        payload["content"] = content[:MODEL_REPLY_PAYLOAD_LIMIT]
-    try:
-        await TASK_SERVICE.log_task_event(
-            task_id,
-            event_type=HISTORY_EVENT_MODEL_REPLY,
-            actor=f"model/{ACTIVE_MODEL or 'codex'}",
-            new_value=trimmed,
-            payload=payload,
-        )
-    except ValueError:
-        worker_log.warning(
-            "The model reply writes fail: Task does not exist",
-            extra={"task_id": task_id, **_session_extra(path=session_path)},
-        )
+    worker_log.debug(
+        "Skipping history write for model reply",
+        extra={"task_id": task_id, "session": str(session_path)},
+    )
 
 
 async def _maybe_finalize_summary(
@@ -4792,60 +4849,79 @@ async def _ensure_session_watcher(chat_id: int) -> Optional[Path]:
 
     target_cwd = CODEX_WORKDIR or None
 
-    if session_path is None and pointer_path is not None:
-        session_path = _read_pointer_path(pointer_path)
-        if session_path is not None:
+    lock_session = _read_session_lock_path()
+    lock_required = _is_session_lock_enforced()
+    if lock_session is not None:
+        if session_path is None or session_path != lock_session:
             worker_log.info(
-                "[session-map] chat=%s pointer -> %s",
+                "[session-map] chat=%s use lock session %s",
                 chat_id,
-                session_path,
-                extra=_session_extra(path=session_path),
+                lock_session,
+                extra=_session_extra(path=lock_session),
             )
-    if session_path is None and pointer_path is not None:
-        latest = _find_latest_rollout_for_cwd(pointer_path, target_cwd)
-        if latest is not None:
-            session_path = latest
-            _update_pointer(pointer_path, latest)
-            worker_log.info(
-                "[session-map] chat=%s locate latest rollout %s",
-                chat_id,
-                session_path,
-                extra=_session_extra(path=session_path),
+        _sync_pointer_with_lock(pointer_path, lock_session)
+        session_path = lock_session
+    else:
+        if lock_required:
+            worker_log.error(
+                "[session-lock] Session lock required but missing during watcher ensure",
+                extra={"chat": chat_id, "lock_file": SESSION_LOCK_FILE_PATH or "-"},
             )
+            return None
+        if session_path is None and pointer_path is not None:
+            session_path = _read_pointer_path(pointer_path)
+            if session_path is not None:
+                worker_log.info(
+                    "[session-map] chat=%s pointer -> %s",
+                    chat_id,
+                    session_path,
+                    extra=_session_extra(path=session_path),
+                )
+        if session_path is None and pointer_path is not None:
+            latest = _find_latest_rollout_for_cwd(pointer_path, target_cwd)
+            if latest is not None:
+                session_path = latest
+                _update_pointer(pointer_path, latest)
+                worker_log.info(
+                    "[session-map] chat=%s locate latest rollout %s",
+                    chat_id,
+                    session_path,
+                    extra=_session_extra(path=session_path),
+                )
 
-    if pointer_path is not None and _is_claudecode_model():
-        fallback = _find_latest_claudecode_rollout(pointer_path)
-        if fallback is not None and fallback != session_path:
-            session_path = fallback
-            _update_pointer(pointer_path, session_path)
-            worker_log.info(
-                "[session-map] chat=%s resume ClaudeCode session %s",
-                chat_id,
-                session_path,
-                extra=_session_extra(path=session_path),
-            )
+        if pointer_path is not None and _is_claudecode_model():
+            fallback = _find_latest_claudecode_rollout(pointer_path)
+            if fallback is not None and fallback != session_path:
+                session_path = fallback
+                _update_pointer(pointer_path, session_path)
+                worker_log.info(
+                    "[session-map] chat=%s resume ClaudeCode session %s",
+                    chat_id,
+                    session_path,
+                    extra=_session_extra(path=session_path),
+                )
 
-    if session_path is None and pointer_path is not None:
-        session_path = await _await_session_path(pointer_path, target_cwd)
-        if session_path is not None:
-            _update_pointer(pointer_path, session_path)
-            worker_log.info(
-                "[session-map] chat=%s bind fresh session %s",
-                chat_id,
-                session_path,
-                extra=_session_extra(path=session_path),
-            )
-    if session_path is None and pointer_path is not None and _is_claudecode_model():
-        fallback = _find_latest_claudecode_rollout(pointer_path)
-        if fallback is not None:
-            session_path = fallback
-            _update_pointer(pointer_path, session_path)
-            worker_log.info(
-                "[session-map] chat=%s fallback bind ClaudeCode session %s",
-                chat_id,
-                session_path,
-                extra=_session_extra(path=session_path),
-            )
+        if session_path is None and pointer_path is not None:
+            session_path = await _await_session_path(pointer_path, target_cwd)
+            if session_path is not None:
+                _update_pointer(pointer_path, session_path)
+                worker_log.info(
+                    "[session-map] chat=%s bind fresh session %s",
+                    chat_id,
+                    session_path,
+                    extra=_session_extra(path=session_path),
+                )
+        if session_path is None and pointer_path is not None and _is_claudecode_model():
+            fallback = _find_latest_claudecode_rollout(pointer_path)
+            if fallback is not None:
+                session_path = fallback
+                _update_pointer(pointer_path, session_path)
+                worker_log.info(
+                    "[session-map] chat=%s fallback bind ClaudeCode session %s",
+                    chat_id,
+                    session_path,
+                    extra=_session_extra(path=session_path),
+                )
 
     if session_path is None:
         worker_log.warning(
@@ -5268,6 +5344,115 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                 )
 
 
+_SESSION_LOCK_CACHE_MTIME: Optional[float] = None
+_SESSION_LOCK_CACHE_VALUE: Optional[Path] = None
+
+
+def _session_lock_file() -> Optional[Path]:
+    if not SESSION_LOCK_FILE_PATH:
+        return None
+    return resolve_path(SESSION_LOCK_FILE_PATH)
+
+
+def _is_session_lock_enforced() -> bool:
+    """Return True when the worker must rely on the captured session lock."""
+
+    return SESSION_LOCK_REQUIRED and bool(SESSION_LOCK_FILE_PATH)
+
+
+def _session_lock_missing_message() -> str:
+    """Build a human-readable error when the session lock is missing."""
+
+    target = SESSION_LOCK_FILE_PATH or "session_lock.json"
+    return (
+        "当前 worker 未检测到会话锁，无法定位本项目独占的模型会话。\n"
+        f"缺失的锁文件：{target}\n"
+        "请在对应项目目录重新执行 scripts/run_bot.sh（或等效启动脚本）以捕获新的 tmux 会话。"
+    )
+
+
+def _read_session_lock_path() -> Optional[Path]:
+    """Read the persisted session lock and return the rollout path when valid."""
+
+    lock_file = _session_lock_file()
+    if lock_file is None:
+        return None
+    global _SESSION_LOCK_CACHE_MTIME, _SESSION_LOCK_CACHE_VALUE
+
+    try:
+        stat = lock_file.stat()
+    except FileNotFoundError:
+        _SESSION_LOCK_CACHE_MTIME = None
+        _SESSION_LOCK_CACHE_VALUE = None
+        return None
+
+    mtime = stat.st_mtime
+    if _SESSION_LOCK_CACHE_MTIME == mtime and _SESSION_LOCK_CACHE_VALUE is not None:
+        return _SESSION_LOCK_CACHE_VALUE
+
+    try:
+        raw = lock_file.read_text(encoding="utf-8")
+    except OSError:
+        _SESSION_LOCK_CACHE_MTIME = mtime
+        _SESSION_LOCK_CACHE_VALUE = None
+        return None
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        worker_log.warning(
+            "[session-lock] Invalid JSON payload",
+            extra={"lock": str(lock_file)},
+        )
+        _SESSION_LOCK_CACHE_MTIME = mtime
+        _SESSION_LOCK_CACHE_VALUE = None
+        return None
+
+    session_raw = payload.get("session_path")
+    if not isinstance(session_raw, str) or not session_raw.strip():
+        _SESSION_LOCK_CACHE_MTIME = mtime
+        _SESSION_LOCK_CACHE_VALUE = None
+        return None
+
+    rollout = resolve_path(session_raw.strip())
+    if not rollout.exists():
+        worker_log.warning(
+            "[session-lock] Recorded session file is missing",
+            extra={"session": str(rollout)},
+        )
+        _SESSION_LOCK_CACHE_MTIME = mtime
+        _SESSION_LOCK_CACHE_VALUE = None
+        return None
+
+    tmux_name = payload.get("tmux_session")
+    if tmux_name and isinstance(tmux_name, str) and tmux_name.strip() and tmux_name.strip() != TMUX_SESSION:
+        worker_log.info(
+            "[session-lock] tmux mismatch, ignoring lock",
+            extra={"lock_session": tmux_name.strip(), "tmux": TMUX_SESSION},
+        )
+        _SESSION_LOCK_CACHE_MTIME = mtime
+        _SESSION_LOCK_CACHE_VALUE = None
+        return None
+
+    _SESSION_LOCK_CACHE_MTIME = mtime
+    _SESSION_LOCK_CACHE_VALUE = rollout
+    return rollout
+
+
+def _sync_pointer_with_lock(pointer: Optional[Path], lock_path: Path) -> None:
+    """Ensure pointer.txt matches the locked session path."""
+
+    if pointer is None:
+        return
+    target = str(lock_path)
+    try:
+        current = pointer.read_text(encoding="utf-8").strip()
+    except OSError:
+        current = ""
+    if current == target:
+        return
+    _update_pointer(pointer, lock_path)
+
+
 def _read_pointer_path(pointer: Path) -> Optional[Path]:
     try:
         raw = pointer.read_text(encoding="utf-8").strip()
@@ -5483,7 +5668,7 @@ def _format_plan_update(arguments: Any, *, event_timestamp: Optional[str]) -> Op
     if not steps:
         return None
 
-    header = "currentTaskExecution plan:"
+    header = "current task execution plan:"
     body_parts = [header]
     if lines:
         body_parts.extend(lines)
@@ -5945,7 +6130,7 @@ async def on_task_list(message: Message) -> None:
     await _handle_task_list_request(message)
 
 
-@router.message(F.text == WORKER_MENU_BUTTON_TEXT)
+@router.message(F.text.in_(WORKER_MENU_BUTTON_TEXT_SET))
 async def on_task_list_button(message: Message) -> None:
     await _handle_task_list_request(message)
 
@@ -5980,7 +6165,7 @@ async def _dispatch_task_new_command(source_message: Message, actor: Optional[Us
     await dp.feed_update(bot_instance, update)
 
 
-@router.message(F.text == WORKER_CREATE_TASK_BUTTON_TEXT)
+@router.message(F.text.in_(WORKER_CREATE_TASK_BUTTON_TEXT_SET))
 async def on_task_create_button(message: Message, state: FSMContext) -> None:
     await state.clear()
     try:
@@ -6667,6 +6852,10 @@ async def on_task_push_model(callback: CallbackQuery, state: FSMContext) -> None
         await callback.answer("Callback parameter error.", show_alert=True)
         return
     _, _, task_id = parts
+    current_state = await state.get_state()
+    existing_context: Dict[str, Any] = {}
+    if current_state == TaskPushStates.waiting_supplement.state:
+        existing_context = await state.get_data()
     task = await TASK_SERVICE.get_task(task_id)
     if task is None:
         await callback.answer("Task does not exist", show_alert=True)
@@ -6677,10 +6866,20 @@ async def on_task_push_model(callback: CallbackQuery, state: FSMContext) -> None
     actor = _actor_from_callback(callback)
     chat_id = callback.message.chat.id if callback.message else callback.from_user.id
     if task.status in MODEL_PUSH_SUPPLEMENT_STATUSES:
+        origin_message = callback.message
+        origin_message_id = origin_message.message_id if origin_message else None
+        if (
+            current_state == TaskPushStates.waiting_supplement.state
+            and existing_context.get("task_id") == task_id
+            and existing_context.get("origin_message_id") == origin_message_id
+        ):
+            await callback.answer(PUSH_MODEL_SUPPLEMENT_IN_PROGRESS_TEXT)
+            return
         await state.clear()
         await state.update_data(
             task_id=task_id,
-            origin_message=callback.message,
+            origin_message=origin_message,
+            origin_message_id=origin_message_id,
             chat_id=chat_id,
             actor=actor,
         )
@@ -6780,16 +6979,31 @@ async def on_task_push_model_fill(callback: CallbackQuery, state: FSMContext) ->
         await callback.answer("Callback parameter error.", show_alert=True)
         return
     _, _, task_id = parts
+    current_state = await state.get_state()
+    existing_context: Dict[str, Any] = {}
+    if current_state == TaskPushStates.waiting_supplement.state:
+        existing_context = await state.get_data()
     task = await TASK_SERVICE.get_task(task_id)
     if task is None:
         await state.clear()
         await callback.answer("Task does not exist", show_alert=True)
         return
     actor = _actor_from_callback(callback)
+    origin_message = callback.message
+    origin_message_id = origin_message.message_id if origin_message else None
+    if (
+        current_state == TaskPushStates.waiting_supplement.state
+        and existing_context.get("task_id") == task_id
+        and existing_context.get("origin_message_id") == origin_message_id
+    ):
+        await callback.answer(PUSH_MODEL_SUPPLEMENT_IN_PROGRESS_TEXT)
+        return
+    await state.clear()
     await state.update_data(
         task_id=task_id,
-        origin_message=callback.message,
-        chat_id=callback.message.chat.id if callback.message else callback.from_user.id,
+        origin_message=origin_message,
+        origin_message_id=origin_message_id,
+        chat_id=origin_message.chat.id if origin_message else callback.from_user.id,
         actor=actor,
     )
     await state.set_state(TaskPushStates.waiting_supplement)
@@ -7959,10 +8173,14 @@ async def on_start(m: Message):
         await m.answer(_format_env_issue_message())
 
 @router.message(F.text)
-async def on_text(m: Message):
+async def on_text(m: Message, state: FSMContext | None = None):
     # Automatically record chat when first received message_id to state document
     _auto_record_chat_id(m.chat.id)
 
+    current_state: Optional[str] = None
+    if state is not None:
+        current_state = await state.get_state()
+
     prompt = (m.text or "").strip()
     if not prompt:
         return await m.answer("Please enter a non-empty prompt word")
@@ -7972,6 +8190,12 @@ async def on_text(m: Message):
         return
     if prompt.startswith("/"):
         return
+    if current_state:
+        worker_log.debug(
+            "Suppressed model dispatch due to active wizard state",
+            extra={**_session_extra(), "chat": m.chat.id, "state": current_state},
+        )
+        return
     await _handle_prompt_dispatch(m, prompt)
 
 

master.py

@@ -2163,8 +2163,21 @@ async def _notify_restart_success(bot: Bot) -> None:
     except Exception as exc:
         log.error("Failed to send restart successful notification: %s", exc, extra={"chat": chat_id})
     else:
-        # After a successful restart, the project list will no longer be included to avoid extra noise during high-frequency restarts.
+        # Restart succeeded; notify admins and push the refreshed project overview for quick status check.
         log.info("Restart successful notification has been sent", extra={"chat": chat_id, "duration": restart_duration})
+        try:
+            manager = await _ensure_manager()
+        except RuntimeError as exc:  # pragma: no cover - defensive guard if startup order changes
+            log.warning("Manager unavailable when trying to push project overview: %s", exc)
+        else:
+            try:
+                await _send_projects_overview_to_chat(bot, chat_id, manager)
+            except Exception as exc:  # pragma: no cover - avoid crashing startup hook
+                log.error(
+                    "Failed to send project overview after restart notification: %s",
+                    exc,
+                    extra={"chat": chat_id},
+                )
     finally:
         candidates = (signal_path, RESTART_SIGNAL_PATH, *LEGACY_RESTART_SIGNAL_PATHS)
         for candidate in candidates:
@@ -2198,7 +2211,8 @@ async def _process_restart_request(
 
     lock = _ensure_restart_lock()
     async with lock:
-        global_restart_in_progress
+        # Use global so the restart flag is shared across concurrent handlers
+        global _restart_in_progress
         if _restart_in_progress:
             await message.answer("A restart request is already being executed, please try again later. ")
             return
@@ -2258,7 +2272,8 @@ async def cmd_start(message: Message) -> None:
 
 async def _perform_restart(message: Message, start_script: Path) -> None:
     """Asynchronous execution ./start.sh,If it fails, roll back the mark and notify the administrator """
-    global_restart_in_progress
+    # Use global so restart flag resets affect the module-level state
+    global _restart_in_progress
     lock = _ensure_restart_lock()
     bot = message.bot
     chat_id = message.chat.id