@maudecode/talaria-web 1.16.1 → 1.18.0

package/sidecar/talaria_sidecar/methods/mcp.py

@@ -17,7 +17,7 @@ log = logging.getLogger("talaria_sidecar.mcp")
 
 def status() -> list[dict]:
     try:
-        from tools.mcp_tool import get_mcp_status
+        from tools.mcp_tool_discovery import get_mcp_status
 
         statuses = get_mcp_status()
     except Exception:  # noqa: BLE001

package/sidecar/talaria_sidecar/methods/process.py

@@ -8,11 +8,12 @@ import json
 import logging
 import queue
 import sqlite3
+import threading
 import time
 from contextlib import closing
 from pathlib import Path
 
-from ..errors import InvalidParams
+from ..errors import InvalidParams, RpcError
 from ..home import profile_home_param, scoped_home
 from ..rpc import CallContext
 
@@ -42,18 +43,80 @@ def _event_row(evt: dict) -> dict:
             if not row.get("origin_ui_session_id"):
                 row["origin_ui_session_id"] = str(getattr(proc, "origin_ui_session_id", "") or "") or str(getattr(proc, "spawn_session_id", "") or "")
     try:
-        row["consumed"] = bool(registry is not None and process_id and row.get("type") != "async_delegation" and registry.is_completion_consumed(process_id))
+        # Only the exit is consumed by the agent's wait or poll; a watch notice from the same process still wakes (TAL-724).
+        row["consumed"] = bool(registry is not None and process_id and row.get("type") in (None, "completion") and registry.is_completion_consumed(process_id))
     except Exception:  # noqa: BLE001
         row["consumed"] = False
     return row
 
 
+# Recovered sessions, held so their exit is seen even when an Agent call other than drain prunes them first.
+_RECOVERED: dict[str, object] = {}
+_RECOVERED_LOCK = threading.Lock()
+
+
+def _reports_recovered_exits(registry) -> bool:
+    """Agent 0.21.6 (hermes-agent 7550800d) closes or prunes a recovered session whose PID is gone without queuing a
+    completion, since it never collected an exit status. Talaria still wakes the session with an unknown exit code."""
+    return callable(getattr(registry, "_detached_host_fate", None)) and callable(getattr(registry, "_publish_finished", None))
+
+
+def track_recovered(registry) -> None:
+    if not _reports_recovered_exits(registry):
+        return
+    try:
+        with registry._lock:
+            detached = [s for s in registry._running.values() if getattr(s, "detached", False)]
+    except Exception:  # noqa: BLE001 - recovery itself succeeded; only the exit report is lost
+        log.warning("Failed to track recovered processes", exc_info=True)
+        return
+    with _RECOVERED_LOCK:
+        _RECOVERED.update((s.id, s) for s in detached)
+
+
+def _publish_recovered_exits(registry) -> None:
+    with _RECOVERED_LOCK:
+        exited = [s for s in _RECOVERED.values() if s.exited]
+        for session in exited:
+            del _RECOVERED[session.id]
+    for session in exited:
+        # A kill (or any path that collected a status) already queued its own completion through _move_to_finished.
+        if session.exit_code is not None or getattr(session, "_finish_claimed", False):
+            continue
+        try:
+            # Best effort, as in the Agent: a durable result must not block the live completion.
+            from tools.process_registry_results import save_completed_result
+
+            save_completed_result(session)
+        except Exception:  # noqa: BLE001
+            log.debug("Failed to retain the result of recovered process %s", session.id, exc_info=True)
+        try:
+            with registry._lock:
+                registry._running.pop(session.id, None)
+                session.exited_at = session.exited_at or time.time()
+                registry._finished[session.id] = session
+            registry._publish_finished(session, True)
+        except Exception:  # noqa: BLE001 - retried on the next drain
+            log.warning("Failed to report the exit of recovered process %s", session.id, exc_info=True)
+            with _RECOVERED_LOCK:
+                _RECOVERED.setdefault(session.id, session)
+
+
 def drain(max_events: int) -> list[dict]:
     """Pop every queued completion event; the server requeues what it does not own."""
     registry = _registry()
     completion_queue = getattr(registry, "completion_queue", None) if registry is not None else None
     if completion_queue is None:
         return []
+    try:
+        # A recovered process has no reader thread; only this probe notices its exit and queues its completion (TAL-533).
+        with registry._lock:
+            detached = [s for s in registry._running.values() if getattr(s, "detached", False)]
+        for session in detached:
+            registry._refresh_detached_session(session)
+        _publish_recovered_exits(registry)
+    except Exception:  # noqa: BLE001
+        log.debug("Failed to reconcile recovered processes", exc_info=True)
     out = []
     while len(out) < max_events:
         try:
@@ -94,6 +157,22 @@ def mark_consumed(process_id: str) -> bool:
         return False
 
 
+def consumed_ids(process_ids: list[str]) -> list[str]:
+    """The processes the agent already holds from its own turn: consumed via wait/log, or observed exiting via poll.
+    Checked at wakeup delivery, since the completion is usually drained before the agent's wait returns (TAL-532)."""
+    registry = _registry()
+    if registry is None:
+        return []
+    out = []
+    for process_id in process_ids:
+        try:
+            if registry.is_completion_consumed(process_id) or process_id in (getattr(registry, "_poll_observed", None) or ()):
+                out.append(process_id)
+        except Exception:  # noqa: BLE001
+            log.debug("Completion consumed check failed for %r", process_id, exc_info=True)
+    return out
+
+
 def _delivery_api():
     """The Agent's durable delivery ledger (``tools.async_delegation``), or None on an Agent without it."""
     try:
@@ -387,12 +466,39 @@ def delegation_result(home: Path, session_id: str, delegation_id: str) -> str:
     return format_notification(event) if event else ""
 
 
+def recover(base_home: Path) -> int:
+    """TAL-533: re-adopt every profile's checkpointed processes when a sidecar starts, so a process in a profile nobody
+    uses yet is watched (and its exit reported) from the start. Entering a home's scope recovers it once; a failed
+    recovery fails the call, so the server retries."""
+    from .profiles import named_profile_homes
+
+    named = [home for _, home in named_profile_homes(base_home)]
+    failed = []
+    for home in [base_home, *named]:
+        try:
+            with scoped_home(home):
+                pass
+        except RpcError as exc:
+            if exc.data.get("condition") != "agent_incompatible":
+                failed.append(str(exc))
+                continue
+            # An Agent without profile isolation refuses named profiles for good; their processes stay unadopted.
+            log.warning("Background process recovery skipped for %s", home, exc_info=True)
+    if failed:
+        raise RpcError("; ".join(failed))
+    return 1 + len(named)
+
+
 def register(registry_) -> None:
     @registry_.method("process.drain")
     def drain_(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):
             return {"events": drain(int(params.get("max_events") or 256))}
 
+    @registry_.method("process.recover")
+    def recover_(ctx: CallContext, params: dict) -> dict:
+        return {"homes": recover(profile_home_param(params, "base_home"))}
+
     @registry_.method("process.requeue")
     def requeue_(ctx: CallContext, params: dict) -> dict:
         events = params.get("events")
@@ -407,6 +513,13 @@ def register(registry_) -> None:
             raise InvalidParams("process_id is required")
         return {"ok": mark_consumed(process_id)}
 
+    @registry_.method("process.consumed")
+    def consumed_(ctx: CallContext, params: dict) -> dict:
+        ids = params.get("process_ids")
+        if not isinstance(ids, list) or not all(isinstance(i, str) and i for i in ids):
+            raise InvalidParams("process_ids must be a list of process ids")
+        return {"consumed": consumed_ids(ids)}
+
     def _delivery_params(params: dict) -> dict:
         evt = params.get("event")
         if not isinstance(evt, dict):

package/sidecar/talaria_sidecar/methods/profiles.py

@@ -24,6 +24,9 @@ log = logging.getLogger("talaria_sidecar.profiles")
 _PROFILE_ID_RE = re.compile(r"[a-z0-9][a-z0-9_-]{0,63}")
 _PROFILE_DIRS = ("skills", "memories", "sessions", "logs", "cron")
 _CLONE_CONFIG_FILES = ("config.yaml", ".env", "SOUL.md")
+_AVATAR_EXTS = ("png", "jpg", "webp")
+# The Agent's ``INTERNAL_LISTING_SOURCES``: worker sessions are never a profile's conversation.
+_INTERNAL_SOURCES = ("kanban", "tool", "oneshot")
 _TERMINAL_ENV = {
     "backend": "TERMINAL_ENV", "env_type": "TERMINAL_ENV", "cwd": "TERMINAL_CWD", "timeout": "TERMINAL_TIMEOUT", "lifetime_seconds": "TERMINAL_LIFETIME_SECONDS",
     "modal_mode": "TERMINAL_MODAL_MODE", "docker_image": "TERMINAL_DOCKER_IMAGE", "docker_forward_env": "TERMINAL_DOCKER_FORWARD_ENV", "docker_env": "TERMINAL_DOCKER_ENV",
@@ -96,6 +99,58 @@ def _visible(profile_dir: Path) -> bool:
     return not (isinstance(data, dict) and data.get("visible") is False)
 
 
+def _bounded(value, limit: int) -> str:
+    """One printable line of at most ``limit`` characters; anything but a string reads as empty."""
+    if not isinstance(value, str):
+        return ""
+    text = " ".join("".join(c if c.isprintable() else " " for c in value).split())
+    return text if len(text) <= limit else text[: limit - 1].rstrip() + "\u2026"
+
+
+def bot_identity(home: Path) -> dict:
+    """The presentation-only Bot Mode identity from ``profile.yaml`` and ``assets/``; never the raw ``ui_meta``."""
+    meta = _yaml_load(home / "profile.yaml") or {}
+    ui_meta = meta.get("ui_meta") if isinstance(meta.get("ui_meta"), dict) else {}
+    bots = ui_meta.get("hermes-bots") if isinstance(ui_meta.get("hermes-bots"), dict) else {}
+    return {
+        # Bot Mode's roster name (``ui_meta['hermes-bots'].title``) wins over the profile's own display name.
+        "display_name": _bounded(bots.get("title"), 80) or _bounded(meta.get("display_name"), 80),
+        "description": _bounded(meta.get("description"), 280), "has_avatar": any((home / "assets" / f"avatar.{ext}").is_file() for ext in _AVATAR_EXTS),
+    }
+
+
+def canonical_bot_chat(home: Path) -> dict | None:
+    """The profile's canonical Bot Chat: its session titled exactly ``Bot Chat`` (Bot Mode's registry) and live
+    compression tip, read through a read-only handle. Missing, unreadable, archived, worker-owned, or an Agent
+    without Bot Mode answers None; the gateway's resurrection of accidental archives is a write and stays there."""
+    db_path = home / "state.db"
+    if not db_path.is_file():
+        return None
+    try:
+        from hermes_state import SessionDB
+
+        title = getattr(SessionDB, "CANONICAL_BOT_CHAT_TITLE", None)
+        if not title:
+            return None
+        db = SessionDB(db_path=db_path, read_only=True)
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        row = db.get_session_by_title(title)
+        if not row or row.get("title") != title or row.get("archived") or str(row.get("source") or "").strip().lower() in _INTERNAL_SOURCES:
+            return None
+        session_id = str(row["id"])
+        return {"session_id": session_id, "tip_session_id": str(db.get_compression_tip(session_id) or session_id)}
+    except Exception:  # noqa: BLE001
+        log.debug("canonical Bot Chat lookup failed for %s", db_path, exc_info=True)
+        return None
+    finally:
+        try:
+            db.close()
+        except Exception:  # noqa: BLE001
+            pass
+
+
 def _row(home: Path, name: str, is_default: bool) -> dict:
     from hermes_cli.profiles import _check_gateway_running, _read_config_model
 
@@ -111,21 +166,36 @@ def _row(home: Path, name: str, is_default: bool) -> dict:
     return {
         "name": name, "path": str(home), "is_default": is_default, "gateway_running": gateway_running, "model": model, "provider": provider,
         "has_env": (home / ".env").exists(), "visible": _visible(home), "skill_count": enabled, "enabled_skills": enabled, "total_skills": total,
+        **bot_identity(home), "canonical_session": canonical_bot_chat(home),
     }
 
 
-def list_profiles(base_home: Path) -> list[dict]:
-    """Profile rows for the base Hermes home: the root profile plus ``profiles/*``."""
+def named_profile_homes(base_home: Path) -> list[tuple[str, Path]]:
+    """(name, home) for the ``profiles/*`` directories named like profiles, skipping any that resolve outside the resolved
+    profiles root (a symlink leading elsewhere is never read as a profile; TAL-579). A contained symlink answers the
+    target it was checked against, so retargeting the link afterwards cannot redirect the caller."""
     from hermes_cli.profiles import _PROFILE_ID_RE as UPSTREAM_ID_RE
 
+    profiles_root = base_home / "profiles"
+    if not profiles_root.is_dir():
+        return []
+    root = profiles_root.resolve()
+    homes = []
+    for entry in sorted(profiles_root.iterdir()):
+        if not (entry.is_dir() and UPSTREAM_ID_RE.match(entry.name)):
+            continue
+        real = entry.resolve()
+        if real.is_relative_to(root):
+            homes.append((entry.name, real if entry.is_symlink() else entry))
+    return homes
+
+
+def list_profiles(base_home: Path) -> list[dict]:
+    """Profile rows for the base Hermes home: the root profile plus ``profiles/*``."""
     rows = []
     if base_home.is_dir():
         rows.append(_row(base_home, "default", True))
-    profiles_root = base_home / "profiles"
-    if profiles_root.is_dir():
-        for entry in sorted(profiles_root.iterdir()):
-            if entry.is_dir() and UPSTREAM_ID_RE.match(entry.name):
-                rows.append(_row(entry, entry.name, False))
+    rows.extend(_row(home, name, False) for name, home in named_profile_homes(base_home))
     return rows
 
 
@@ -241,7 +311,13 @@ def register(registry) -> None:
 
     @registry.method("profiles.delete")
     def delete(ctx: CallContext, params: dict) -> dict:
-        delete_profile(profile_home_param(params, "base_home"), str(params.get("name") or "").strip())
+        base_home, name = profile_home_param(params, "base_home"), str(params.get("name") or "").strip()
+        validate_name(name)
+        # Idle cached agents end their memory sessions while the profile's home still exists.
+        from .chat import release_profile_agents
+
+        release_profile_agents(base_home / "profiles" / name)
+        delete_profile(base_home, name)
         return {"ok": True}
 
     @registry.method("profiles.runtime_env")

package/sidecar/talaria_sidecar/methods/providers.py

@@ -97,8 +97,10 @@ def _user_plugin_profiles() -> dict[int, tuple[Any, Path]]:
 def _load_plugin(root: Path) -> None:
     """Load the scoped profile's installed plugin that the process-wide discovery (run under the launch profile) skipped.
 
-    Uses the Agent's own loader, as ``hermes plugins dev`` does, once per directory. A plugin never displaces a provider
-    that is already registered, so one profile's plugin cannot change what another profile's provider id runs.
+    Uses the Agent's own loader, as ``hermes plugins dev`` does, once per directory. On an Agent with one process-wide
+    provider registry, a plugin never displaces a provider that is already registered, so one profile's plugin cannot
+    change what another profile's provider id runs. An Agent with per-home provider layers registers it in this home's
+    layer instead, so the same id is that profile's own provider.
     """
     import providers
 
@@ -121,12 +123,12 @@ def _load_plugin(root: Path) -> None:
 def installed_plugin_profiles() -> list[tuple[str, Any]]:
     """``(manifest name, profile | None)`` for each enabled model-provider plugin installed in the scoped home.
 
-    Bundled providers are built-ins, not plugins. The Agent keeps one provider registry per process, so a profile
-    belongs to this home only when the plugin module that registered it lives in one of this home's plugin
-    directories; a plugin the launch discovery skipped is loaded here. ``None`` means the plugin could not be loaded:
-    it failed to import, its provider id is taken by another plugin, or another profile's plugin has the same directory
-    name. ponytail: ownership is read from the plugin module's globals, so a plugin that registers an unbound inline
-    profile also reads as not loaded; track registrations in the Agent if one ever does.
+    Bundled providers are built-ins, not plugins. A profile belongs to this home only when the plugin module that
+    registered it lives in one of this home's plugin directories; a plugin the launch discovery skipped is loaded here.
+    ``None`` means the plugin could not be loaded: it failed to import, another plugin took its provider id (only on an
+    Agent with one process-wide provider registry rather than per-home layers), or another profile's plugin has the same
+    directory name. ponytail: ownership is read from the plugin module's globals, so a plugin that registers an unbound
+    inline profile also reads as not loaded; track registrations in the Agent if one ever does.
     """
     try:
         from hermes_cli.plugins_discovery import _get_disabled_plugins, _get_enabled_plugins, collect_directory_manifests, gate_manifest
@@ -168,8 +170,25 @@ def _other_profile_plugin(provider_id: str) -> bool:
     return not any(p is profile for _name, p in installed_plugin_profiles())
 
 
+def _agent_knows_provider(name: str) -> bool:
+    """Whether the Agent's auth layer can resolve this provider id at all.
+
+    Agent 0.21.3 resolves providers from a ``PROVIDER_REGISTRY`` snapshot of its import-time plugin discovery, so a
+    named profile's plugin loaded here on demand is unknown to it and cannot run. Registering it there would expose it
+    to every profile, so it reads as unavailable instead. Newer Agents look providers up live (``_registry_lookup``).
+    """
+    try:
+        import hermes_cli.auth as auth
+    except Exception:  # noqa: BLE001 - auth_status reports an unavailable auth layer
+        return True
+    registry = getattr(auth, "PROVIDER_REGISTRY", None)
+    return hasattr(auth, "_registry_lookup") or not isinstance(registry, dict) or name.strip().lower() in registry
+
+
 def _setup_state(profile: Any) -> str:
     """The Agent's own setup verdict for a plugin provider, without spawning its CLI or reading its credentials."""
+    if not _agent_knows_provider(str(profile.name)):
+        return "unavailable"
     try:
         status = auth_status(profile.name)
     except RpcError:

package/sidecar/talaria_sidecar/methods/runtime.py

@@ -66,5 +66,8 @@ def register(registry) -> None:
         code = params.get("exit_code", 0)
         if not isinstance(code, int):
             raise InvalidParams("exit_code must be an integer")
+        from .chat import drain_agents
+
+        drain_agents()
         ctx.server.request_shutdown(exit_code=code)
         return {"ok": True}

package/sidecar/talaria_sidecar/methods/state_db.py

@@ -95,7 +95,8 @@ def sync_session_usage(home: Path, session_id: str, *, input_tokens=0, output_to
         _close(db)
 
 
-def sync_session_title(home: Path, session_id: str, title: str) -> bool:
+def sync_session_title(home: Path, session_id: str, title: str, *, manual: bool = False) -> bool:
+    """A manual (user-requested) title lands with ``user`` provenance; an auto title is ``llm`` and never replaces a user name."""
     if not title:
         return False
     db = _session_db(home)
@@ -104,15 +105,38 @@ def sync_session_title(home: Path, session_id: str, title: str) -> bool:
     try:
         db.ensure_session(session_id=session_id, source="webui")
         source = getattr(db, "TITLE_SOURCE_LLM", "llm")
+
+        def write(value: str) -> None:
+            if manual:
+                db.set_session_title(session_id, value)
+            else:
+                db.set_auto_title(session_id, value, source=source)
+
         try:
-            db.set_auto_title(session_id, title, source=source)
+            write(title)
         except ValueError:
             alt = db.get_next_title_in_lineage(title)
             if alt and alt != title:
-                db.set_auto_title(session_id, alt, source=source)
+                write(alt)
+        return True
+    except Exception:  # noqa: BLE001
+        log.debug("Failed to sync session title", exc_info=True)
+        return False
+    finally:
+        _close(db)
+
+
+def append_message(home: Path, session_id: str, *, role: str, content: str, tool_name=None, timestamp=None) -> bool:
+    """TAL-258 (predecessor ``_persist_handoff_summary_to_state_db``): one row through ``SessionDB.append_message``,
+    which also bumps the session's ``message_count``. False without a state.db or when the write fails."""
+    db = _session_db(home)
+    if not db:
+        return False
+    try:
+        db.append_message(session_id, role, content=content, tool_name=tool_name or None, timestamp=timestamp)
         return True
     except Exception:  # noqa: BLE001
-        log.debug("Failed to sync auto title", exc_info=True)
+        log.warning("Failed to append a %s row to state.db for %s", role, session_id, exc_info=True)
         return False
     finally:
         _close(db)
@@ -408,7 +432,17 @@ def register(registry) -> None:
 
     @registry.method("state_db.sync_title")
     def title(ctx: CallContext, params: dict) -> dict:
-        return {"ok": sync_session_title(profile_home_param(params), _session_id(params), str(params.get("title") or ""))}
+        return {"ok": sync_session_title(profile_home_param(params), _session_id(params), str(params.get("title") or ""), manual=params.get("manual") is True)}
+
+    @registry.method("state_db.append_message")
+    def append(ctx: CallContext, params: dict) -> dict:
+        role = str(params.get("role") or "").strip()
+        if not role:
+            raise InvalidParams("role is required")
+        content = params.get("content")
+        if not isinstance(content, str):
+            raise InvalidParams("content must be a string")
+        return {"ok": append_message(profile_home_param(params), _session_id(params), role=role, content=content, tool_name=params.get("tool_name"), timestamp=params.get("timestamp"))}
 
     @registry.method("state_db.delete_cli_session")
     def delete(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/text.py

@@ -16,7 +16,7 @@ def image_mode(*, provider: str, model: str, cfg: dict | None, requested_provide
     try:
         from agent.image_routing import decide_image_input_mode
     except Exception:  # noqa: BLE001
-        return {"mode": "text", "reason": "image routing unavailable"}
+        return {"mode": "text", "reason": "image routing unavailable", "supports_vision": None}
     try:
         decision = decide_image_input_mode(provider, model, cfg, requested_provider=requested_provider)
     except TypeError:
@@ -34,6 +34,18 @@ def image_mode(*, provider: str, model: str, cfg: dict | None, requested_provide
     return {"mode": str(decision or "text"), "reason": "", "supports_vision": supports_vision}
 
 
+def _profile_config() -> dict | None:
+    """The scoped profile's ``config.yaml``; None when the Agent cannot load it."""
+    try:
+        from hermes_cli.config import load_config
+
+        cfg = load_config()
+    except Exception:  # noqa: BLE001
+        log.debug("image mode config load failed", exc_info=True)
+        return None
+    return cfg if isinstance(cfg, dict) else None
+
+
 def portal_tags() -> dict:
     try:
         from agent.portal_tags import conversation_tag, hermes_client_tag, nous_portal_tags
@@ -58,6 +70,10 @@ def register(registry) -> None:
     def image_mode_(ctx: CallContext, params: dict) -> dict:
         cfg = params.get("cfg") if isinstance(params.get("cfg"), dict) else None
         with scoped_home(profile_home_param(params)):
+            # TAL-545: without an explicit cfg the profile's config.yaml decides, so its vision overrides
+            # (``agent.image_input_mode``, ``supports_vision``) apply as they do for the Agent's own turn.
+            if cfg is None:
+                cfg = _profile_config()
             return image_mode(provider=str(params.get("provider") or ""), model=str(params.get("model") or ""), cfg=cfg, requested_provider=str(params.get("requested_provider") or ""))
 
     @registry.method("text.portal_tags")