@inline-chat/hermes-agent-adapter 1.0.1 → 1.2.0

package/plugin/inline/adapter.py

@@ -8,12 +8,17 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import concurrent.futures
+import contextvars
+import functools
 import hashlib
+import inspect
 import json
 import logging
 import math
 import mimetypes
 import os
+import queue
 import re
 import secrets
 import shlex
@@ -22,8 +27,11 @@ import signal
 import socket
 import subprocess
 import sys
+import threading
 import time
-from collections import OrderedDict
+import urllib.error
+import urllib.request
+from collections import OrderedDict, deque
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Dict, List, NamedTuple, Optional
@@ -52,11 +60,14 @@ from .message_actions import (
     build_inline_agent_action_input,
     build_inline_agent_action_turn_id,
     build_inline_system_action_id,
+    inline_message_widget_ids,
+    inline_widget_call,
     parse_inline_agent_action_reply_target,
     resolve_inline_message_action_ownership,
 )
-from .profile import bot_state_key, inline_env, legacy_state_dir, may_adopt_legacy_state, state_dir
+from .profile import bot_state_key, hermes_home, inline_env, legacy_state_dir, may_adopt_legacy_state, state_dir
 from .telemetry import capture_plugin_error
+from .widgets import has_widget_markup, scan_widgets, split_widget_aware, streaming_preview, without_widgets
 
 logger = logging.getLogger(__name__)
 
@@ -64,6 +75,7 @@ _DEFAULT_SIDECAR_PORT = 8794
 _ACTION_EDIT_RETRY_DELAY_SECONDS = 0.5
 _DEFAULT_SIDECAR_BIND = "127.0.0.1"
 _MAX_MESSAGE_LENGTH = 4000
+_APPROVAL_CHOICES = frozenset({"once", "session", "always", "deny"})
 _MODEL_PAGE_SIZE = 8
 _CHOICE_PICKER_MAX_CHOICES = 16
 _CHOICE_PICKER_TTL_SECONDS = 2 * 60
@@ -168,6 +180,29 @@ _INLINE_ENTITY_TYPE_NAMES = {
     14: "group_mention",
 }
 
+_APPROVAL_COMMAND_LIMIT = 2000
+_APPROVAL_FENCE_PATTERN = re.compile(r"(`{3,})[^\n]*\n(.*?)\n\1", re.DOTALL)
+# Same headings as OpenClaw's Inline, Slack and Discord approval cards.
+_APPROVAL_DECISION_HEADINGS = {
+    "once": "✅ Allowed once",
+    "session": "✅ Allowed for this session",
+    "always": "✅ Always allowed",
+    "deny": "❌ Denied",
+}
+_APPROVAL_EXPIRED_HEADING = "⌛ Approval expired"
+
+
+def _approval_command_block(command: str) -> str:
+    body = command if len(command) <= _APPROVAL_COMMAND_LIMIT else f"{command[:_APPROVAL_COMMAND_LIMIT]}…"
+    fence = "````" if "```" in body else "```"
+    return f"{fence}sh\n{body}\n{fence}"
+
+
+def _approval_card_text(heading: str, command: str) -> str:
+    """An answered or expired card: the outcome above the command it was for."""
+    return f"{heading}\n\n{_approval_command_block(command)}" if command else heading
+
+
 _ENV_REF_PATTERN = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
 _SIDECAR_RETRYABLE_KINDS = {"transient"}
 _INLINE_DISPLAY_DEFAULTS = {
@@ -175,7 +210,9 @@ _INLINE_DISPLAY_DEFAULTS = {
     "tool_progress_grouping": "accumulate",
     "cleanup_progress": True,
     "streaming": False,
-    "interim_assistant_messages": False,
+    # Hermes' own between-tool-calls messages: Friendly posts them as short updates and
+    # Detailed folds them into the progress message (see InlineAdapter.send).
+    "interim_assistant_messages": True,
     "show_reasoning": False,
     "tool_preview_length": 40,
     "busy_ack_detail": False,
@@ -843,6 +880,7 @@ def _apply_yaml_config(yaml_cfg: dict, platform_cfg: dict) -> Optional[dict]:
         "state_path",
         "settings_path",
         "parse_markdown",
+        "cron_mention_prefix",
         "require_mention",
         "strict_mention",
         "allowed_chats",
@@ -878,17 +916,578 @@ def _apply_yaml_config(yaml_cfg: dict, platform_cfg: dict) -> Optional[dict]:
     return extra
 
 
+async def _wait_for_exit(proc: subprocess.Popen, timeout: float) -> bool:
+    """Wait for ``proc`` without blocking the loop or taking an executor worker; False on timeout."""
+    deadline = time.monotonic() + timeout
+    while proc.poll() is None:
+        if time.monotonic() >= deadline:
+            return False
+        await asyncio.sleep(0.05)
+    return True
+
+
+def _token_count(tokens: int) -> str:
+    """"850", "439k", "1.2M": the bridge's wording for context sizes."""
+    if tokens < 1_000:
+        return str(tokens)
+    if tokens < 1_000_000:
+        return f"{tokens // 1_000}k"
+    tenths = tokens // 100_000
+    return f"{tenths // 10}M" if tenths % 10 == 0 else f"{tenths // 10}.{tenths % 10}M"
+
+
+def _accepts_keyword(fn: Callable[..., Any], name: str) -> bool:
+    """Whether a host callable takes keyword ``name`` (host APIs grow optional keywords)."""
+    try:
+        params = inspect.signature(fn).parameters
+    except (TypeError, ValueError):
+        return False
+    return name in params or any(p.kind is inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+
+# ── Detailed progress (Output: Detailed / Friendly) ──────────────────────────────────────
+# Hermes reports its work to plugins through public hooks: pre/post_tool_call,
+# subagent_start/stop and pre_approval_request/post_approval_response. Each hook finds the
+# Inline turn its session belongs to (gateway.session_context) and only enqueues in memory:
+# pre_tool_call blocks the tool while it runs. One worker thread per adapter posts the
+# events, in order, to the sidecar, which draws them with @inline-chat/agent-activity.
+
+_ACTIVITY_POST_TIMEOUT_SECONDS = 10.0
+_ACTIVITY_FLUSH_TIMEOUT_SECONDS = 30.0
+# The answer waits at most this long for "Worked for" to land above it.
+_ACTIVITY_FINAL_WAIT_SECONDS = 15.0
+# An interim message waits at most this long for the chat's mode before it posts as is.
+_ACTIVITY_MODE_WAIT_SECONDS = 5.0
+_ACTIVITY_OUTPUT_LIMIT = 2_000
+_ACTIVITY_DIFF_LIMIT = 8_000
+_ACTIVITY_TITLE_LIMIT = 100
+_ACTIVITY_PLAN_LIMIT = 50
+_ACTIVITY_HOOKS = (
+    "pre_tool_call", "post_tool_call", "subagent_start", "subagent_stop",
+    "pre_approval_request", "post_approval_response",
+)
+# Tools whose work is visible on its own: a question card, a message the agent sent.
+_ACTIVITY_SKIPPED_TOOLS = frozenset({"clarify"})
+_ACTIVITY_VISIBLE_INLINE_ACTIONS = frozenset({"send_message", "send_widget"})
+_ACTIVITY_COMMAND_TOOLS = frozenset({"terminal", "exec", "bash", "shell"})
+_ACTIVITY_READ_TOOLS = frozenset({"read_file", "file_read"})
+_ACTIVITY_SEARCH_TOOLS = frozenset({"search_files", "grep"})
+_ACTIVITY_EDIT_TOOLS = frozenset({"write_file", "file_write", "file_edit", "patch", "apply_patch"})
+_ACTIVITY_WEB_SEARCH_TOOLS = frozenset({"web_search", "x_search"})
+_ACTIVITY_PLAN_TOOLS = frozenset({"todo", "todo_list"})
+# Titles never come from a command, output or reasoning: only the tool and its explicit intent.
+_ACTIVITY_TOOL_TITLES = {
+    "execute_code": "Ran code",
+    "browser": "Used the browser",
+    "browser_exec": "Used the browser",
+    "browser_cdp": "Used the browser",
+    "browser_dialog": "Used the browser",
+    "browser_vault": "Used the browser",
+    "web_extract": "Read a web page",
+    "tool_describe": "Checked available tools",
+    "skill_view": "Read instructions",
+    "skills_list": "Listed skills",
+    "delegate_task": "Delegated a task",
+    "image_generate": "Generated an image",
+    "video_generate": "Generated a video",
+    "vision_analyze": "Looked at an image",
+    "video_analyze": "Watched a video",
+    "text_to_speech": "Generated speech",
+    "session_search": "Searched past sessions",
+    "memory": "Updated memory",
+    "read_terminal": "Read terminal output",
+    "close_terminal": "Closed a terminal",
+    "process_manage": "Managed a background process",
+    "cronjob_manage": "Managed scheduled jobs",
+    "skill_manage": "Managed skills",
+}
+
+_ACTIVITY_LOCK = threading.Lock()
+# Set while the adapter answers on its own (a /threads reply, a button's fallback, a question):
+# those sends are neither Hermes' answer nor its commentary, so a turn's progress ignores them.
+_ACTIVITY_LOCAL_SEND: contextvars.ContextVar[bool] = contextvars.ContextVar("inline_activity_local_send", default=False)
+# (chat_id, thread_id) as Hermes binds them for the turn's session -> open turns, oldest first.
+_ACTIVITY_TURNS: Dict[tuple[str, str], List["_ActivityTurn"]] = {}
+_ACTIVITY_LOGGED_FAILURES: set[str] = set()
+# gateway.session_context.get_session_env, resolved off the hook path.
+_ACTIVITY_SESSION_ENV: Optional[Callable[..., Any]] = None
+
+
+def _is_hermes_heartbeat(content: Any) -> bool:
+    """Hermes' long-running "⏳ Working — N min" notice; every locale starts it with ⏳."""
+    return isinstance(content, str) and content.lstrip().startswith("⏳")
+
+
+def _activity_local_sends(fn: Callable[..., Any]) -> Callable[..., Any]:
+    @functools.wraps(fn)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        token = _ACTIVITY_LOCAL_SEND.set(True)
+        try:
+            return await fn(*args, **kwargs)
+        finally:
+            _ACTIVITY_LOCAL_SEND.reset(token)
+
+    return wrapper
+
+
+def _activity_log_failure(operation: str, exc: BaseException) -> None:
+    """Progress never breaks a turn: log the first failure of each kind, then stay quiet."""
+    if operation in _ACTIVITY_LOGGED_FAILURES:
+        logger.debug("[inline] progress %s failed: %s", operation, exc)
+        return
+    _ACTIVITY_LOGGED_FAILURES.add(operation)
+    logger.warning("[inline] progress %s failed: %s: %s; the turn goes on without it", operation, type(exc).__name__, exc)
+
+
+def _activity_session_env_reader() -> Optional[Callable[..., Any]]:
+    global _ACTIVITY_SESSION_ENV
+    if _ACTIVITY_SESSION_ENV is None:
+        try:
+            from gateway.session_context import get_session_env
+            _ACTIVITY_SESSION_ENV = get_session_env
+        except Exception:
+            return None
+    return _ACTIVITY_SESSION_ENV
+
+
+def _activity_str(value: Any) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _activity_tail(text: str, limit: int) -> str:
+    return text if len(text) <= limit else text[-limit:]
+
+
+def _activity_json(value: Any) -> Any:
+    if isinstance(value, (dict, list)):
+        return value
+    if isinstance(value, str) and value[:1] in {"{", "["}:
+        try:
+            return json.loads(value)
+        except ValueError:
+            return None
+    return None
+
+
+def _activity_plan_steps(todos: Any) -> List[Dict[str, str]]:
+    steps: List[Dict[str, str]] = []
+    for todo in todos if isinstance(todos, list) else []:
+        if not isinstance(todo, dict):
+            continue
+        text = _activity_str(todo.get("content"))
+        if not text:
+            continue
+        status = _activity_str(todo.get("status"))
+        if status == "cancelled":
+            steps.append({"text": f"{text} (cancelled)", "status": "completed"})
+        else:
+            steps.append({"text": text, "status": status if status in {"in_progress", "completed"} else "pending"})
+        if len(steps) >= _ACTIVITY_PLAN_LIMIT:
+            break
+    return steps
+
+
+def _activity_tool_body(name: str, args: Any) -> Optional[Dict[str, Any]]:
+    """The row a Hermes tool call starts, or None for tools that show no row."""
+    args = args if isinstance(args, dict) else {}
+    if name in _ACTIVITY_SKIPPED_TOOLS or name == "delegate_task":
+        # Sub-agents draw their own rows through subagent_start/stop.
+        return None
+    if name == "inline":
+        action = _activity_str(args.get("action"))
+        if action in _ACTIVITY_VISIBLE_INLINE_ACTIONS:
+            return None
+        return {"kind": "tool", "name": "inline", "title": f"Inline: {action.replace('_', ' ')}" if action else "Used Inline"}
+    if name in _ACTIVITY_COMMAND_TOOLS:
+        command = _activity_str(args.get("command"))
+        return {"kind": "command", "command": command} if command else {"kind": "tool", "name": name, "title": "Ran a command"}
+    path = _activity_str(args.get("path")) or _activity_str(args.get("file_path"))
+    if name in _ACTIVITY_READ_TOOLS and path:
+        return {"kind": "read", "path": path}
+    if name in _ACTIVITY_SEARCH_TOOLS:
+        query = _activity_str(args.get("pattern")) or _activity_str(args.get("query"))
+        body: Dict[str, Any] = {"kind": "search"}
+        if query:
+            body["query"] = query
+        if path and path != ".":
+            body["path"] = path
+        return body
+    if name in _ACTIVITY_EDIT_TOOLS:
+        if path:
+            return {"kind": "edit", "files": [{"path": path}]}
+        return {"kind": "tool", "name": name, "title": "Edited files"}
+    if name in _ACTIVITY_WEB_SEARCH_TOOLS:
+        query = _activity_str(args.get("query"))
+        return {"kind": "web", "query": query} if query else {"kind": "tool", "name": name, "title": "Searched the web"}
+    if name == "web_extract" or name.startswith("browser"):
+        urls = args.get("urls") if isinstance(args.get("urls"), list) else []
+        url = _activity_str(args.get("url")) or next((_activity_str(u) for u in urls if _activity_str(u)), "")
+        if url:
+            return {"kind": "web", "url": url}
+    if name in _ACTIVITY_PLAN_TOOLS:
+        steps = _activity_plan_steps(args.get("todos"))
+        # Reading the list (no todos) changes nothing worth a row.
+        return {"kind": "plan", "steps": steps} if steps else None
+    description = " ".join(_activity_str(args.get("description")).split())
+    title = description or _ACTIVITY_TOOL_TITLES.get(name) or f"Used {name}"
+    return {"kind": "tool", "name": name, "title": title[:_ACTIVITY_TITLE_LIMIT]}
+
+
+def _activity_tool_result(name: str, args: Any, body: Dict[str, Any], result: Any, status: str, error: str) -> Dict[str, Any]:
+    """The row's body once the tool finished: output tails, exit codes, diffs, plans, errors."""
+    args = args if isinstance(args, dict) else {}
+    parsed = _activity_json(result)
+    record = parsed if isinstance(parsed, dict) else {}
+    kind = body.get("kind")
+    if kind == "command":
+        merged = dict(body)
+        output = record.get("output")
+        if isinstance(output, str) and output.strip():
+            merged["output"] = _activity_tail(output.rstrip(), _ACTIVITY_OUTPUT_LIMIT)
+        exit_code = record.get("exit_code")
+        if isinstance(exit_code, int) and not isinstance(exit_code, bool):
+            merged["exitCode"] = exit_code
+        return merged
+    if name in _ACTIVITY_EDIT_TOOLS:
+        files: List[Dict[str, Any]] = []
+        for key, change in (("files_created", "added"), ("files_deleted", "deleted"), ("files_modified", "modified")):
+            for path in record.get(key) or []:
+                if isinstance(path, str) and path.strip() and all(f["path"] != path for f in files):
+                    files.append({"path": path, "change": change})
+        path = _activity_str(args.get("path")) or _activity_str(args.get("file_path"))
+        if not files and path:
+            files.append({"path": path})
+        diff = record.get("diff")
+        if len(files) == 1 and isinstance(diff, str) and diff.strip():
+            files[0]["diff"] = _activity_tail(diff.rstrip(), _ACTIVITY_DIFF_LIMIT)
+        if files:
+            return {"kind": "edit", "files": files}
+        return body
+    if kind == "plan":
+        steps = _activity_plan_steps(record.get("todos"))
+        return {"kind": "plan", "steps": steps} if steps else body
+    if kind == "tool" and status == "error" and error:
+        return {**body, "error": error.splitlines()[0][:500]}
+    return body
+
+
+def _activity_agent_state(status: Any) -> str:
+    value = _activity_str(status).lower()
+    if value in {"interrupted", "cancelled", "canceled", "stopped"}:
+        return "cancelled"
+    if value in {"failed", "error", "timeout"}:
+        return "failed"
+    return "done"
+
+
+def _activity_same_text(left: Optional[str], right: Optional[str]) -> bool:
+    return bool(left) and bool(right) and " ".join(str(left).split()) == " ".join(str(right).split())
+
+
+class _ActivityTurn:
+    """One Hermes turn in one Inline chat, from on_processing_start to its answer."""
+
+    def __init__(self, *, pump: "_ActivityPump", turn_id: str, target: Dict[str, str], key: tuple[str, str], user_id: str, home: str):
+        self.pump = pump
+        self.turn_id = turn_id
+        self.target = target
+        self.key = key
+        self.user_id = user_id
+        self.home = home
+        # "detailed", "friendly", or "off" when the sidecar could not be reached; None until known.
+        self.mode: Optional[str] = None
+        self.mode_ready = threading.Event()
+        self.closed = False
+        # People's messages that arrived mid-turn: Hermes' busy notice replies to them, and
+        # that send is not this turn's answer.
+        self.later_messages: set[str] = set()
+        # Worker-thread state below.
+        self.rows: Dict[str, Dict[str, Any]] = {}
+        # (session, tool call) -> row; None for calls that show no row.
+        self.calls: Dict[tuple[str, str], Optional[str]] = {}
+        self.unmatched: Dict[tuple[str, str], deque] = {}
+        self.children: Dict[str, str] = {}
+        self.held: Optional[str] = None
+        self.next_row = 0
+
+
+def _activity_register(turn: _ActivityTurn) -> None:
+    with _ACTIVITY_LOCK:
+        _ACTIVITY_TURNS.setdefault(turn.key, []).append(turn)
+
+
+def _activity_unregister(turn: _ActivityTurn) -> None:
+    with _ACTIVITY_LOCK:
+        turns = _ACTIVITY_TURNS.get(turn.key)
+        if turns and turn in turns:
+            turns.remove(turn)
+        if not turns:
+            _ACTIVITY_TURNS.pop(turn.key, None)
+
+
+def _activity_turns_for(key: tuple[str, str]) -> List[_ActivityTurn]:
+    with _ACTIVITY_LOCK:
+        return list(_ACTIVITY_TURNS.get(key, ()))
+
+
+def _activity_turn_for_session() -> Optional[_ActivityTurn]:
+    """The open Inline turn the calling hook's session belongs to. In memory only: no I/O."""
+    get_env = _ACTIVITY_SESSION_ENV
+    if get_env is None or str(get_env("HERMES_SESSION_PLATFORM", "") or "") != "inline":
+        return None
+    key = (str(get_env("HERMES_SESSION_CHAT_ID", "") or ""), str(get_env("HERMES_SESSION_THREAD_ID", "") or ""))
+    candidates = _activity_turns_for(key)
+    if len(candidates) > 1:
+        # Per-user sessions share a group chat; several profiles' bots can share one too.
+        user_id = str(get_env("HERMES_SESSION_USER_ID", "") or "")
+        candidates = [turn for turn in candidates if turn.user_id == user_id] or candidates
+    if len(candidates) > 1:
+        home = str(hermes_home())
+        candidates = [turn for turn in candidates if turn.home == home] or candidates
+    return candidates[-1] if candidates else None
+
+
+def _activity_hook(kind: str) -> Callable[..., None]:
+    def callback(**kwargs: Any) -> None:
+        # pre_tool_call is fail-closed and blocks the tool while it runs: find the turn,
+        # copy the payload and enqueue it, nothing else. Never raise, never return a directive.
+        try:
+            turn = _activity_turn_for_session()
+            if turn is not None and not turn.closed and turn.mode not in {"friendly", "off"}:
+                payload = dict(kwargs)
+                if isinstance(payload.get("args"), dict):
+                    payload["args"] = dict(payload["args"])
+                turn.pump.put(kind, turn, payload)
+        except Exception as exc:
+            _activity_log_failure(f"hook {kind}", exc)
+        return None
+
+    callback.__name__ = f"inline_activity_{kind}"
+    return callback
+
+
+def _register_activity_hooks(ctx: Any) -> None:
+    register_hook = getattr(ctx, "register_hook", None)
+    if not callable(register_hook):
+        logger.info("[inline] this Hermes has no plugin hooks; Detailed output shows only the turn's time")
+        return
+    for name in _ACTIVITY_HOOKS:
+        try:
+            register_hook(name, _activity_hook(name))
+        except Exception as exc:
+            _activity_log_failure(f"register {name}", exc)
+
+
+class _ActivityPump:
+    """Posts one adapter's progress events to its sidecar, in order, off the agent's threads."""
+
+    def __init__(self, post: Callable[[str, Dict[str, Any], float], Dict[str, Any]]):
+        self._post = post
+        self._queue: "queue.SimpleQueue[Any]" = queue.SimpleQueue()
+        self._thread = threading.Thread(target=self._run, name="inline-activity", daemon=True)
+        self._thread.start()
+
+    def put(self, kind: str, turn: _ActivityTurn, payload: Any = None) -> None:
+        self._queue.put((kind, turn, payload, time.time()))
+
+    def flush(self, turn: _ActivityTurn) -> "concurrent.futures.Future[None]":
+        """Resolves once every event queued before it has reached Inline."""
+        future: "concurrent.futures.Future[None]" = concurrent.futures.Future()
+        self.put("flush", turn, future)
+        return future
+
+    def stop(self) -> None:
+        self._queue.put(None)
+
+    def _run(self) -> None:
+        while True:
+            item = self._queue.get()
+            if item is None:
+                return
+            kind, turn, payload, at = item
+            try:
+                self._handle(kind, turn, payload, at)
+            except Exception as exc:
+                _activity_log_failure(kind, exc)
+            finally:
+                if kind == "flush" and isinstance(payload, concurrent.futures.Future) and not payload.done():
+                    payload.set_result(None)
+
+    def _send(self, turn: _ActivityTurn, event: Dict[str, Any], at: float) -> Dict[str, Any]:
+        return self._post("/activity", {
+            "target": turn.target, "turnId": turn.turn_id, "event": event, "at": int(at * 1000),
+        }, _ACTIVITY_POST_TIMEOUT_SECONDS)
+
+    def _handle(self, kind: str, turn: _ActivityTurn, payload: Any, at: float) -> None:
+        if kind == "start":
+            try:
+                data = self._post("/activity", {
+                    "target": turn.target, "turnId": turn.turn_id, "event": {"type": "turn.start"},
+                    "at": int(at * 1000), "lazy": bool((payload or {}).get("lazy")),
+                }, _ACTIVITY_POST_TIMEOUT_SECONDS)
+                mode = str((data.get("result") or {}).get("mode") or "")
+                turn.mode = mode if mode in {"detailed", "friendly"} else "detailed"
+            except Exception:
+                turn.mode = "off"
+                raise
+            finally:
+                turn.mode_ready.set()
+            return
+        if turn.mode != "detailed":
+            return
+        if kind == "flush":
+            self._post("/activity/flush", {"target": turn.target, "turnId": turn.turn_id}, _ACTIVITY_FLUSH_TIMEOUT_SECONDS)
+            return
+        for event in self._events(kind, turn, payload):
+            self._send(turn, event, at)
+
+    def _events(self, kind: str, turn: _ActivityTurn, payload: Any) -> List[Dict[str, Any]]:
+        if kind == "commentary":
+            text = str(payload or "").strip()
+            if not text:
+                return []
+            # Held until the next event: an interim message that turns out to be the answer
+            # (Hermes then sends the same text as the final) is not drawn twice.
+            events = self._release_held(turn)
+            turn.held = text
+            return events
+        if kind == "end":
+            final = (payload or {}).get("final")
+            if turn.held and _activity_same_text(turn.held, final):
+                turn.held = None
+            return [*self._release_held(turn), {"type": "turn.end", "outcome": (payload or {}).get("outcome") or "success"}]
+        events = self._release_held(turn)
+        if kind == "split":
+            events.append({"type": "split"})
+        elif kind in {"pre_approval_request", "post_approval_response"}:
+            # Smart approval is decided by a model, not a person: nothing waits.
+            if _activity_str((payload or {}).get("surface")) != "smart":
+                events.append({"type": "waiting", "waiting": kind == "pre_approval_request"})
+        elif kind == "pre_tool_call":
+            events.extend(self._tool_start(turn, payload or {}))
+        elif kind == "post_tool_call":
+            events.extend(self._tool_end(turn, payload or {}))
+        elif kind == "subagent_start":
+            events.extend(self._agent_start(turn, payload or {}))
+        elif kind == "subagent_stop":
+            events.extend(self._agent_stop(turn, payload or {}))
+        return events
+
+    @staticmethod
+    def _release_held(turn: _ActivityTurn) -> List[Dict[str, Any]]:
+        held, turn.held = turn.held, None
+        return [{"type": "commentary", "text": held}] if held else []
+
+    @staticmethod
+    def _new_row(turn: _ActivityTurn, call_id: str) -> str:
+        if call_id and f"tool:{call_id}" not in turn.rows:
+            return f"tool:{call_id}"
+        turn.next_row += 1
+        return f"tool:#{turn.next_row}"
+
+    def _tool_start(self, turn: _ActivityTurn, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+        name = _activity_str(payload.get("tool_name"))
+        call_id = _activity_str(payload.get("tool_call_id"))
+        session_id = _activity_str(payload.get("session_id"))
+        body = _activity_tool_body(name, payload.get("args"))
+        if body is None:
+            if call_id:
+                turn.calls[(session_id, call_id)] = None
+            return []
+        # One plan per agent: later updates redraw the same row.
+        row_id = f"plan:{session_id or 'main'}" if body.get("kind") == "plan" else self._new_row(turn, call_id)
+        parent = turn.children.get(session_id)
+        turn.rows[row_id] = {"name": name, "args": payload.get("args"), "body": body}
+        if call_id:
+            turn.calls[(session_id, call_id)] = row_id
+        else:
+            turn.unmatched.setdefault((session_id, name), deque()).append(row_id)
+        event: Dict[str, Any] = {"type": "item", "id": row_id, "body": body, "state": "running"}
+        if parent:
+            event["parent"] = parent
+        return [event]
+
+    def _tool_end(self, turn: _ActivityTurn, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+        name = _activity_str(payload.get("tool_name"))
+        call_id = _activity_str(payload.get("tool_call_id"))
+        session_id = _activity_str(payload.get("session_id"))
+        status = _activity_str(payload.get("status")) or "ok"
+        error = _activity_str(payload.get("error_message"))
+        row_id: Optional[str] = None
+        if call_id and (session_id, call_id) in turn.calls:
+            row_id = turn.calls.pop((session_id, call_id))
+            if row_id is None and not (name == "delegate_task" and status == "error"):
+                return []
+        elif not call_id:
+            pending = turn.unmatched.get((session_id, name))
+            row_id = pending.popleft() if pending else None
+        event: Dict[str, Any] = {"type": "item", "state": "failed" if status == "error" else "done"}
+        row = turn.rows.get(row_id) if row_id else None
+        if row is None:
+            # No start seen (or a sub-agent hand-off that failed before it began): draw it now.
+            body = _activity_tool_body(name, payload.get("args"))
+            if body is None and name == "delegate_task" and status == "error":
+                body = {"kind": "tool", "name": name, "title": _ACTIVITY_TOOL_TITLES["delegate_task"]}
+            if body is None:
+                return []
+            row_id = self._new_row(turn, call_id)
+            row = {"name": name, "args": payload.get("args"), "body": body}
+            turn.rows[row_id] = row
+            parent = turn.children.get(session_id)
+            if parent:
+                event["parent"] = parent
+        event["id"] = row_id
+        event["body"] = _activity_tool_result(name, row.get("args"), row["body"], payload.get("result"), status, error)
+        duration = payload.get("duration_ms")
+        if isinstance(duration, (int, float)) and not isinstance(duration, bool) and duration >= 0:
+            event["durationMs"] = int(duration)
+        return [event]
+
+    @staticmethod
+    def _agent_start(turn: _ActivityTurn, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+        child = _activity_str(payload.get("child_subagent_id")) or _activity_str(payload.get("child_session_id"))
+        if not child:
+            return []
+        row_id = f"agent:{child}"
+        goal = _activity_str(payload.get("child_goal"))
+        body: Dict[str, Any] = {"kind": "agent"}
+        if goal:
+            body["title"] = " ".join(goal.splitlines()[0].split())[:_ACTIVITY_TITLE_LIMIT]
+        child_session = _activity_str(payload.get("child_session_id"))
+        if child_session:
+            turn.children[child_session] = row_id
+        event: Dict[str, Any] = {"type": "item", "id": row_id, "body": body, "state": "running"}
+        parent_subagent = _activity_str(payload.get("parent_subagent_id"))
+        parent = f"agent:{parent_subagent}" if parent_subagent else turn.children.get(_activity_str(payload.get("parent_session_id")))
+        if parent and parent != row_id:
+            event["parent"] = parent
+        return [event]
+
+    @staticmethod
+    def _agent_stop(turn: _ActivityTurn, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+        row_id = turn.children.get(_activity_str(payload.get("child_session_id")))
+        if not row_id:
+            return []
+        event: Dict[str, Any] = {"type": "item", "id": row_id, "state": _activity_agent_state(payload.get("child_status"))}
+        duration = payload.get("duration_ms")
+        if isinstance(duration, (int, float)) and not isinstance(duration, bool) and duration > 0:
+            event["durationMs"] = int(duration)
+        return [event]
+
+
 class InlineAdapter(BasePlatformAdapter):
     MAX_MESSAGE_LENGTH = _MAX_MESSAGE_LENGTH
     supports_code_blocks = True
     splits_long_messages = True
+    # Command preview on an approval card; Hermes sends a longer command whole before the card.
+    _EA_CMD_BUDGET = 2000
 
     def __init__(self, config: PlatformConfig, *, use_ephemeral_sidecar_port: bool = False):
         super().__init__(config, Platform("inline"))
         extra = config.extra or {}
 
         if _truthy(inline_env("INLINE_EXPERIMENTAL_AGENT_ACTIVITY")):
-            logger.warning("[inline] experimental tool timelines are unavailable; ignoring INLINE_EXPERIMENTAL_AGENT_ACTIVITY and using ordinary typing")
+            logger.warning("[inline] INLINE_EXPERIMENTAL_AGENT_ACTIVITY is ignored; progress follows the bot's Output setting (Detailed or Friendly)")
         self._token = _config_token(config)
         self._base_url = inline_env("INLINE_BASE_URL") or extra.get("base_url") or "https://api.inline.chat"
         self._sidecar_bind = _normalize_sidecar_bind(extra.get("sidecar_bind") or inline_env("INLINE_SIDECAR_BIND"))
@@ -910,6 +1509,10 @@ class InlineAdapter(BasePlatformAdapter):
         _configure_tool_sidecar(bind=self._sidecar_bind, port=self._sidecar_port, token=self._sidecar_token)
         self._node_bin = _find_node_bin() or "node"
         self._parse_markdown = _truthy(extra.get("parse_markdown") if "parse_markdown" in extra else inline_env("INLINE_PARSE_MARKDOWN"), True)
+        cron_mention_prefix = extra.get("cron_mention_prefix") if "cron_mention_prefix" in extra else inline_env("INLINE_CRON_MENTION_PREFIX")
+        self._cron_mention_prefix = cron_mention_prefix.strip() if isinstance(cron_mention_prefix, str) else ""
+        if self._cron_mention_prefix and not self._parse_markdown:
+            logger.warning("[inline] cron_mention_prefix needs parse_markdown=true; scheduled mentions are disabled")
         self._media_max_bytes = int(
             _normalize_positive_float(
                 extra.get("media_max_mb") if "media_max_mb" in extra else inline_env("INLINE_MEDIA_MAX_MB"),
@@ -1086,6 +1689,9 @@ class InlineAdapter(BasePlatformAdapter):
         self._clarify_choices: "OrderedDict[str, List[str]]" = OrderedDict()
         self._clarify_sessions: "OrderedDict[str, str]" = OrderedDict()
         self._approval_sessions: "OrderedDict[str, str]" = OrderedDict()
+        self._partial_sends: "OrderedDict[tuple, bool]" = OrderedDict()
+        self._approval_request_ids: "OrderedDict[str, str]" = OrderedDict()
+        self._approval_commands: "OrderedDict[str, str]" = OrderedDict()
         self._slash_sessions: "OrderedDict[str, str]" = OrderedDict()
         self._choice_picker_sessions: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
         self._update_prompt_sessions: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
@@ -1109,6 +1715,12 @@ class InlineAdapter(BasePlatformAdapter):
         self._reply_thread_overrides = self._load_reply_thread_overrides()
         # Threads the agent made for the message it is answering: (chat, message) -> thread.
         self._turn_threads: "OrderedDict[tuple[str, str], str]" = OrderedDict()
+        # Detailed progress: the worker that posts this adapter's turn events, and each
+        # processing event's turn (on_processing_start/complete receive the same event).
+        self._activity_pump: Optional[_ActivityPump] = None
+        self._activity_events: "OrderedDict[int, tuple[Any, _ActivityTurn]]" = OrderedDict()
+        self._activity_home = str(hermes_home())
+        self._activity_opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
         try:
             from . import tools as _inline_tools
             _inline_tools.configure_settings(self)
@@ -1369,6 +1981,7 @@ class InlineAdapter(BasePlatformAdapter):
         }
         if runner is None:
             return context
+        context["context_usage"] = self._session_context_usage(runner, source)
 
         try:
             from hermes_cli.config import load_config_readonly
@@ -1489,6 +2102,22 @@ class InlineAdapter(BasePlatformAdapter):
             )
         return context
 
+    @staticmethod
+    def _session_context_usage(runner: Any, source: Any) -> Optional[List[int]]:
+        """``[used, window]`` prompt tokens of the chat's resident Hermes agent, read like Hermes'
+        own ``/usage``; None before its first turn or once the agent was evicted."""
+        try:
+            agent = runner._resident_agent_for(runner._session_key_for_source(source))
+            compressor = getattr(agent, "context_compressor", None) if agent is not None else None
+            used = int(getattr(compressor, "last_prompt_tokens", 0) or 0)
+            window = int(getattr(compressor, "context_length", 0) or 0)
+        except Exception as exc:
+            _hermes_seam_unavailable(
+                "GatewayRunner._resident_agent_for", "Inline agent settings omit the context window", exc,
+            )
+            return None
+        return [used, window] if used > 0 and window > 0 else None
+
     @staticmethod
     def _bot_settings_revision(context: Dict[str, Any]) -> str:
         visible = {
@@ -1550,6 +2179,21 @@ class InlineAdapter(BasePlatformAdapter):
                     "options": [{**option, "disabled": False} for option in reasoning_options],
                 }},
             })
+        usage = context.get("context_usage")
+        if usage:
+            used, window = min(usage[0], usage[1]), usage[1]
+            percent = used * 100 // window
+            # The id carries the numbers: Inline's composer draws its context circle from
+            # ``session.context:<used>:<window>``, as it does for coding-agent bridges.
+            runtime_items.append({
+                "id": f"session.context:{usage[0]}:{window}", "label": "Context window",
+                "description": f"{_token_count(usage[0])} of {_token_count(window)} tokens used",
+                "disabled": True,
+                "control": {"oneofKind": "info", "info": {
+                    "text": f"{percent}% full",
+                    "tone": _INLINE_BOT_SETTINGS_TONE_WARNING if percent >= 90 else _INLINE_BOT_SETTINGS_TONE_NEUTRAL,
+                }},
+            })
         if not runtime_items:
             runtime_items.append({
                 "id": "runtime-unavailable", "label": "Runtime", "disabled": False,
@@ -1880,6 +2524,7 @@ class InlineAdapter(BasePlatformAdapter):
             rows.append({"actions": [self._action(f"{prefix}reset", "Reset")]})
         return {"rows": rows}
 
+    @_activity_local_sends
     async def _send_thread_status(
         self,
         *,
@@ -1896,6 +2541,7 @@ class InlineAdapter(BasePlatformAdapter):
             actions=self._thread_status_actions(display_chat_id=chat_id, target_chat_id=target_chat_id),
         )
 
+    @_activity_local_sends
     async def _handle_thread_command(
         self,
         *,
@@ -1938,6 +2584,7 @@ class InlineAdapter(BasePlatformAdapter):
             )
         return True
 
+    @_activity_local_sends
     async def _handle_follow_command(
         self,
         *,
@@ -1981,6 +2628,7 @@ class InlineAdapter(BasePlatformAdapter):
         await self.send(chat_id, body, reply_to=msg_id, metadata=metadata)
         return True
 
+    @_activity_local_sends
     async def _handle_inline_maintenance_command(
         self,
         *,
@@ -2037,6 +2685,7 @@ class InlineAdapter(BasePlatformAdapter):
             return False
         # Re-register under the profile scope the gateway connects this adapter in.
         _configure_tool_sidecar(bind=self._sidecar_bind, port=self._sidecar_port, token=self._sidecar_token)
+        self._activity_home = str(hermes_home())
         node_error = _node_version_error(self._node_bin)
         if node_error:
             self._set_fatal_error("NODE_UNSUPPORTED", node_error, retryable=False)
@@ -2110,6 +2759,7 @@ class InlineAdapter(BasePlatformAdapter):
         if self._bot_settings_tasks:
             await asyncio.gather(*self._bot_settings_tasks, return_exceptions=True)
             self._bot_settings_tasks.clear()
+        self._activity_stop()
         await self._stop_sidecar()
         if self._http_client is not None:
             await self._http_client.aclose()
@@ -2170,14 +2820,34 @@ class InlineAdapter(BasePlatformAdapter):
         raise RuntimeError(f"Inline sidecar did not become ready within {timeout}: {last_error}")
 
     async def _supervise_sidecar(self, proc: subprocess.Popen) -> None:
-        if proc.stdout is None:
+        """Log sidecar output. A quiet sidecar can go hours without a line, so its blocking
+        read runs on a thread of its own: on the loop's shared executor every sidecar would pin
+        a worker, and a gateway with more Inline bots than workers stalls every other
+        ``to_thread`` job (startup included)."""
+        stdout = proc.stdout
+        if stdout is None:
             return
-        loop = asyncio.get_event_loop()
-        while True:
+        loop = asyncio.get_running_loop()
+        lines: "asyncio.Queue[bytes]" = asyncio.Queue()
+
+        def hand_off(raw: bytes) -> None:
             try:
-                line = await loop.run_in_executor(None, proc.stdout.readline)
+                loop.call_soon_threadsafe(lines.put_nowait, raw)
+            except RuntimeError:
+                pass  # the loop closed first
+
+        def read() -> None:
+            try:
+                for raw in iter(stdout.readline, b""):
+                    hand_off(raw)
             except Exception:
-                return
+                pass
+            finally:
+                hand_off(b"")
+
+        threading.Thread(target=read, name="inline-sidecar-stdout", daemon=True).start()
+        while True:
+            line = await lines.get()
             if not line:
                 return
             text = line.decode("utf-8", "replace").rstrip()
@@ -2206,9 +2876,7 @@ class InlineAdapter(BasePlatformAdapter):
                     )
                 except Exception:
                     pass
-            try:
-                proc.wait(timeout=3.0)
-            except subprocess.TimeoutExpired:
+            if not await _wait_for_exit(proc, 3.0):
                 if sys.platform != "win32":
                     try:
                         os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
@@ -2216,9 +2884,7 @@ class InlineAdapter(BasePlatformAdapter):
                         proc.terminate()
                 else:
                     proc.terminate()
-                try:
-                    proc.wait(timeout=2.0)
-                except subprocess.TimeoutExpired:
+                if not await _wait_for_exit(proc, 2.0):
                     proc.kill()
         finally:
             self._sidecar_proc = None
@@ -2519,10 +3185,12 @@ class InlineAdapter(BasePlatformAdapter):
                 self._schedule_bot_settings_task(self._handle_bot_settings_item(event))
             return
         if kind == "message.action.invoke":
-            if await self._handle_action(event):
+            # A widget call names its widget, never a native control, so it skips system handlers.
+            widget_call = inline_widget_call(event) is not None
+            if not widget_call and await self._handle_action(event):
                 return
             ownership = resolve_inline_message_action_ownership(event.get("actionId"))
-            if ownership.owner == "system" and ownership.explicit:
+            if not widget_call and ownership.owner == "system" and ownership.explicit:
                 await self._answer_action(str(event.get("interactionId") or ""), "Action expired")
                 logger.info("[inline] dropped unhandled system action %s", event.get("actionId") or "")
                 return
@@ -2757,9 +3425,7 @@ class InlineAdapter(BasePlatformAdapter):
             await self.handle_message(MessageEvent(
                 text=text or "[Inline message with no text]", message_type=MessageType.TEXT,
                 source=source, raw_message=event,
-                message_id=build_inline_agent_action_turn_id(
-                    agent_action.get("messageId"), agent_action.get("interactionId"),
-                ) if agent_action else msg_id,
+                message_id=_agent_action_turn_message_id(agent_action, msg_id),
                 timestamp=self._timestamp(event.get("date") or msg.get("date")),
                 allow_gateway_control=not bool(agent_action),
             ))
@@ -2935,20 +3601,17 @@ class InlineAdapter(BasePlatformAdapter):
         # A bot's answer coming back needs no reply: the agent may stay silent instead of Hermes
         # posting its "needed a reply" warning. Hosts before reply_expected ignore this.
         answer_from_bot = sender_is_bot and not explicitly_mentions_me and not command_addressed_to_me
+        if not edit and sender_profile.get("bot") is not True:
+            # A person's message mid-turn steers the work: the progress message ends here and
+            # later work starts a new one. Hermes' steer mode reports nothing itself.
+            self._activity_split(session_chat_id, str(thread_id or ""), msg_id)
         await self.handle_message(MessageEvent(
             **({"reply_expected": False} if answer_from_bot and "reply_expected" in getattr(MessageEvent, "__dataclass_fields__", {}) else {}),
             text=text,
             message_type=message_type,
             source=source,
             raw_message=event,
-            message_id=(
-                build_inline_agent_action_turn_id(
-                    agent_action.get("messageId"),
-                    agent_action.get("interactionId"),
-                )
-                if agent_action
-                else msg_id
-            ),
+            message_id=_agent_action_turn_message_id(agent_action, msg_id),
             platform_update_id=int(event.get("seq") or 0) if str(event.get("seq") or "").isdigit() else None,
             media_urls=media_urls,
             media_types=media_types,
@@ -2982,6 +3645,12 @@ class InlineAdapter(BasePlatformAdapter):
         if not target:
             await self._answer_action(interaction_id, "Action expired or no longer accessible.")
             return
+        widget_call = inline_widget_call(event)
+        if widget_call is None and str(event.get("actionId") or "") in inline_message_widget_ids(target):
+            # Older realtime SDKs drop the call's name and payload but keep the widget ID.
+            widget_call = {}
+        if widget_call is not None:
+            event = {**event, "widgetCall": widget_call}
 
         synthetic_message = dict(target)
         for stale_key in ("actions", "attachments", "entities", "media", "reactions", "replies", "sender"):
@@ -4432,32 +5101,93 @@ class InlineAdapter(BasePlatformAdapter):
         _, approval_id, choice = parts
         choice = "once" if choice == "approve" else choice
         session_key = self._approval_sessions.get(approval_id)
-        if choice not in {"once", "session", "always", "deny"}:
+        if choice not in _APPROVAL_CHOICES:
             return False
         if not session_key:
-            await self._finish_action(event, "Approval expired", "Approval expired; the command was not run.")
+            command = self._approval_commands.pop(approval_id, None) or await self._approval_command_from_message(event)
+            await self._finish_action(event, "Approval expired", _approval_card_text(_APPROVAL_EXPIRED_HEADING, command))
             return True
         try:
-            from tools.approval import resolve_gateway_approval
-            count = resolve_gateway_approval(session_key, choice)
+            request_id = self._approval_request_ids.get(approval_id)
+            actor_id = str(event.get("actorUserId") or "").strip()
+            refusal = self._approval_refusal(session_key, actor_id, request_id)
+            if refusal:
+                # Another member's approval: leave the card live for the requester.
+                await self._answer_action(str(event.get("interactionId") or ""), refusal)
+                return True
+            count = self._resolve_approval(session_key, choice, request_id, actor_id)
             self._approval_sessions.pop(approval_id, None)
+            self._approval_request_ids.pop(approval_id, None)
+            command = self._approval_commands.pop(approval_id, None) or ""
             if not count:
-                await self._finish_action(event, "Approval expired", "Approval expired; the command was not run.")
+                await self._finish_action(event, "Approval expired", _approval_card_text(_APPROVAL_EXPIRED_HEADING, command))
                 return True
-            labels = {
-                "once": ("Approved once", "Approved once."),
-                "session": ("Approved for session", "Approved for this session."),
-                "always": ("Always allowed", "Always allowed."),
-                "deny": ("Denied", "Denied."),
+            toasts = {
+                "once": "Approved once",
+                "session": "Approved for session",
+                "always": "Always allowed",
+                "deny": "Denied",
             }
-            toast, text = labels[choice]
-            await self._finish_action(event, toast, text)
+            # Slack, Discord and OpenClaw's Inline card say who answered; a bare id is noise.
+            answered_by, _, _ = _inline_sender_identity(_inline_sender_profile(event))
+            heading = _APPROVAL_DECISION_HEADINGS[choice] + (f" by {answered_by}" if answered_by else "")
+            await self._finish_action(event, toasts[choice], _approval_card_text(heading, command))
             return True
         except Exception as exc:
             self._report_error("action.approval", exc)
             logger.exception("[inline] approval action failed")
             return True
 
+    async def _approval_command_from_message(self, event: Dict[str, Any]) -> str:
+        """Recover the command from the card itself when this process no longer has it (e.g. after a restart)."""
+        chat_id = str(event.get("chatId") or "")
+        message_id = str(event.get("messageId") or "")
+        msg = await self._fetch_message(chat_id, message_id) if chat_id and message_id else None
+        if not msg:
+            return ""
+        text = str(msg.get("message") or "")
+        units = text.encode("utf-16-le")
+        for entity in self._message_entities(msg):
+            if self._entity_kind(entity) != "pre":
+                continue
+            offset = _to_int(entity.get("offset"))
+            length = _to_int(entity.get("length"))
+            if offset is None or length is None or offset < 0 or length <= 0:
+                continue
+            return units[offset * 2 : (offset + length) * 2].decode("utf-16-le", errors="ignore").strip()
+        match = _APPROVAL_FENCE_PATTERN.search(text)
+        return match.group(2).strip() if match else ""
+
+    def _approval_refusal(self, session_key: str, actor_id: str, request_id: Optional[str]) -> Optional[str]:
+        """Hermes' approver rule (``approvals.approvers``) for a tap, or None when it may answer.
+        Hosts without the rule leave it to the chat access check every action already passed."""
+        try:
+            from gateway.approval_actor import approval_refusal
+        except ImportError:
+            return None
+        requester = approval_refusal(session_key, actor_id, extra=self.config.extra, request_id=request_id)
+        if not requester:
+            return None
+        try:
+            from gateway.approval_actor import refusal_text
+            return str(refusal_text(requester))
+        except ImportError:
+            return f"Only {requester} can answer this approval."
+
+    def _resolve_approval(self, session_key: str, choice: str, request_id: Optional[str], actor_id: str) -> int:
+        """Resolve only the request the card was sent for; once it settled (timeout, /approve)
+        the tap resolves nothing rather than the next one queued. A card without a request id
+        (hosts before 0.22.7) keeps the oldest-pending behaviour."""
+        from tools import approval as approval_mod
+        resolve_card = getattr(approval_mod, "resolve_gateway_approval_card", None)
+        if resolve_card is not None:
+            if _accepts_keyword(resolve_card, "actor_id"):
+                return resolve_card(session_key, choice, request_id, actor_id=actor_id or None, extra=self.config.extra)
+            return resolve_card(session_key, choice, request_id)
+        if request_id:
+            return approval_mod.resolve_gateway_approval(session_key, choice, request_id=request_id)
+        return approval_mod.resolve_gateway_approval(session_key, choice)
+
     async def _handle_slash_action(self, event: Dict[str, Any]) -> bool:
         action_id = str(event.get("actionId") or "")
         parts = action_id.split(":", 2)
@@ -4851,6 +5581,7 @@ class InlineAdapter(BasePlatformAdapter):
             logger.warning("[inline] expensive model check failed", exc_info=True)
             return None
 
+    @_activity_local_sends
     async def _edit_action_message(self, event: Dict[str, Any], text: str, actions: Optional[Dict[str, Any]] = None) -> SendResult:
         chat_id = str(event.get("chatId") or "")
         message_id = str(event.get("messageId") or "")
@@ -4890,8 +5621,49 @@ class InlineAdapter(BasePlatformAdapter):
         metadata: Optional[Dict[str, Any]] = None,
         actions: Optional[Dict[str, Any]] = None,
     ) -> SendResult:
+        """Hermes' send. Within a turn, the first send not marked ``_interim_send`` is the
+        answer: Detailed progress closes ("Worked for") above it first. A Detailed turn's
+        interim messages (Hermes' commentary between tool calls) go into the progress message
+        instead of the chat. ``_interim_send`` and every other metadata key stay off the wire."""
+        turn = None if _ACTIVITY_LOCAL_SEND.get() else self._activity_turn_for_send(chat_id, metadata)
+        if turn is not None:
+            if (metadata or {}).get("_interim_send"):
+                if self._activity_foldable(content, metadata, actions) and await self._activity_is_detailed(turn):
+                    if _is_hermes_heartbeat(content):
+                        # The progress message's live timer already says this.
+                        return _send_result(
+                            success=False,
+                            error="the Inline progress message shows the elapsed time",
+                            raw_response={"inlineActivity": "heartbeat"},
+                            retryable=False,
+                        )
+                    turn.pump.put("commentary", turn, str(content))
+                    # Not a chat message: reported undelivered so Hermes never counts it as the
+                    # answer (its final-reply dedup matches delivered interim text) and the answer
+                    # still posts. Nothing is retried; the text shows in the progress message.
+                    return _send_result(
+                        success=False,
+                        error="shown in the Inline progress message",
+                        raw_response={"inlineActivity": "commentary"},
+                        retryable=False,
+                    )
+            elif not (reply_to and str(reply_to) in turn.later_messages):
+                await self._activity_close_before_answer(turn, content)
+        return await self._send_message(chat_id, content, reply_to=reply_to, metadata=metadata, actions=actions)
+
+    async def _send_message(
+        self,
+        chat_id: str,
+        content: str,
+        reply_to: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        actions: Optional[Dict[str, Any]] = None,
+    ) -> SendResult:
+        requested = content
+        content = self._with_cron_mention(content, metadata)
         metadata = self._with_turn_thread(chat_id, reply_to, metadata)
         target = self._target_for(chat_id, metadata)
+        send_options = {"sendMode": "silent"} if (metadata or {}).get("notify") is False else {}
         agent_action_target = parse_inline_agent_action_reply_target(reply_to)
         if agent_action_target:
             chunks = self.truncate_message(self.format_message(content), self.MAX_MESSAGE_LENGTH)
@@ -4916,10 +5688,13 @@ class InlineAdapter(BasePlatformAdapter):
                         "text": chunk,
                         "parseMarkdown": self._parse_markdown,
                         "replyToMsgId": previous_id,
+                        **send_options,
                     })
                     raw_responses.append(continuation.raw_response)
                     if not continuation.success:
-                        return continuation
+                        return self._partial_send_failure(
+                            chat_id, requested, continuation, previous_id, continuation_ids, len(chunks), raw_responses,
+                        )
                     if continuation.message_id:
                         previous_id = str(continuation.message_id)
                         continuation_ids.append(previous_id)
@@ -4945,6 +5720,7 @@ class InlineAdapter(BasePlatformAdapter):
                 "target": target,
                 "text": chunk,
                 "parseMarkdown": self._parse_markdown,
+                **send_options,
             }
             if reply_to and index == 0:
                 body["replyToMsgId"] = str(reply_to)
@@ -4952,7 +5728,12 @@ class InlineAdapter(BasePlatformAdapter):
                 body["actions"] = actions
             last_result = await self._send_sidecar("/send", body)
             if not last_result.success:
-                return last_result
+                if not message_ids:
+                    return last_result
+                return self._partial_send_failure(
+                    chat_id, requested, last_result, message_ids[-1], message_ids[:-1], len(chunks),
+                    [*raw_responses, getattr(last_result, "raw_response", None)],
+                )
             if not marked_visible:
                 self._mark_reply_thread_visible(target)
                 marked_visible = True
@@ -5014,7 +5795,13 @@ class InlineAdapter(BasePlatformAdapter):
         metadata: Optional[Dict[str, Any]] = None,
     ) -> SendResult:
         text = self.format_message(content)
-        if len(text) > self.MAX_MESSAGE_LENGTH:
+        several_widgets = False
+        if self._parse_markdown and has_widget_markup(text):
+            if not finalize:
+                # A streaming preview must not send a widget whose closing tag hasn't arrived.
+                text = streaming_preview(text)
+            several_widgets = len(scan_widgets(text).widgets) > 1
+        if len(text) > self.MAX_MESSAGE_LENGTH or several_widgets:
             if finalize:
                 return await self._edit_overflow_split(chat_id, message_id, content, metadata=metadata)
             text = self.truncate_message(text, self.MAX_MESSAGE_LENGTH)[0]
@@ -5174,6 +5961,7 @@ class InlineAdapter(BasePlatformAdapter):
 
     async def on_processing_start(self, event: MessageEvent) -> None:
         """Mark an inbound message while Hermes is actively processing it."""
+        self._activity_begin(event)
         reaction_target = self._processing_reaction_target(event)
         if not reaction_target:
             return
@@ -5191,6 +5979,7 @@ class InlineAdapter(BasePlatformAdapter):
 
     async def on_processing_complete(self, event: MessageEvent, outcome: Any) -> None:
         """Replace the processing marker without affecting response delivery."""
+        self._activity_finish(event, outcome)
         reaction_target = self._processing_reaction_target(event)
         if not reaction_target:
             return
@@ -5205,6 +5994,140 @@ class InlineAdapter(BasePlatformAdapter):
         elif outcome_name == "failure":
             await self._set_processing_reaction(target, message_id, "❌")
 
+    # ── Detailed progress ───────────────────────────────────────────────────────────────
+
+    def _activity_post(self, path: str, body: Dict[str, Any], timeout: float) -> Dict[str, Any]:
+        """The activity worker's own blocking sidecar call (it runs on its own thread)."""
+        request = urllib.request.Request(
+            f"{self._sidecar_base_url()}{path}",
+            data=json.dumps(body).encode("utf-8"),
+            headers={"content-type": "application/json; charset=utf-8", "x-hermes-sidecar-token": self._sidecar_token},
+            method="POST",
+        )
+        try:
+            # Loopback IPC: never through a configured HTTP proxy.
+            with self._activity_opener.open(request, timeout=timeout) as response:
+                raw = response.read().decode("utf-8")
+                status = response.status
+        except urllib.error.HTTPError as exc:
+            raw = exc.read().decode("utf-8", errors="replace")
+            status = exc.code
+        data = json.loads(raw or "{}")
+        if status != 200 or not data.get("ok"):
+            raise InlineSidecarError(path, status, str(data.get("error") or f"Inline sidecar {path} failed"), str(data.get("errorKind") or "unknown"), data)
+        return data
+
+    def _activity_begin(self, event: Any) -> None:
+        """Opens Detailed progress for a turn; the sidecar resolves the chat's mode."""
+        try:
+            if self._http_client is None:
+                return  # Not connected (or a one-shot sender): no turns to draw.
+            source = getattr(event, "source", None)
+            chat_id = str(getattr(source, "chat_id", None) or "").strip()
+            if not chat_id:
+                return
+            thread_id = str(getattr(source, "thread_id", None) or "").strip()
+            if _activity_session_env_reader() is None:
+                return
+            if self._activity_pump is None:
+                self._activity_pump = _ActivityPump(self._activity_post)
+            turn = _ActivityTurn(
+                pump=self._activity_pump,
+                turn_id=secrets.token_hex(8),
+                target=self._target_for(chat_id, {"thread_id": thread_id} if thread_id else None),
+                key=(chat_id, thread_id),
+                user_id=str(getattr(source, "user_id", None) or ""),
+                home=self._activity_home,
+            )
+            is_command = getattr(event, "is_command", None)
+            # A slash command usually answers without working: show "Working" only once work starts.
+            lazy = bool(is_command()) if callable(is_command) else False
+            self._remember(self._activity_events, id(event), (event, turn))
+            _activity_register(turn)
+            turn.pump.put("start", turn, {"lazy": lazy})
+        except Exception as exc:
+            _activity_log_failure("turn start", exc)
+
+    def _activity_finish(self, event: Any, outcome: Any) -> None:
+        """The fallback close for a turn that never sent an answer (empty, failed, stopped)."""
+        try:
+            entry = self._activity_events.pop(id(event), None)
+            if entry is None or entry[0] is not event:
+                return
+            turn = entry[1]
+            if turn.closed:
+                return
+            name = str(getattr(outcome, "value", outcome) or "").strip().lower()
+            self._activity_close(turn, {"outcome": name if name in {"success", "failure", "cancelled"} else "success"})
+        except Exception as exc:
+            _activity_log_failure("turn end", exc)
+
+    def _activity_close(self, turn: _ActivityTurn, payload: Dict[str, Any]) -> None:
+        turn.closed = True
+        _activity_unregister(turn)
+        turn.pump.put("end", turn, payload)
+
+    async def _activity_close_before_answer(self, turn: _ActivityTurn, final_text: Optional[str]) -> None:
+        """Closes the progress message and waits (bounded) until it reached Inline."""
+        if turn.closed:
+            return
+        try:
+            self._activity_close(turn, {"outcome": "success", "final": final_text})
+            await asyncio.wait_for(asyncio.wrap_future(turn.pump.flush(turn)), timeout=_ACTIVITY_FINAL_WAIT_SECONDS)
+        except Exception as exc:
+            _activity_log_failure("answer ordering", exc)
+
+    def _activity_turn_for_send(self, chat_id: Any, metadata: Optional[Dict[str, Any]]) -> Optional[_ActivityTurn]:
+        """This adapter's open turn for a Hermes send, matched as Hermes addresses the turn."""
+        if self._activity_pump is None:
+            return None
+        thread_id = str((metadata or {}).get("thread_id") or "").strip()
+        turns = [
+            turn for turn in _activity_turns_for((str(chat_id or "").strip(), thread_id))
+            if turn.pump is self._activity_pump and not turn.closed
+        ]
+        return turns[-1] if turns else None
+
+    @staticmethod
+    def _activity_foldable(content: Any, metadata: Optional[Dict[str, Any]], actions: Optional[Dict[str, Any]]) -> bool:
+        meta = metadata or {}
+        if meta.get("non_conversational") or meta.get("is_approval_prompt") or actions is not None:
+            return False
+        text = content if isinstance(content, str) else ""
+        return bool(text.strip()) and not has_widget_markup(text)
+
+    async def _activity_is_detailed(self, turn: _ActivityTurn) -> bool:
+        if not turn.mode_ready.is_set():
+            await asyncio.get_running_loop().run_in_executor(None, turn.mode_ready.wait, _ACTIVITY_MODE_WAIT_SECONDS)
+        return turn.mode == "detailed"
+
+    def _activity_split(self, chat_id: str, thread_id: str, message_id: str) -> None:
+        try:
+            if self._activity_pump is None:
+                return
+            for turn in _activity_turns_for((str(chat_id or ""), thread_id)):
+                if turn.pump is self._activity_pump and not turn.closed:
+                    if message_id and len(turn.later_messages) < 64:
+                        turn.later_messages.add(str(message_id))
+                    if turn.mode != "friendly":
+                        turn.pump.put("split", turn)
+        except Exception as exc:
+            _activity_log_failure("split", exc)
+
+    def _activity_stop(self) -> None:
+        pump, self._activity_pump = self._activity_pump, None
+        if pump is None:
+            return
+        with _ACTIVITY_LOCK:
+            for key in list(_ACTIVITY_TURNS):
+                kept = [turn for turn in _ACTIVITY_TURNS[key] if turn.pump is not pump]
+                if kept:
+                    _ACTIVITY_TURNS[key] = kept
+                else:
+                    _ACTIVITY_TURNS.pop(key, None)
+        self._activity_events.clear()
+        pump.stop()
+
     async def send_image_file(self, chat_id: str, image_path: str, caption: Optional[str] = None, reply_to: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> SendResult:
         return await self._send_attachment(chat_id, image_path, "photo", caption, reply_to, metadata=metadata)
 
@@ -5232,6 +6155,10 @@ class InlineAdapter(BasePlatformAdapter):
         return await self._send_attachment(chat_id, audio_path, "voice", caption, reply_to, metadata=metadata)
 
     async def _send_attachment(self, chat_id: str, file_path: str, kind: str, caption: Optional[str], reply_to: Optional[str], file_name: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> SendResult:
+        turn = None if _ACTIVITY_LOCAL_SEND.get() else self._activity_turn_for_send(chat_id, metadata)
+        if turn is not None and not (metadata or {}).get("_interim_send"):
+            # An answer that is only media (or TTS) also lands below "Worked for".
+            await self._activity_close_before_answer(turn, None)
         safe_path = self.validate_media_delivery_path(file_path)
         if not safe_path:
             return _send_result(success=False, error=f"unsafe or missing attachment path: {file_path}", error_kind="bad_format")
@@ -5281,7 +6208,12 @@ class InlineAdapter(BasePlatformAdapter):
         if not choices:
             from tools.clarify_gateway import mark_awaiting_text
             mark_awaiting_text(clarify_id)
-            return await self.send(chat_id, f"Clarify: {question}", metadata=metadata)
+            # A question, not the answer: the turn's progress stays open below it.
+            token = _ACTIVITY_LOCAL_SEND.set(True)
+            try:
+                return await self.send(chat_id, f"Clarify: {question}", metadata=metadata)
+            finally:
+                _ACTIVITY_LOCAL_SEND.reset(token)
         clean_choices = [str(c).strip() for c in choices if str(c).strip()][:10]
         self._remember(self._clarify_sessions, clarify_id, session_key)
         self._remember(self._clarify_choices, clarify_id, clean_choices)
@@ -5298,35 +6230,31 @@ class InlineAdapter(BasePlatformAdapter):
             "actions": {"rows": self._action_rows(actions)},
         })
 
-    async def send_exec_approval(
-        self,
-        chat_id: str,
-        command: str,
-        session_key: str,
-        description: str = "dangerous command",
-        metadata: Optional[Dict[str, Any]] = None,
-        allow_permanent: bool = True,
-        allow_session: bool = True,
-        smart_denied: bool = False,
-    ) -> SendResult:
+    async def _send_exec_approval_prompt(self, prompt: Any) -> SendResult:
+        """Draw Hermes' exec-approval prompt as an Inline button card.
+
+        Hermes' ``send_exec_approval`` owns the wording, a truncated command's full send and
+        the Deny-only gate of newer hosts; overriding this hook is also how Hermes knows the
+        adapter has native buttons. Inline only draws the offered choices and remembers which
+        request the card answers, so a tap never resolves a different one."""
         approval_id = secrets.token_hex(6)
-        text = f"Command approval required\n\n```\n{command[:2000]}\n```\n\nReason: {description}"
-        if smart_denied:
-            text += "\n\nSmart DENY: owner override applies to this one operation only."
-        actions = [self._action(f"appr:{approval_id}:once", "Allow Once")]
-        if not smart_denied and allow_session:
-            actions.append(self._action(f"appr:{approval_id}:session", "Allow for Session"))
-            if allow_permanent:
-                actions.append(self._action(f"appr:{approval_id}:always", "Always Allow"))
-        actions.append(self._action(f"appr:{approval_id}:deny", "Deny"))
+        actions = [
+            self._action(f"appr:{approval_id}:{choice}", str(label))
+            for label, choice, _style in prompt.actions
+            if choice in _APPROVAL_CHOICES
+        ]
         result = await self._send_sidecar("/send", {
-            "target": self._target_for(chat_id, metadata),
-            "text": text,
+            "target": self._target_for(prompt.chat_id, prompt.metadata),
+            "text": prompt.text,
             "parseMarkdown": self._parse_markdown,
             "actions": {"rows": self._action_rows(actions)},
         })
         if result.success:
-            self._remember(self._approval_sessions, approval_id, session_key)
+            self._remember(self._approval_sessions, approval_id, prompt.session_key)
+            self._remember(self._approval_commands, approval_id, str(getattr(prompt, "command", "") or ""))
+            request_id = getattr(prompt, "request_id", None)
+            if request_id:
+                self._remember(self._approval_request_ids, approval_id, str(request_id))
         return result
 
     async def send_slash_confirm(self, chat_id: str, title: str, message: str, session_key: str, confirm_id: str, metadata: Optional[Dict[str, Any]] = None) -> SendResult:
@@ -5642,6 +6570,81 @@ class InlineAdapter(BasePlatformAdapter):
             out["parent_message_id"] = parent_message_id
         return out
 
+    def _with_cron_mention(self, content: str, metadata: Optional[Dict[str, Any]]) -> str:
+        # Hermes identifies scheduled text sends with job_id. notify also appears
+        # on ordinary replies, so it cannot identify a cron on its own. Decorate
+        # before chunking to mention once, while preserving the supplied body.
+        meta = metadata or {}
+        prefix = self._cron_mention_prefix
+        if not prefix or not self._parse_markdown or not meta.get("job_id") or meta.get("notify") is False:
+            return content
+        if not content or not content.strip() or content.startswith(prefix):
+            return content
+        return f"{prefix}\n\n{content}"
+
+    def truncate_message(
+        self,
+        content: str,
+        max_length: int = _MAX_MESSAGE_LENGTH,
+        len_fn: Optional[Callable[[str], int]] = None,
+    ) -> List[str]:
+        """Hermes splitting, except a widget block is never cut or shares a message with another."""
+        if getattr(self, "_parse_markdown", True):
+            def split_plain(text: str, limit: int) -> List[str]:
+                pieces = self._base_truncate(text, limit, len_fn)
+                # Upstream numbers multi-part output; the parts here are pieces of one reply.
+                return [piece.removesuffix(f" ({i + 1}/{len(pieces)})") for i, piece in enumerate(pieces)]
+
+            chunks = split_widget_aware(content, max_length, split_plain, len_fn or len)
+            if chunks is not None:
+                return chunks
+        return self._base_truncate(content, max_length, len_fn)
+
+    def _base_truncate(self, content: str, max_length: int, len_fn: Optional[Callable[[str], int]]) -> List[str]:
+        base = super().truncate_message
+        if len_fn is not None and _accepts_keyword(base, "len_fn"):
+            return list(base(content, max_length, len_fn=len_fn))
+        return list(base(content, max_length))
+
+    def _partial_send_failure(
+        self, chat_id: str, requested: str, failed: SendResult, last_delivered_id: str,
+        delivered_continuations: List[str], total_chunks: int, raw_responses: List[Any],
+    ) -> SendResult:
+        """A later chunk failed after earlier ones were delivered. ``partial_overflow`` tells Hermes
+        (0.22.7+) not to resend the visible head as plain text; older hosts are stopped in
+        ``_send_plain_fallback``. Either way the reply is not posted twice."""
+        if getattr(BasePlatformAdapter, "_is_partial_delivery", None) is None:
+            self._remember(self._partial_sends, (self._chat_key(chat_id), requested), True, limit=64)
+        return _send_result(
+            success=False,
+            message_id=last_delivered_id,
+            error=failed.error or "continuation failed",
+            error_kind=getattr(failed, "error_kind", None),
+            retryable=bool(getattr(failed, "retryable", False)),
+            raw_response={
+                "partial_overflow": True,
+                "delivered_chunks": 1 + len(delivered_continuations),
+                "total_chunks": total_chunks,
+                "last_message_id": last_delivered_id,
+                "continuation_message_ids": tuple(delivered_continuations),
+                "responses": raw_responses,
+            },
+            continuation_message_ids=tuple(delivered_continuations),
+        )
+
+    async def _send_plain_fallback(self, chat_id: str, content: str, *, reply_to: Optional[str], metadata: Any) -> SendResult:
+        if self._partial_sends.pop((self._chat_key(chat_id), content), None):
+            # Part of this reply is already in the chat: resending it would post that part twice.
+            logger.warning("[inline] send failed after partial delivery; not resending it as plain text")
+            return _send_result(success=False, error="send failed after partial delivery", error_kind="bad_format")
+        # A widget the server rejected would fail the fallback too; keep the prose and say so.
+        if getattr(self, "_parse_markdown", True) and has_widget_markup(content):
+            content = without_widgets(content)
+        base = getattr(super(), "_send_plain_fallback", None)
+        if base is None:
+            return await self.send(chat_id, content, reply_to=reply_to, metadata=metadata)
+        return await base(chat_id, content, reply_to=reply_to, metadata=metadata)
+
     def format_message(self, content: str) -> str:
         # parseMarkdown=false means literal input at every Inline API boundary.
         # Preserve that contract instead of silently rewriting the caller's text.
@@ -5679,8 +6682,9 @@ class InlineAdapter(BasePlatformAdapter):
     def _send_retry_is_final(self, result: SendResult) -> bool:
         # The request reached Inline but its result was lost. A retry or plain-text
         # fallback would post the message twice; Hermes treats timeouts the same way.
+        # Commentary folded into a progress message is shown already: never resend it.
         raw = getattr(result, "raw_response", None)
-        return isinstance(raw, dict) and raw.get("outcomeUnknown") is True
+        return isinstance(raw, dict) and (raw.get("outcomeUnknown") is True or "inlineActivity" in raw)
 
     async def _send_sidecar(self, path: str, body: Dict[str, Any]) -> SendResult:
         try:
@@ -5731,6 +6735,13 @@ class InlineAdapter(BasePlatformAdapter):
         return _sidecar_base_url(self._sidecar_bind, self._sidecar_port)
 
 
+def _agent_action_turn_message_id(agent_action: Optional[Dict[str, Any]], msg_id: str) -> str:
+    """A button turn's answer replaces its card; a widget call's answer replies below the widget."""
+    if not agent_action or inline_widget_call(agent_action) is not None:
+        return msg_id
+    return build_inline_agent_action_turn_id(agent_action.get("messageId"), agent_action.get("interactionId"))
+
+
 def _send_result(**kwargs: Any) -> SendResult:
     fields = getattr(SendResult, "__dataclass_fields__", {})
     for optional in ("error_kind", "retry_after"):
@@ -6000,3 +7011,4 @@ def register(ctx) -> None:
         handler_fn=_cli.dispatch,
     )
     _tools.register(ctx)
+    _register_activity_hooks(ctx)