@inline-chat/hermes-agent-adapter 0.0.11 → 0.0.13

package/README.md

@@ -147,7 +147,7 @@ uv run ./hermes plugins list --plain --no-bundled
 Expected local output includes:
 
 ```text
-enabled      user     0.0.11   inline-platform
+enabled      user     0.0.13   inline-platform
 ```
 
 ## Update Or Reinstall
@@ -261,6 +261,12 @@ progress message after a successful final reply. Token streaming requires both
 top-level `streaming.enabled: true` and
 `display.platforms.inline.streaming: true`.
 
+Hermes-native sends and scheduled deliveries accept Inline's explicit target
+forms: a bare positive ID or `chat:ID` for a chat, `thread:ID` for a routable
+reply thread, and `user:ID` for a direct user target. IDs are validated as
+positive signed 64-bit integers before delivery. The parser hooks activate on
+Hermes versions that expose the native plugin target-resolution contract.
+
 Hermes also accepts a top-level `inline:` block for plugin-owned settings, but
 `platforms.inline` matches the shape used by most Hermes platform docs and is
 the safest form to copy into `~/.hermes/config.yaml`.
@@ -293,6 +299,7 @@ Access control follows Hermes' native platform model:
 | `INLINE_CONTEXT_HISTORY_LIMIT` | Legacy compatibility shortcut. `0` maps to `INLINE_CONTEXT_BACKFILL=off`; `1` through `20` maps to `always` with that thread-context limit. Prefer the explicit settings above. |
 | `INLINE_SETTINGS_PATH` | JSON settings file for per-chat `/threads` overrides. `/threads` shows native Auto/On/Off buttons; `reset` clears the chat override back to the global default. Defaults next to `INLINE_STATE_PATH`; `.env`-like paths are refused. |
 | `INLINE_SYSTEM_EVENTS` | Delivers Inline lifecycle events such as edits, deletes, and participant changes as synthetic messages. Defaults to `false`. Reactions on bot messages are always delivered. |
+| `INLINE_REACTIONS` | Shows 👀 while Hermes handles an inbound message, then ✅ on success or ❌ on failure. Cancellation clears the working marker. Defaults to `false`. |
 | `INLINE_MENTION_PATTERNS` | JSON list, comma-separated, or newline-separated regex patterns for group wake words. |
 | `INLINE_PARSE_MARKDOWN` | Controls whether supported outbound Inline Markdown is parsed. Defaults to `true`; `false` preserves the supplied syntax literally. |
 | `INLINE_SYNC_COMMANDS` | Syncs Hermes slash commands into Inline's native `/` bot command menu on gateway connect. Defaults to `true`. |
@@ -316,7 +323,7 @@ Equivalent Hermes YAML can use `allow_from`, `allowed_users`,
 `strict_mention`, `allowed_chats`, `free_response_chats`, `reply_threads`,
 `context_backfill`, `thread_context_limit`, `reply_context_limit`,
 `observed_context_limit`, `observe_unmentioned_messages`, `settings_path`, and
-`mention_patterns` under the Inline platform config. Operational settings such
+`mention_patterns`, and `reactions` under the Inline platform config. Operational settings such
 as `base_url`, `parse_markdown`, `media_max_mb`, `upload_max_mb`,
 `state_path`, `sidecar_port`, `connect_timeout_ms`, `sync_commands`, and
 `command_limit` can also be set there.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/hermes-agent-adapter",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Hermes Agent platform adapter for Inline, with a native Python plugin and bundled Inline realtime sidecar.",
   "license": "Apache-2.0",
   "type": "module",

package/plugin/inline/adapter.py

@@ -62,6 +62,9 @@ _DEFAULT_SIDECAR_PORT = 8794
 _DEFAULT_SIDECAR_BIND = "127.0.0.1"
 _MAX_MESSAGE_LENGTH = 4000
 _MODEL_PAGE_SIZE = 8
+_CHOICE_PICKER_MAX_CHOICES = 16
+_CHOICE_PICKER_TTL_SECONDS = 2 * 60
+_UPDATE_PROMPT_TTL_SECONDS = 5 * 60
 _DEDUP_MAX_SIZE = 5000
 _DEDUP_WINDOW_SECONDS = 48 * 3600
 _CHAT_INFO_CACHE_SECONDS = 10 * 60
@@ -91,6 +94,7 @@ _SIDECAR_DIR = Path(__file__).parent / "sidecar"
 _SIDECAR_ENTRY = _SIDECAR_DIR / "index.mjs"
 _DEFAULT_MEDIA_MAX_MB = 25
 _DEFAULT_UPLOAD_MAX_MB = 300
+_MAX_INLINE_ID = 9_223_372_036_854_775_807
 _MIN_NODE_MAJOR = 20
 _DEFAULT_CONNECT_TIMEOUT_MS = 20_000
 _INLINE_COMMAND_LIMIT = 100
@@ -351,13 +355,81 @@ def _target_from_chat_id(chat_id: str) -> Dict[str, str]:
     raw = str(chat_id or "").strip()
     if raw.startswith("inline:"):
         raw = raw[len("inline:"):].strip()
-    if raw.startswith("chat:"):
-        return {"chatId": raw[len("chat:"):].strip()}
+    if raw.startswith(("chat:", "thread:")):
+        return {"chatId": raw.split(":", 1)[1].strip()}
     if raw.startswith("user:"):
         return {"userId": raw[len("user:"):].strip()}
     return {"chatId": raw}
 
 
+def _normalize_inline_target_id(value: Any) -> Optional[str]:
+    text = str(value or "").strip()
+    if not re.fullmatch(r"[0-9]+", text):
+        return None
+    parsed = int(text)
+    if parsed <= 0 or parsed > _MAX_INLINE_ID:
+        return None
+    return str(parsed)
+
+
+def _parse_inline_target_ref(target_ref: str) -> Optional[tuple[str, Optional[str]]]:
+    """Normalize Hermes delivery refs without losing direct-user routing."""
+    raw = str(target_ref or "").strip()
+    if raw.lower().startswith("inline:"):
+        raw = raw.split(":", 1)[1].strip()
+    if not raw:
+        return None
+
+    prefix = ""
+    if ":" in raw:
+        prefix, raw = raw.split(":", 1)
+        prefix = prefix.strip().lower()
+        raw = raw.strip()
+        if prefix not in {"chat", "thread", "user"} or not raw or ":" in raw:
+            return None
+
+    normalized = _normalize_inline_target_id(raw)
+    if normalized is None:
+        # Preserve recognized explicit refs for the validator so callers get
+        # the same signed-Int64 diagnostic as other Inline ID entry points.
+        if prefix:
+            return (f"user:{raw}" if prefix == "user" else raw), None
+        return None
+    if prefix == "user":
+        return f"user:{normalized}", None
+    return normalized, None
+
+
+def _validate_inline_target_ref(chat_id: str) -> bool | str:
+    raw = str(chat_id or "").strip()
+    if raw.lower().startswith("inline:"):
+        raw = raw.split(":", 1)[1].strip()
+    if ":" in raw:
+        prefix, raw = raw.split(":", 1)
+        if prefix.strip().lower() not in {"chat", "thread", "user"}:
+            return "Use a bare Inline ID or a chat:, thread:, or user: target"
+        raw = raw.strip()
+    if _normalize_inline_target_id(raw) is None:
+        return "Inline targets must use a positive signed 64-bit integer ID"
+    return True
+
+
+def _target_registration_hooks() -> Dict[str, Callable[..., Any]]:
+    """Expose newer Hermes target hooks without breaking older runtimes."""
+    try:
+        from gateway.platform_registry import PlatformEntry
+
+        fields = getattr(PlatformEntry, "__dataclass_fields__", {})
+        if {"parse_target_ref_fn", "validate_target_ref_fn"}.issubset(fields):
+            return {
+                "parse_target_ref_fn": _parse_inline_target_ref,
+                "validate_target_ref_fn": _validate_inline_target_ref,
+            }
+    except Exception:
+        logger.debug("[inline] Hermes target parser hooks are unavailable", exc_info=True)
+    return {}
+
+
 def _inline_sender_profile(event: Dict[str, Any], message: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     raw = event.get("sender")
     if not isinstance(raw, dict) and isinstance(message, dict):
@@ -673,6 +745,7 @@ def _apply_yaml_config(yaml_cfg: dict, platform_cfg: dict) -> Optional[dict]:
         "text_chunk_limit",
         "reply_threads",
         "system_events",
+        "reactions",
         "channel_prompts",
         "channel_skill_bindings",
         "typing_indicator",
@@ -738,6 +811,10 @@ class InlineAdapter(BasePlatformAdapter):
             extra.get("system_events") if "system_events" in extra else os.getenv("INLINE_SYSTEM_EVENTS"),
             False,
         )
+        self._processing_reactions = _truthy(
+            extra.get("reactions") if "reactions" in extra else os.getenv("INLINE_REACTIONS"),
+            False,
+        )
         self._sync_commands = _truthy(
             extra.get("sync_commands") if "sync_commands" in extra else os.getenv("INLINE_SYNC_COMMANDS"),
             True,
@@ -877,7 +954,11 @@ class InlineAdapter(BasePlatformAdapter):
         self._clarify_sessions: "OrderedDict[str, str]" = OrderedDict()
         self._approval_sessions: "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()
         self._model_picker_sessions: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
+        self._status_message_ids: "OrderedDict[tuple[str, str, str], str]" = OrderedDict()
+        self._processing_reaction_messages: "OrderedDict[tuple[str, str, str], Dict[str, str]]" = OrderedDict()
         self._thread_action_sessions: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
         self._chat_info_cache: "OrderedDict[str, tuple[float, Dict[str, Any]]]" = OrderedDict()
         self._bot_agent_cache: "OrderedDict[str, tuple[float, Dict[str, Any]]]" = OrderedDict()
@@ -3582,6 +3663,14 @@ class InlineAdapter(BasePlatformAdapter):
             if not await self._action_allowed(event):
                 return True
             return await self._handle_model_picker_action(event)
+        if action_id.startswith("cp:"):
+            if not await self._action_allowed(event):
+                return True
+            return await self._handle_choice_picker_action(event)
+        if action_id.startswith("up:"):
+            if not await self._action_allowed(event):
+                return True
+            return await self._handle_update_prompt_action(event)
         if action_id.startswith("cl:"):
             if not await self._action_allowed(event):
                 return True
@@ -3805,6 +3894,121 @@ class InlineAdapter(BasePlatformAdapter):
     def _is_model_picker_action(action_id: str) -> bool:
         return action_id.startswith(("mp:", "mpg:", "mm:", "mc:", "mg:", "mb:", "mx:"))
 
+    def _action_matches_state_target(self, event: Dict[str, Any], state: Dict[str, Any]) -> bool:
+        target = state.get("target")
+        if not isinstance(target, dict):
+            return False
+        expected_chat_id = str(target.get("chatId") or "").strip()
+        expected_user_id = str(target.get("userId") or "").strip()
+        target_matches = (
+            bool(expected_chat_id) and expected_chat_id == self._chat_key(event.get("chatId"))
+        ) or (
+            bool(expected_user_id) and expected_user_id == str(event.get("actorUserId") or "").strip()
+        )
+        expected_message_id = str(state.get("message_id") or "").strip()
+        actual_message_id = str(event.get("messageId") or "").strip()
+        return bool(
+            target_matches
+            and expected_message_id
+            and expected_message_id == actual_message_id
+        )
+
+    async def _handle_choice_picker_action(self, event: Dict[str, Any]) -> bool:
+        action_id = str(event.get("actionId") or "")
+        parts = action_id.split(":", 2)
+        if len(parts) != 3 or parts[0] != "cp":
+            return False
+        _, picker_id, index_raw = parts
+        interaction_id = str(event.get("interactionId") or "")
+        state = self._choice_picker_sessions.get(picker_id)
+        if not state:
+            await self._answer_action(interaction_id, "Picker expired")
+            return True
+        if not self._action_matches_state_target(event, state):
+            await self._answer_action(interaction_id, "Picker expired")
+            return True
+        if time.monotonic() - float(state.get("created_at") or 0) > _CHOICE_PICKER_TTL_SECONDS:
+            self._choice_picker_sessions.pop(picker_id, None)
+            await self._finish_action(event, "Picker expired", "Selection expired; no change was made.")
+            return True
+        try:
+            index = int(index_raw)
+            state_choices = state["choices"]
+            if index < 0 or index >= len(state_choices):
+                raise IndexError
+            choice = state_choices[index]
+        except (KeyError, TypeError, ValueError, IndexError):
+            await self._answer_action(interaction_id, "Invalid selection")
+            return True
+
+        callback = state.get("on_choice_selected")
+        if not callable(callback):
+            self._choice_picker_sessions.pop(picker_id, None)
+            await self._finish_action(event, "Picker expired", "Selection expired; no change was made.")
+            return True
+
+        # Claim the picker before awaiting the callback so concurrent taps cannot
+        # apply the same setting more than once.
+        self._choice_picker_sessions.pop(picker_id, None)
+        failed = False
+        try:
+            result_text = callback(str(state.get("chat_id") or event.get("chatId") or ""), str(choice.get("value") or ""))
+            if asyncio.iscoroutine(result_text):
+                result_text = await result_text
+            result_text = str(result_text or "Selection applied.")
+        except Exception as exc:
+            logger.error("[inline] choice picker selection failed (%s)", type(exc).__name__)
+            result_text = "Selection failed; try again."
+            failed = True
+        await self._finish_action(
+            event,
+            "Selection failed" if failed else "Selection applied",
+            result_text,
+        )
+        return True
+
+    async def _handle_update_prompt_action(self, event: Dict[str, Any]) -> bool:
+        action_id = str(event.get("actionId") or "")
+        parts = action_id.split(":", 2)
+        if len(parts) != 3 or parts[0] != "up":
+            return False
+        _, prompt_id, answer = parts
+        interaction_id = str(event.get("interactionId") or "")
+        state = self._update_prompt_sessions.get(prompt_id)
+        if not state:
+            await self._answer_action(interaction_id, "Prompt expired")
+            return True
+        if not self._action_matches_state_target(event, state):
+            await self._answer_action(interaction_id, "Prompt expired")
+            return True
+        if time.monotonic() - float(state.get("created_at") or 0) > _UPDATE_PROMPT_TTL_SECONDS:
+            self._update_prompt_sessions.pop(prompt_id, None)
+            await self._finish_action(event, "Prompt expired", "Update prompt expired; no response was sent.")
+            return True
+        if answer not in {"y", "n"}:
+            await self._answer_action(interaction_id, "Invalid response")
+            return True
+
+        try:
+            from hermes_constants import get_hermes_home
+            response_path = Path(get_hermes_home()) / ".update_response"
+            tmp_path = response_path.with_suffix(".tmp")
+            tmp_path.write_text(answer, encoding="utf-8")
+            tmp_path.replace(response_path)
+        except Exception:
+            logger.exception("[inline] failed to write Hermes update response")
+            await self._answer_action(interaction_id, "Response failed; try again")
+            return True
+
+        self._update_prompt_sessions.pop(prompt_id, None)
+        label = "Yes" if answer == "y" else "No"
+        await self._finish_action(
+            event,
+            f"Update response: {label}",
+            f"Hermes update prompt answered: {label}.",
+        )
+        return True
+
     @staticmethod
     def _split_model_picker_action(action_id: str) -> Optional[tuple[str, str, str]]:
         parts = action_id.split(":", 2)
@@ -3831,6 +4035,9 @@ class InlineAdapter(BasePlatformAdapter):
         if not state:
             await self._answer_action(interaction_id, "Picker expired")
             return True
+        if not self._action_matches_state_target(event, state):
+            await self._answer_action(interaction_id, "Picker expired")
+            return True
 
         if kind == "mp":
             return await self._select_model_provider(event, picker_id, state, value)
@@ -3953,6 +4160,10 @@ class InlineAdapter(BasePlatformAdapter):
             self._model_picker_sessions.pop(picker_id, None)
             await self._answer_action(interaction_id, "Picker expired")
             return True
+        # Claim the picker before awaiting provider work. The sidecar currently
+        # dispatches serially, but this keeps the callback single-use if that
+        # delivery contract changes.
+        self._model_picker_sessions.pop(picker_id, None)
         failed = False
         try:
             result_text = callback(str(state.get("chat_id") or event.get("chatId") or ""), model_id, provider_slug)
@@ -3960,10 +4171,9 @@ class InlineAdapter(BasePlatformAdapter):
                 result_text = await result_text
             result_text = str(result_text or "Model switched.")
         except Exception as exc:
-            logger.exception("[inline] model picker switch failed")
-            result_text = f"Error switching model: {exc}"
+            logger.error("[inline] model picker switch failed (%s)", type(exc).__name__)
+            result_text = "Model switch failed; try again."
             failed = True
-        self._model_picker_sessions.pop(picker_id, None)
         await self._edit_action_message(event, result_text, {"rows": []})
         await self._answer_action(interaction_id, "Switch failed" if failed else "Model switched")
         return True
@@ -4094,6 +4304,35 @@ class InlineAdapter(BasePlatformAdapter):
     ) -> bool:
         return False
 
+    async def send_or_update_status(
+        self,
+        chat_id: str,
+        status_key: str,
+        content: str,
+        *,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> SendResult:
+        target = self._target_for(chat_id, metadata)
+        target_kind = "userId" if "userId" in target else "chatId"
+        key = (target_kind, str(target.get(target_kind) or ""), str(status_key))
+        cached_id = self._status_message_ids.get(key)
+        if cached_id:
+            result = await self.edit_message(
+                chat_id,
+                cached_id,
+                content,
+                metadata=metadata,
+            )
+            if result.success:
+                self._remember(self._status_message_ids, key, str(result.message_id or cached_id))
+                return result
+            self._status_message_ids.pop(key, None)
+
+        result = await self.send(chat_id, content, metadata=metadata)
+        if result.success and result.message_id:
+            self._remember(self._status_message_ids, key, str(result.message_id))
+        return result
+
     async def edit_message(
         self,
         chat_id: str,
@@ -4209,6 +4448,88 @@ class InlineAdapter(BasePlatformAdapter):
         except Exception:
             pass
 
+    def _processing_reaction_target(
+        self,
+        event: MessageEvent,
+    ) -> Optional[tuple[tuple[str, str, str], Dict[str, str], str]]:
+        if not self._processing_reactions:
+            return None
+        raw_message = getattr(event, "raw_message", None)
+        if isinstance(raw_message, dict):
+            # Lifecycle and reaction events can themselves invoke Hermes when
+            # system events are enabled. Reacting to those would add noise and
+            # could create a reaction-event loop. Agent-action turns resolve
+            # their own source card in place and must not react to that card.
+            kind = str(raw_message.get("kind") or "")
+            if (kind and kind != "message.new") or raw_message.get("_inlineAgentAction"):
+                return None
+        source = getattr(event, "source", None)
+        chat_id = str(getattr(source, "chat_id", None) or "").strip()
+        message_id = str(getattr(event, "message_id", None) or "").strip()
+        if not chat_id or not message_id:
+            return None
+        target = _target_from_chat_id(chat_id)
+        target_kind = "userId" if "userId" in target else "chatId"
+        target_id = str(target.get(target_kind) or "").strip()
+        if not target_id:
+            return None
+        return (target_kind, target_id, message_id), target, message_id
+
+    async def _set_processing_reaction(
+        self,
+        target: Dict[str, str],
+        message_id: str,
+        emoji: str,
+        *,
+        remove: bool = False,
+    ) -> bool:
+        body: Dict[str, Any] = {
+            "target": target,
+            "messageId": message_id,
+            "emoji": emoji,
+        }
+        if remove:
+            body["remove"] = True
+        try:
+            await self._sidecar_call("/reaction", body)
+            return True
+        except Exception as exc:
+            logger.debug("[inline] processing reaction failed: %s", exc)
+            return False
+
+    async def on_processing_start(self, event: MessageEvent) -> None:
+        """Mark an inbound message while Hermes is actively processing it."""
+        reaction_target = self._processing_reaction_target(event)
+        if not reaction_target:
+            return
+        key, target, message_id = reaction_target
+        if key not in self._processing_reaction_messages and len(self._processing_reaction_messages) >= 512:
+            evicted_key = next(iter(self._processing_reaction_messages))
+            evicted_target = self._processing_reaction_messages[evicted_key]
+            await self._set_processing_reaction(evicted_target, evicted_key[2], "👀", remove=True)
+            self._processing_reaction_messages.pop(evicted_key, None)
+        # Record cleanup ownership before awaiting the add. Cancellation or a
+        # lost acknowledgement can otherwise strand a bot-owned marker.
+        self._remember(self._processing_reaction_messages, key, target)
+        if not await self._set_processing_reaction(target, message_id, "👀"):
+            self._processing_reaction_messages.pop(key, None)
+
+    async def on_processing_complete(self, event: MessageEvent, outcome: Any) -> None:
+        """Replace the processing marker without affecting response delivery."""
+        reaction_target = self._processing_reaction_target(event)
+        if not reaction_target:
+            return
+        key, _, message_id = reaction_target
+        target = self._processing_reaction_messages.pop(key, None)
+        if not target:
+            return
+        await self._set_processing_reaction(target, message_id, "👀", remove=True)
+        outcome_name = str(getattr(outcome, "value", outcome) or "").strip().lower()
+        if outcome_name == "success":
+            await self._set_processing_reaction(target, message_id, "✅")
+        elif outcome_name == "failure":
+            await self._set_processing_reaction(target, message_id, "❌")
+
     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)
 
@@ -4361,8 +4682,9 @@ class InlineAdapter(BasePlatformAdapter):
         if not clean_providers:
             return await self.send(chat_id, "No authenticated models are available for this session.", metadata=metadata)
         picker_id = secrets.token_hex(6)
+        target = self._target_for(chat_id, metadata)
         result = await self._send_sidecar("/send", {
-            "target": self._target_for(chat_id, metadata),
+            "target": target,
             "text": self._model_picker_text(current_model, current_provider),
             "parseMarkdown": self._parse_markdown,
             "actions": self._build_provider_actions(picker_id, clean_providers),
@@ -4377,6 +4699,95 @@ class InlineAdapter(BasePlatformAdapter):
             "current_model": str(current_model or ""),
             "current_provider": str(current_provider or ""),
             "message_id": result.message_id,
+            "target": target,
+        })
+        return result
+
+    async def send_choice_picker(
+        self,
+        chat_id: str,
+        title: str,
+        choices: list,
+        session_key: str,
+        on_choice_selected,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> SendResult:
+        clean_choices: list[Dict[str, Any]] = []
+        for choice in choices or []:
+            if not isinstance(choice, dict):
+                continue
+            value = str(choice.get("value") or "").strip()
+            label = str(choice.get("label") or value).strip()
+            if not value or not label:
+                continue
+            clean_choices.append({
+                "value": value,
+                "label": label,
+                "is_current": bool(choice.get("is_current")),
+            })
+            # Inline accepts at most eight action rows. Picker actions use two
+            # buttons per row, so keep the native card within that hard limit.
+            if len(clean_choices) >= _CHOICE_PICKER_MAX_CHOICES:
+                break
+        if not clean_choices:
+            return _send_result(success=False, error="No choices")
+
+        picker_id = secrets.token_hex(6)
+        actions = []
+        for index, choice in enumerate(clean_choices):
+            label = str(choice["label"])
+            if choice["is_current"]:
+                label = f"✓ {label}"
+            actions.append(self._action(f"cp:{picker_id}:{index}", self._short_label(label)))
+        target = self._target_for(chat_id, metadata)
+        result = await self._send_sidecar("/send", {
+            "target": target,
+            "text": str(title or "Choose an option"),
+            "parseMarkdown": self._parse_markdown,
+            "actions": {"rows": self._action_rows(actions)},
+        })
+        if result.success:
+            self._remember(self._choice_picker_sessions, picker_id, {
+                "chat_id": str(chat_id),
+                "choices": clean_choices,
+                "session_key": str(session_key),
+                "on_choice_selected": on_choice_selected,
+                "target": target,
+                "message_id": result.message_id,
+                "created_at": time.monotonic(),
+            })
+        return result
+
+    async def send_update_prompt(
+        self,
+        chat_id: str,
+        prompt: str,
+        default: str = "",
+        session_key: str = "",
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> SendResult:
+        prompt_id = secrets.token_hex(6)
+        default_hint = f" (default: {default})" if default else ""
+        target = self._target_for(chat_id, metadata)
+        result = await self._send_sidecar("/send", {
+            "target": target,
+            "text": f"Hermes update needs your input\n\n{prompt}{default_hint}",
+            "parseMarkdown": self._parse_markdown,
+            "actions": {"rows": [{"actions": [
+                self._action(f"up:{prompt_id}:y", "✓ Yes"),
+                self._action(f"up:{prompt_id}:n", "✗ No"),
+            ]}]},
+        })
+        if not result.success:
+            # Hermes 0.20.6 treats any non-raising hook call as delivered and
+            # otherwise suppresses its plaintext /approve and /deny fallback.
+            raise RuntimeError(result.error or "failed to send Inline update prompt")
+        self._remember(self._update_prompt_sessions, prompt_id, {
+            "chat_id": str(chat_id),
+            "session_key": str(session_key),
+            "target": target,
+            "message_id": result.message_id,
+            "created_at": time.monotonic(),
         })
         return result
 
@@ -4580,7 +4991,7 @@ class InlineAdapter(BasePlatformAdapter):
         return self._target_for(chat_id, metadata)
 
     @staticmethod
-    def _remember(mapping: OrderedDict, key: str, value: Any, limit: int = 512) -> None:
+    def _remember(mapping: OrderedDict, key: Any, value: Any, limit: int = 512) -> None:
         if key in mapping:
             del mapping[key]
         mapping[key] = value
@@ -5046,6 +5457,7 @@ def register(ctx) -> None:
         pii_safe=False,
         allow_update_command=True,
         platform_hint=_tools.INLINE_PLATFORM_GUIDANCE,
+        **_target_registration_hooks(),
     )
     register_command = getattr(ctx, "register_command", None)
     if callable(register_command):

package/plugin/inline/cli.py

@@ -7,6 +7,7 @@ the plugin has already been discovered by Hermes.
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 import os
 import re
@@ -26,7 +27,7 @@ _CLI_INSTALL_URL = "https://inline.chat/cli/install.sh"
 _MAX_TOKEN_BYTES = 16 * 1024
 _MAX_PROBE_RESPONSE_BYTES = 64 * 1024
 _MACHINE_SETUP_PROTOCOL_VERSION = 1
-_PROBE_USER_AGENT = "inline-hermes-agent-adapter/0.0.11"
+_PROBE_USER_AGENT = "inline-hermes-agent-adapter/0.0.13"
 _ENV_REFERENCE_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
 
 
@@ -463,6 +464,7 @@ def _status(args) -> int:
         "sidecar": sidecar,
         "node": node,
         "probeRequested": probe_requested,
+        "gateway": _gateway_status(),
         **({"probe": probe} if probe is not None else {}),
     }
     if getattr(args, "json", False):
@@ -480,6 +482,51 @@ def _status(args) -> int:
     return 0 if runtime_usable and (not probe_requested or ready) else 1
 
 
+def _gateway_status() -> dict:
+    """Project local runtime facts without changing the credential-status contract."""
+    unavailable = {"supported": False, "ready": False, "reason": "runtime_status_unavailable"}
+    try:
+        from gateway.status import read_runtime_status, get_runtime_status_running_pid
+        from hermes_constants import get_hermes_home
+
+        runtime = read_runtime_status()
+        # Also validate this helper contract for an absent runtime: older hosts
+        # lack expected_home and must not claim support until after installation.
+        pid = get_runtime_status_running_pid(runtime if isinstance(runtime, dict) else {}, expected_home=get_hermes_home())
+        if not isinstance(runtime, dict):
+            return {"supported": True, "ready": False, "reason": "missing_status"}
+        # Return only an opaque generation, never process IDs or raw state.
+        start_time = runtime.get("start_time")
+        valid_identity = type(pid) is int and pid > 0 and type(start_time) is int and start_time >= 0
+        if pid and not valid_identity:
+            return {"supported": False, "ready": False, "reason": "runtime_identity_unavailable"}
+        generation = hashlib.sha256(f"inline-gateway:{pid}:{start_time}".encode()).hexdigest() if valid_identity else None
+        state = runtime.get("gateway_state")
+        platforms = runtime.get("platforms")
+        inline = platforms.get("inline") if isinstance(platforms, dict) else None
+        platform_state = inline.get("state") if isinstance(inline, dict) else None
+        state = state if state in ("starting", "running", "draining", "stopping", "stopped", "startup_failed") else "unknown"
+        platform_state = platform_state if platform_state in ("connected", "connecting", "retrying", "fatal", "disconnected") else "unknown"
+        if pid and isinstance(inline, dict) and ("writer_pid" not in inline or "writer_start_time" not in inline):
+            return {"supported": False, "ready": False, "reason": "runtime_writer_identity_unavailable"}
+        # Runtime status can retain platform entries from the prior process.
+        # Only the current process's own connected projection is readiness proof.
+        writer_matches = isinstance(inline, dict) and inline.get("writer_pid") == pid and inline.get("writer_start_time") == start_time
+        ready = generation is not None and writer_matches and state == "running" and platform_state == "connected"
+        return {
+            "supported": True,
+            "ready": ready,
+            **({"generation": generation} if generation is not None else {}),
+            "gatewayState": state,
+            "platformState": platform_state,
+            "reason": "ready" if ready else "stale_pid" if not pid else "gateway_not_running" if state != "running" else "platform_status_stale" if not writer_matches else "platform_not_connected",
+        }
+    except Exception:
+        # Older Hermes versions may not expose the helpers. Never return raw
+        # runtime files or exceptions: they can contain provider/credential data.
+        return unavailable
+
+
 def _plugin_version() -> str:
     """Read the separately installed plugin version without package-manager state."""
     try:

package/plugin/inline/plugin.yaml

@@ -1,7 +1,7 @@
 name: inline-platform
 label: Inline
 kind: platform
-version: 0.0.11
+version: 0.0.13
 description: >
   Inline platform adapter for Hermes Agent. The adapter runs as a native
   Hermes Python platform plugin and supervises a local Node sidecar that uses
@@ -110,6 +110,10 @@ optional_env:
     description: "Deliver Inline lifecycle events such as edits, deletes, and participant changes as synthetic messages (true/false, default false)"
     prompt: "Deliver lifecycle events? (true/false)"
     password: false
+  - name: INLINE_REACTIONS
+    description: "Show processing reactions on handled inbound messages: eyes while working, then success or failure (true/false, default false)"
+    prompt: "Show processing reactions? (true/false)"
+    password: false
   - name: INLINE_MENTION_PATTERNS
     description: "Mention wake-word regexes, JSON list or comma/newline-separated"
     prompt: "Mention patterns"