vibego 1.0.7__tar.gz → 1.0.13__tar.gz

{vibego-1.0.7/vibego.egg-info → vibego-1.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibego
-Version: 1.0.7
+Version: 1.0.13
 Summary: vibego CLI: tools for bootstrapping and managing the Telegram Master Bot
 Author: DavidChan
 License-Expression: LicenseRef-Proprietary

{vibego-1.0.7 → vibego-1.0.13}/bot.py

@@ -20,6 +20,7 @@ from aiogram.filters import Command, CommandStart
 from aiogram.filters.command import CommandObject
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.storage.memory import MemoryStorage
+from aiogram.dispatcher.event.bases import SkipHandler
 from aiogram.types import (
     Message,
     BufferedInputFile,
@@ -258,6 +259,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": "✅",
@@ -989,6 +991,22 @@ async def _dispatch_prompt_to_model(
 ) -> tuple[bool, Optional[Path]]:
     """Handle session binding, acknowledgement, and watcher setup after pushing a prompt."""
 
+    if _is_menu_control_message(prompt):
+        worker_log.warning(
+            "Rejected menu control prompt before tmux dispatch",
+            extra={
+                "chat": chat_id,
+                **_session_extra(),
+                "token": _normalize_choice_token(prompt),
+            },
+        )
+        await _reply_to_chat(
+            chat_id,
+            "Skip/Cancel inputs are ignored outside interactive menus. Please send an actual prompt.",
+            reply_to=reply_to,
+        )
+        return False, None
+
     prev_watcher = CHAT_WATCHERS.pop(chat_id, None)
     if prev_watcher is not None:
         if not prev_watcher.done():
@@ -1038,6 +1056,7 @@ async def _dispatch_prompt_to_model(
         pointer_path = resolve_path(CODEX_SESSION_FILE_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(
@@ -1056,53 +1075,65 @@ async def _dispatch_prompt_to_model(
         _sync_pointer_with_lock(pointer_path, lock_session)
         session_path = lock_session
     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),
-                )
-        elif session_path is not None:
+        if 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),
             )
-
-        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
+        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 fallback to ClaudeCode session %s",
+                        "[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 (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:
         await _reply_to_chat(
@@ -1802,6 +1833,17 @@ async def _enqueue_media_group_message(message: Message, text_part: Optional[str
 async def _handle_prompt_dispatch(message: Message, prompt: str) -> None:
     """Wrapper routine that pushes prompts to the model."""
 
+    if _is_menu_control_message(prompt):
+        worker_log.info(
+            "Dropped menu control prompt during dispatch",
+            extra={
+                **_session_extra(),
+                "chat": getattr(message.chat, "id", None),
+                "token": _normalize_choice_token(prompt),
+            },
+        )
+        return
+
     if ENV_ISSUES:
         message_text = _format_env_issue_message()
         worker_log.warning(
@@ -1840,8 +1882,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."
@@ -2260,6 +2327,12 @@ def _is_cancel_message(value: Optional[str]) -> bool:
     return lowered in cancel_tokens
 
 
+def _is_menu_control_message(value: Optional[str]) -> bool:
+    """Return True when the payload represents a generic Skip/Cancel menu action."""
+
+    return _is_skip_message(value) or _is_cancel_message(value)
+
+
 _MARKDOWN_ESCAPE_RE = re.compile(r"([_*\[\]()~`>#+=|{}.!])")
 TASK_REFERENCE_PATTERN = re.compile(r"/?TASK[_]?\d{4,}")
 
@@ -2355,6 +2428,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, ...] = (
@@ -3030,6 +3106,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,
     *,
@@ -3043,11 +3122,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,
@@ -4318,29 +4406,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(
@@ -4813,6 +4884,7 @@ async def _ensure_session_watcher(chat_id: int) -> Optional[Path]:
     target_cwd = CODEX_WORKDIR or 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(
@@ -4824,6 +4896,12 @@ async def _ensure_session_watcher(chat_id: int) -> Optional[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:
@@ -5310,6 +5388,23 @@ def _session_lock_file() -> Optional[Path]:
     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."""
 
@@ -6069,7 +6164,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)
 
@@ -6104,7 +6199,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:
@@ -6791,6 +6886,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)
@@ -6801,10 +6900,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,
         )
@@ -6904,16 +7013,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)
@@ -6931,18 +7055,18 @@ async def on_task_push_model_supplement(message: Message, state: FSMContext) ->
     if resolved == "Cancel" or trimmed == "Cancel":
         await state.clear()
         await message.answer("Push to the model cancelled.", reply_markup=_build_worker_main_keyboard())
-        return
+        raise SkipHandler()
     data = await state.get_data()
     task_id = data.get("task_id")
     if not task_id:
         await state.clear()
         await message.answer("The push session has expired, please click the button again.", reply_markup=_build_worker_main_keyboard())
-        return
+        raise SkipHandler()
     task = await TASK_SERVICE.get_task(task_id)
     if task is None:
         await state.clear()
         await message.answer("Task not found. Push cancelled.", reply_markup=_build_worker_main_keyboard())
-        return
+        raise SkipHandler()
     supplement: Optional[str] = None
     if trimmed and resolved != SKIP_TEXT:
         if len(trimmed) > DESCRIPTION_MAX_LENGTH:
@@ -6950,7 +7074,7 @@ async def on_task_push_model_supplement(message: Message, state: FSMContext) ->
                 f"Supplementary task description cannot exceed {DESCRIPTION_MAX_LENGTH} characters. Please re-enter:",
                 reply_markup=_build_description_keyboard(),
             )
-            return
+            raise SkipHandler()
         supplement = raw_text.strip()
     chat_id = data.get("chat_id") or message.chat.id
     origin_message = data.get("origin_message")
@@ -6971,11 +7095,11 @@ async def on_task_push_model_supplement(message: Message, state: FSMContext) ->
             extra={"task_id": task_id, "status": task.status if task else None},
         )
         await message.answer("Push failed: missing template configuration.", reply_markup=_build_worker_main_keyboard())
-        return
+        raise SkipHandler()
     await state.clear()
     if not success:
         await message.answer("Push failed: model is not ready. Please retry shortly.", reply_markup=_build_worker_main_keyboard())
-        return
+        raise SkipHandler()
     preview_block, preview_parse_mode = _wrap_text_in_code_block(prompt)
     await _reply_to_chat(
         chat_id,
@@ -6986,6 +7110,7 @@ async def on_task_push_model_supplement(message: Message, state: FSMContext) ->
     )
     if session_path is not None:
         await _send_session_ack(chat_id, session_path, reply_to=origin_message)
+    raise SkipHandler()
 
 
 @router.callback_query(F.data.startswith("task:history:"))
@@ -8083,10 +8208,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")
@@ -8096,6 +8225,22 @@ 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
+    if _is_menu_control_message(prompt):
+        worker_log.info(
+            "Suppressed stray menu control input without active wizard",
+            extra={
+                **_session_extra(),
+                "chat": getattr(m.chat, "id", None),
+                "token": _normalize_choice_token(prompt),
+            },
+        )
+        return
     await _handle_prompt_dispatch(m, prompt)
 
 

{vibego-1.0.7 → vibego-1.0.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vibego"
-version = "1.0.7"
+version = "1.0.13"
 description = "vibego CLI: tools for bootstrapping and managing the Telegram Master Bot"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -42,7 +42,7 @@ include = ["vibego_cli", "tasks", "scripts"]
 "scripts" = ["*.sh", "models/*.sh"]
 
 [tool.bumpversion]
-current_version = "1.0.7"
+current_version = "1.0.13"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{vibego-1.0.7 → vibego-1.0.13}/scripts/session_pointer_watch.py

@@ -239,8 +239,13 @@ def main(argv: Optional[list[str]] = None) -> int:
             observer.join(timeout=5)
 
     if session_path is None:
-        log.error("Failed to detect rollout file within timeout %.1fs", args.timeout)
-        return 0  # Do not fail startup; worker will fall back to legacy behaviour.
+        log.error(
+            "Failed to detect rollout file within timeout %.1fs (tmux session=%s, project=%s)",
+            args.timeout,
+            args.tmux_session or "-",
+            args.project or "-",
+        )
+        return 1
 
     _write_pointer(pointer_path, session_path)
     _write_lock(

{vibego-1.0.7 → vibego-1.0.13}/scripts/start_tmux_codex.sh

@@ -163,7 +163,10 @@ if (( ! DRY_RUN )); then
   WATCH_ARGS+=("--additional-root" "$(dirname "$SESSION_POINTER_FILE")/sessions")
   WATCH_ARGS+=("--timeout" "$SESSION_CAPTURE_TIMEOUT")
   WATCH_ARGS+=("--poll" "$SESSION_CAPTURE_POLL_INTERVAL")
-  "${WATCH_ARGS[@]}" >/dev/null 2>&1 &
+  if ! "${WATCH_ARGS[@]}"; then
+    echo "Failed to capture Codex/Claude session log for tmux session '$SESSION_NAME'. Please check CLI startup output." >&2
+    exit 1
+  fi
 fi
 
 exit 0

{vibego-1.0.7 → vibego-1.0.13}/tasks/service.py

@@ -445,15 +445,6 @@ class TaskService:
                         0,
                     ),
                 )
-                await self._insert_history(
-                    db,
-                    task_id,
-                    "create",
-                    None,
-                    title,
-                    actor,
-                    created_at=now,
-                )
                 await db.commit()
                 return TaskRecord(
                     id=task_id,
@@ -605,10 +596,8 @@ class TaskService:
                     raise ValueError("Task does not exist")
                 updates = []
                 params: List[object] = []
-                history_items: List[Tuple[str, Optional[str], Optional[str]]] = []
                 if title is not None and title != row["title"]:
                     updates.append("title = ?")
-                    history_items.append(("title", row["title"], title))
                     params.append(title)
                 if status is not None:
                     normalized_status = self._normalize_status_token(status, context="update")
@@ -624,35 +613,28 @@ class TaskService:
                     status_value = None
                 if status_value is not None and status_value != row["status"]:
                     updates.append("status = ?")
-                    history_items.append(("status", row["status"], status_value))
                     params.append(status_value)
                 if priority is not None and priority != row["priority"]:
                     updates.append("priority = ?")
-                    history_items.append(("priority", str(row["priority"]), str(priority)))
                     params.append(priority)
                 if task_type is not None and task_type != row["task_type"]:
                     updates.append("task_type = ?")
-                    history_items.append(("task_type", row["task_type"], task_type))
                     params.append(task_type)
                 if tags is not None:
                     tags_json = json.dumps(list(tags))
                     if tags_json != row["tags"]:
                         updates.append("tags = ?")
-                        history_items.append(("tags", row["tags"], tags_json))
                         params.append(tags_json)
                 if due_date is not None and due_date != row["due_date"]:
                     updates.append("due_date = ?")
-                    history_items.append(("due_date", row["due_date"], due_date))
                     params.append(due_date)
                 if description is not None and description != row["description"]:
                     updates.append("description = ?")
-                    history_items.append(("description", row["description"], description))
                     params.append(description)
                 if archived is not None:
                     archived_int = 1 if archived else 0
                     if archived_int != row["archived"]:
                         updates.append("archived = ?")
-                        history_items.append(("archived", str(row["archived"]), str(archived_int)))
                         params.append(archived_int)
                 if updates:
                     now = shanghai_now_iso()
@@ -663,16 +645,6 @@ class TaskService:
                         f"UPDATE tasks SET {' , '.join(updates)} WHERE id = ?",
                         params,
                     )
-                    for field, old, new in history_items:
-                        await self._insert_history(
-                            db,
-                            task_id,
-                            field,
-                            old,
-                            new,
-                            actor,
-                            created_at=now,
-                        )
                 await db.commit()
         updated = await self.get_task(task_id)
         if updated is None:
@@ -687,7 +659,7 @@ class TaskService:
         content: str,
         actor: Optional[str],
     ) -> TaskNoteRecord:
-        """Append a note to a task and persist a corresponding history entry."""
+        """Append a note to a task (notes no longer create task history entries)."""
 
         canonical_task_id = self._canonical_task_id(task_id)
         if not canonical_task_id:
@@ -711,23 +683,6 @@ class TaskService:
                     (task_id, note_type, content, now),
                 )
                 note_id = cursor.lastrowid
-                payload = {
-                    "action": "add_note",
-                    "note_type": note_type,
-                    "note_id": note_id,
-                    "content_length": len(content or ""),
-                }
-                await self._insert_history(
-                    db,
-                    task_id,
-                    "note",
-                    None,
-                    content,
-                    actor,
-                    event_type="task_action",
-                    payload=json.dumps(payload, ensure_ascii=False),
-                    created_at=now,
-                )
                 await db.commit()
         return TaskNoteRecord(
             id=note_id,