@maudecode/talaria-web 1.17.2 → 1.18.0

package/sidecar/talaria_sidecar/methods/commands.py

@@ -244,6 +244,77 @@ def execute_plugin_command(command: str) -> str | None:
         return f"Plugin command error: {type(exc).__name__}"
 
 
+def _profile_bundles(skill_bundles) -> dict[str, dict[str, Any]]:
+    """The scoped profile's bundles keyed ``/slug``, read from disk the way ``scan_bundles`` reads them.
+
+    ``scan_bundles``/``get_skill_bundles`` publish one profile's bundles in a process-wide cache keyed only by mtime,
+    which cron jobs in other profiles read concurrently, so the sidecar never fills it."""
+    out: dict[str, dict[str, Any]] = {}
+    for path in skill_bundles._iter_bundle_files():
+        info = skill_bundles._load_bundle_file(path)
+        if info:
+            out.setdefault(f"/{info['slug']}", info)
+    return out
+
+
+def list_command_bundles() -> list[dict[str, Any]]:
+    """The profile's skill bundles as slash-command rows; [] when the bundle runtime is missing or fails."""
+    try:
+        import agent.skill_bundles as skill_bundles
+    except ImportError:
+        return []
+    try:
+        bundles = sorted(_profile_bundles(skill_bundles).values(), key=lambda b: b["slug"])
+    except Exception:  # noqa: BLE001
+        log.warning("Failed to list skill bundles", exc_info=True)
+        return []
+    return [{"name": str(b["slug"]).strip().lower(), "description": str(b.get("description") or "").strip() or "Skill bundle",
+             "skill_count": len(b.get("skills") or []), "source": "bundle"} for b in bundles if str(b.get("slug") or "").strip()]
+
+
+def _bundle_invocation(info: dict[str, Any], instruction: str) -> tuple[str, list[str], list[str]] | None:
+    """``build_bundle_invocation_message`` for a bundle read by ``_profile_bundles`` (that one looks it up in the shared cache),
+    skipping the skills disabled for Web chat (``skills.platform_disabled.webui``)."""
+    from agent.skill_commands import _disabled_skill_names, _load_skill_blocks, _load_skill_payload, _scaffold_header
+
+    name = info["name"]
+    loaded, missing, disabled, blocks = _load_skill_blocks(
+        [(skill or "").strip() for skill in info["skills"]], _load_skill_payload, lambda _skill: f'[Loaded as part of the "{name}" skill bundle.]',
+        None, disabled_names=_disabled_skill_names("webui"))
+    if not blocks:
+        return None
+    header = _scaffold_header(f'"{name}" skill bundle', loaded, lead_lines=[f"Bundle: {name}"], missing=missing, disabled=disabled,
+                              extra_instruction=info.get("instruction") or "", user_instruction=instruction)
+    return "\n\n".join([header, *blocks]), loaded, missing
+
+
+def resolve_bundle_command(command: str) -> dict[str, Any]:
+    """Expand ``/<bundle> [instruction]`` into the user message that loads the bundle's skills."""
+    name, instruction = parse_slash_command(command)
+    try:
+        import agent.skill_bundles as skill_bundles
+        from agent.skill_commands import resolve_slash_key
+    except ImportError as exc:
+        raise RpcError("Skill bundle runtime unavailable", condition="bundle_unavailable") from exc
+    try:
+        bundles = _profile_bundles(skill_bundles)
+        key = resolve_slash_key(name, bundles)
+        result = _bundle_invocation(bundles[key], instruction) if key else None
+    except ValueError as exc:
+        raise InvalidParams(str(exc)) from exc
+    except Exception as exc:  # noqa: BLE001
+        log.warning("Failed to resolve skill bundle command", exc_info=True)
+        raise RpcError("Skill bundle command unavailable", condition="bundle_unavailable") from exc
+    if key is None:
+        raise RpcError("Bundle command not found", condition="bundle_not_found")
+    message, loaded, missing = result or ("", [], [])
+    message = str(message or "").strip()
+    if not message:
+        raise RpcError("Bundle command returned no invocation text", condition="bundle_unavailable")
+    return {"name": key.lstrip("/"), "source": "bundle", "message": message, "loaded_skills": [str(s) for s in loaded or []],
+            "missing_skills": [str(s) for s in missing or []]}
+
+
 def resolve_moa_config(preset: str | None) -> dict:
     try:
         from hermes_cli.moa_config import moa_usage, normalize_moa_config
@@ -352,6 +423,16 @@ def register(registry) -> None:
             raise RpcError(f"unknown command {parse_slash_command(command)[0]!r}", condition="command_not_found")
         return {"output": output, "source": source}
 
+    @registry.method("commands.bundles")
+    def bundles(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"bundles": list_command_bundles()}
+
+    @registry.method("commands.bundle_resolve")
+    def bundle_resolve(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return resolve_bundle_command(str(params.get("command") or ""))
+
     @registry.method("commands.moa_preset")
     def moa(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):

package/sidecar/talaria_sidecar/methods/cron.py

@@ -33,6 +33,35 @@ _RUNNING_LOCK = threading.Lock()
 _SNAPSHOT_LOCK = threading.Lock()
 
 
+def _main_model_pin() -> tuple[str | None, str | None]:
+    """``(provider, model)`` the scoped profile's main agent runs on: the Agent's own ``cron.jobs._main_model_pin``.
+
+    Agent 0.21.3 predates that helper, so it is rebuilt from the readers 0.21.4 composes: the home's effective
+    ``config.yaml`` model and the provider the runtime resolves for it. ``(None, None)`` when no model is configured.
+    """
+    from cron import jobs
+
+    if hasattr(jobs, "_main_model_pin"):
+        return jobs._main_model_pin()
+    from hermes_cli.config_effective import load_user_config_effective
+    from hermes_constants import get_hermes_home
+
+    cfg_path = get_hermes_home() / "config.yaml"
+    cfg = load_user_config_effective(cfg_path) if cfg_path.exists() else {}
+    model_cfg = cfg.get("model") or {}
+    model = model_cfg.get("default") or model_cfg.get("model") if isinstance(model_cfg, dict) else model_cfg
+    model = model.strip() or None if isinstance(model, str) else None
+    if not model:
+        return None, None
+    provider = None
+    with contextlib.suppress(Exception):
+        from hermes_cli.runtime_provider import resolve_runtime_provider
+
+        resolved = resolve_runtime_provider(requested=None).get("provider")
+        provider = resolved.strip().lower() or None if isinstance(resolved, str) else None
+    return provider, model
+
+
 class CronUnavailable(RpcError):
     def __init__(self, exc: Exception):
         super().__init__(f"cron unavailable: {exc}", condition="cron_unavailable")
@@ -396,8 +425,6 @@ def register(registry) -> None:
         # to the store home; owner_profile only preserves management from the creating Web profile.
         if post.get("profile") and execution_home and not (model and provider) and not body.get("no_agent"):
             try:
-                from cron.jobs import _main_model_pin
-
                 with _SNAPSHOT_LOCK, scoped_home(Path(execution_home)):
                     profile_provider, profile_model = _main_model_pin()
                 if not profile_model:

package/sidecar/talaria_sidecar/methods/gateway.py

@@ -1,4 +1,4 @@
-"""``gateway.*``: Hermes gateway lifecycle through the ``hermes`` CLI (ported from api/gateway_restart.py)."""
+"""``gateway.*``: Hermes gateway lifecycle (start, stop, restart) through the ``hermes`` CLI."""
 
 from __future__ import annotations
 
@@ -16,7 +16,10 @@ from ..home import profile_home_param
 from ..rpc import CallContext
 
 log = logging.getLogger("talaria_sidecar.gateway")
-_RESTART_LOCK = threading.Lock()
+# One lifecycle action at a time across every action: overlapping `hermes gateway` subprocesses race each other.
+_ACTION_LOCK = threading.Lock()
+ACTIONS = ("start", "stop", "restart")
+_DONE = {"start": "started", "stop": "stopped", "restart": "restarted"}
 
 
 def _hermes_command() -> str:
@@ -39,9 +42,11 @@ def _drain(stream, sink: list[str]) -> None:
             pass
 
 
-def restart(home: Path, cli_profile: str | None, ctx: CallContext, *, quick_timeout: float, background_wait: float) -> dict:
-    if not _RESTART_LOCK.acquire(blocking=False):
-        return {"status": "busy", "message": "Restart already in progress. Please wait a moment and try again."}
+def control(action: str, home: Path, cli_profile: str | None, ctx: CallContext, *, quick_timeout: float, background_wait: float) -> dict:
+    if action not in ACTIONS:
+        raise InvalidParams("unsupported gateway action")
+    if not _ACTION_LOCK.acquire(blocking=False):
+        return {"status": "busy", "message": "Another gateway action is already in progress. Please wait a moment and try again."}
     try:
         env = dict(os.environ)
         env["HERMES_HOME"] = str(home)
@@ -49,9 +54,12 @@ def restart(home: Path, cli_profile: str | None, ctx: CallContext, *, quick_time
         cmd = [_hermes_command()]
         if cli_profile:
             cmd.extend(["--profile", cli_profile])
-        cmd.extend(["gateway", "restart"])
-        log.info("Restarting gateway via %s (HERMES_HOME=%s)", " ".join(cmd), home)
-        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=env)
+        cmd.extend(["gateway", action])
+        log.info("Running gateway %s via %s (HERMES_HOME=%s)", action, " ".join(cmd), home)
+        try:
+            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=env)
+        except FileNotFoundError:
+            return {"status": "failed", "message": "Hermes CLI not found"}
         # Drain both pipes from the start: a chatty restart must never block on a full pipe and be mistaken for a hang.
         out: list[str] = []
         err: list[str] = []
@@ -67,8 +75,8 @@ def restart(home: Path, cli_profile: str | None, ctx: CallContext, *, quick_time
         def outcome() -> dict:
             stdout, stderr = collected()
             if proc.returncode == 0:
-                return {"status": "completed", "message": "Gateway service restarted successfully", "detail": stdout or stderr}
-            return {"status": "failed", "message": f"Restart failed: {stderr or stdout}", "detail": stdout or stderr, "returncode": proc.returncode}
+                return {"status": "completed", "message": f"Gateway service {_DONE[action]} successfully", "detail": stdout or stderr}
+            return {"status": "failed", "message": f"{action.capitalize()} failed: {stderr or stdout}", "detail": stdout or stderr, "returncode": proc.returncode}
 
         ctx.emit("progress", {"phase": "started"})
         deadline = time.monotonic() + quick_timeout
@@ -90,17 +98,26 @@ def restart(home: Path, cli_profile: str | None, ctx: CallContext, *, quick_time
                 proc.kill()
                 proc.wait(timeout=5)
             collected()
-            return {"status": "failed", "message": f"Gateway restart process timed out after {background_wait:.0f}s and was terminated"}
+            return {"status": "failed", "message": f"Gateway {action} process timed out after {background_wait:.0f}s and was terminated", "timed_out": True}
         return outcome()
     finally:
-        _RESTART_LOCK.release()
+        _ACTION_LOCK.release()
 
 
 def register(registry) -> None:
-    @registry.method("gateway.restart", requires_agent=False)
-    def restart_(ctx: CallContext, params: dict) -> dict:
+    def run(ctx: CallContext, params: dict, action: str) -> dict:
         home = profile_home_param(params)
         cli_profile = params.get("cli_profile")
         if cli_profile is not None and not isinstance(cli_profile, str):
             raise InvalidParams("cli_profile must be a string")
-        return restart(home, cli_profile or None, ctx, quick_timeout=float(params.get("quick_timeout_seconds") or 2.0), background_wait=float(params.get("background_wait_seconds") or 240.0))
+        # A restart drains the old gateway first, so it gets longer than start or stop.
+        default_wait = 240.0 if action == "restart" else 60.0
+        return control(action, home, cli_profile or None, ctx, quick_timeout=float(params.get("quick_timeout_seconds") or 2.0), background_wait=float(params.get("background_wait_seconds") or default_wait))
+
+    @registry.method("gateway.control", requires_agent=False)
+    def control_(ctx: CallContext, params: dict) -> dict:
+        return run(ctx, params, str(params.get("action") or ""))
+
+    @registry.method("gateway.restart", requires_agent=False)
+    def restart_(ctx: CallContext, params: dict) -> dict:
+        return run(ctx, params, "restart")

package/sidecar/talaria_sidecar/methods/kanban.py

@@ -96,10 +96,28 @@ def _row_claim_live(row) -> bool:
         return False
     columns = row.keys()
     claim = {k: row[k] if k in columns else None for k in ("status", "claim_lock", "worker_pid", "worker_started_at")}
+    claimed = bool(claim["claim_lock"] and claim["worker_pid"])
     try:
-        return bool(_kb()._claim_is_live(claim))
-    except Exception:  # noqa: BLE001 - an older Agent without the helper
-        return bool(claim["claim_lock"] and claim["worker_pid"])
+        helper = getattr(_kb(), "_claim_is_live", None)
+    except RpcError:
+        return claimed
+    if helper is not None:
+        try:
+            return bool(helper(claim))
+        except Exception:  # noqa: BLE001 - the Agent could not decide: unknown liveness counts as live
+            return claimed
+    if not claimed:
+        return False
+    try:
+        # Agent 0.21.3 has no _claim_is_live, but its dispatcher's own worker PID check. Like its crash sweep, probe
+        # only a claim this host issued: another host's PID means nothing here, so a remote claim stays live.
+        from hermes_cli.kanban_db_dispatch import _pid_alive
+
+        if not str(claim["claim_lock"]).startswith(_kb()._host_prefix()):
+            return True
+        return bool(_pid_alive(int(claim["worker_pid"])))
+    except Exception:  # noqa: BLE001
+        return True
 
 
 def _claim_live(conn, task_id) -> bool:
@@ -655,11 +673,14 @@ def bulk_payload(params: dict) -> dict:
 
 
 def dispatch_payload(params: dict) -> dict:
-    kb = _kb()
-    if not hasattr(kb, "dispatch_once"):
-        raise InvalidParams("dispatcher is unavailable")
+    _kb()
+    try:
+        # Agent 0.21.6 dropped the kanban_db re-export; every supported release defines it here.
+        from hermes_cli.kanban_db_dispatch import dispatch_once
+    except Exception as exc:  # noqa: BLE001
+        raise InvalidParams("dispatcher is unavailable") from exc
     with _conn(board=_board(params)) as conn:
-        result = kb.dispatch_once(conn, dry_run=_bool(params, "dry_run"), max_spawn=_int(params, "max", 8, minimum=1, maximum=100))
+        result = dispatch_once(conn, dry_run=_bool(params, "dry_run"), max_spawn=_int(params, "max", 8, minimum=1, maximum=100))
     if isinstance(result, dict):
         return result
     try:

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,6 +8,7 @@ import json
 import logging
 import queue
 import sqlite3
+import threading
 import time
 from contextlib import closing
 from pathlib import Path
@@ -42,12 +43,65 @@ 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()
@@ -60,6 +114,7 @@ def drain(max_events: int) -> list[dict]:
             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 = []
@@ -415,10 +470,9 @@ 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 hermes_cli.profiles import _PROFILE_ID_RE
+    from .profiles import named_profile_homes
 
-    profiles_root = base_home / "profiles"
-    named = sorted(p for p in profiles_root.iterdir() if p.is_dir() and _PROFILE_ID_RE.match(p.name)) if profiles_root.is_dir() else []
+    named = [home for _, home in named_profile_homes(base_home)]
     failed = []
     for home in [base_home, *named]:
         try:

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
 
 

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/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: