# After _status_callback_sync block, before run_sync():
def _clarify_callback(question: str, choices=None) -> str:
    if not _status_adapter or not _run_still_current():
        return ""
    import uuid, threading
    clarify_id = uuid.uuid4().hex
    event = threading.Event()
    _status_adapter._clarify_state[clarify_id] = {
        "event": event, "choice": None,
        "choices": choices or [], "question": question,
    }
    try:
        asyncio.run_coroutine_threadsafe(
            _status_adapter.send_clarify_prompt(
                chat_id=_status_chat_id,
                question=question, choices=choices or [],
                clarify_id=clarify_id,
                metadata=_status_thread_metadata,
            ), _loop_for_step,
        ).result(timeout=10)
    except Exception as _e:
        logger.error("clarify_callback send error: %s", _e)
        _status_adapter._clarify_state.pop(clarify_id, None)
        return ""
    logger.info("clarify pending stored: %s choices=%s", clarify_id, choices)
    event.wait(timeout=120)
    state = _status_adapter._clarify_state.pop(clarify_id, {"choice": ""})
    return state.get("choice", "")

# After agent.status_callback = _status_callback_sync:
agent.clarify_callback = _clarify_callback

self._clarify_state: Dict[str, dict] = {}

async def send_clarify_prompt(
    self, chat_id: str, question: str, choices: list,
    clarify_id: str, metadata=None,
) -> SendResult:
    if not self._bot:
        return SendResult(success=False, error="Not connected")
    try:
        buttons = []
        for i, choice in enumerate(choices):
            buttons.append([InlineKeyboardButton(
                choice, callback_data=f"clarify:{clarify_id}:{i}")])
        buttons.append([InlineKeyboardButton(
            "✗ Skip", callback_data=f"clarify:{clarify_id}:skip")])
        keyboard = InlineKeyboardMarkup(buttons)
        thread_id = metadata.get("thread_id") if metadata else None
        msg = await self._bot.send_message(
            chat_id=int(chat_id), text=question,
            reply_markup=keyboard,
            message_thread_id=int(thread_id) if thread_id else None,
            **self._link_preview_kwargs(),
        )
        return SendResult(success=True, message_id=str(msg.message_id))
    except Exception as e:
        logger.warning("[%s] send_clarify_prompt failed: %s", self.name, e)
        return SendResult(success=False, error=str(e))

# --- Clarify callbacks (clarify:id:idx) ---
if data.startswith("clarify:"):
    parts = data.split(":", 2)
    if len(parts) == 3:
        clarify_id = parts[1]
        choice_key = parts[2]
        state = self._clarify_state.get(clarify_id)
        if not state:
            await query.answer(text="This question is no longer active.")
            return
        if choice_key == "skip":
            user_choice = ""
        else:
            try:
                idx = int(choice_key)
            except ValueError:
                await query.answer(text="Invalid choice.")
                return
            choices = state.get("choices", [])
            if 0 <= idx < len(choices):
                user_choice = choices[idx]
            else:
                await query.answer(text="Invalid choice.")
                return
        state["choice"] = user_choice
        state["event"].set()
        user_display = getattr(query.from_user, "first_name", "User")
        label = f"Selected: {user_choice}" if user_choice else "Skipped"
        await query.answer(text=label)
        try:
            await query.edit_message_text(
                text=f"{state['question']}\n\n*{label}* by {user_display}",
                parse_mode=ParseMode.MARKDOWN, reply_markup=None,
            )
        except Exception:
            pass
        logger.info(
            "[%s] clarify resolved: %s idx=%s choice=%r",
            self.name, clarify_id, choice_key, user_choice,
        )
    return