@maudecode/talaria-web 1.19.0 → 1.21.0

package/sidecar/talaria_sidecar/methods/state_db.py

@@ -20,7 +20,7 @@ from contextlib import closing, contextmanager
 from pathlib import Path
 
 from ..errors import InvalidParams, RpcError
-from ..home import profile_home_param
+from ..home import profile_home_param, scoped_home
 from ..rpc import CallContext
 
 log = logging.getLogger("talaria_sidecar.state_db")
@@ -52,30 +52,107 @@ def _session_id(params: dict) -> str:
     return sid
 
 
-def sync_session_start(home: Path, session_id: str, model=None) -> bool:
-    db = _session_db(home)
-    if not db:
-        return False
+# TAL-1191: write RPCs borrow the Agent's shared registry handle for the home's state.db (the one cached chat agents
+# hold) instead of a full writer open and close-time checkpoint per call. One extra reference per home stays pinned for
+# _IDLE_RELEASE_S after its last write; the registry hands out a fresh generation once the file is replaced.
+_IDLE_RELEASE_S = 60.0
+_pins_lock = threading.Lock()
+_pins: dict[str, tuple[object, threading.Timer]] = {}
+
+
+def release_session_db(db) -> None:
+    """Give back a registry reference (a cached agent's or a write pin); the final one closes the handle."""
+    if db is None:
+        return
     try:
-        db.ensure_session(session_id=session_id, source="webui", model=model)
-        return True
+        from hermes_state_registry import release_or_close
+
+        release_or_close(db)
     except Exception:  # noqa: BLE001
-        log.debug("Failed to sync session start", exc_info=True)
+        log.warning("releasing a state.db handle failed", exc_info=True)
+
+
+def _write(home: Path, what: str, op, *, level: int = logging.DEBUG) -> bool:
+    """Run ``op(db)`` on the shared handle; False without a state.db or when it fails. A failed write unpins the handle,
+    so the next one reopens it unless another holder keeps it."""
+    try:
+        from hermes_state_registry import acquire
+    except ImportError as exc:
+        raise RpcError("hermes_state unavailable", condition="state_db_unavailable") from exc
+    db_path = home / "state.db"
+    if not db_path.exists():
         return False
-    finally:
-        _close(db)
+    try:
+        db = acquire(db_path)
+    except Exception as exc:  # noqa: BLE001
+        log.debug("Failed to open state.db at %s: %s", db_path, exc)
+        return False
+    key = os.path.realpath(home)
+    # This call's reference keeps the same generation open; a retired one (replaced file) closes before its replacement
+    # is written, so its close-time checkpoint cannot carry the new rows into the old inode.
+    _pin(key, None)
+    ok = False
+    try:
+        op(db)
+        ok = True
+    except Exception:  # noqa: BLE001
+        log.log(level, "Failed to %s", what, exc_info=True)
+    if ok and db_path.exists():
+        _pin(key, db)
+    else:
+        release_session_db(db)
+    return ok
+
+
+def _pin(key: str, db) -> None:
+    """Make ``db`` (this call's reference) the home's pin with a fresh idle timer, giving back the previous pin."""
+    with _pins_lock:
+        previous = _pins.pop(key, None)
+        if previous is not None:
+            previous[1].cancel()
+        if db is not None:
+            timer = threading.Timer(_IDLE_RELEASE_S, lambda: _expire(key, timer))
+            timer.daemon = True
+            _pins[key] = (db, timer)
+            timer.start()
+    if previous is not None:  # outside the lock: a final release checkpoints
+        release_session_db(previous[0])
+
+
+def _expire(key: str, timer: threading.Timer) -> None:
+    with _pins_lock:
+        pinned = _pins.get(key)
+        if pinned is None or pinned[1] is not timer:
+            return
+        del _pins[key]
+    release_session_db(pinned[0])
+
+
+def release_home(home) -> None:
+    """Give back the pinned handle for ``home`` before its profile is deleted."""
+    _pin(os.path.realpath(home), None)
+
+
+def release_all() -> None:
+    """Shutdown: give back every pinned handle, so the final release still checkpoints once per process."""
+    with _pins_lock:
+        keys = list(_pins)
+    for key in keys:
+        _pin(key, None)
+
+
+def sync_session_start(home: Path, session_id: str, model=None) -> bool:
+    return _write(home, "sync session start", lambda db: db.ensure_session(session_id=session_id, source="webui", model=model))
 
 
 def sync_session_usage(home: Path, session_id: str, *, input_tokens=0, output_tokens=0, estimated_cost=None, model=None, title=None,
                        message_count=None, cache_read_tokens=0, cache_write_tokens=0, api_call_count=None) -> bool:
-    db = _session_db(home)
-    if not db:
-        return False
-    try:
-        db.ensure_session(session_id=session_id, source="webui", model=model)
+    def op(db) -> None:
+        # The token update's own row guard creates the session with this source, like ``ensure_session``.
         db.update_token_counts(
             session_id=session_id, input_tokens=input_tokens, output_tokens=output_tokens, cache_read_tokens=cache_read_tokens,
             cache_write_tokens=cache_write_tokens, api_call_count=api_call_count or 0, estimated_cost_usd=estimated_cost, model=model, absolute=True,
+            source="webui",
         )
         if title:
             try:
@@ -87,22 +164,16 @@ def sync_session_usage(home: Path, session_id: str, *, input_tokens=0, output_to
                 db._execute_write(lambda conn: conn.execute("UPDATE sessions SET message_count = ? WHERE id = ?", (message_count, session_id)))
             except Exception:  # noqa: BLE001
                 log.debug("Failed to sync message count", exc_info=True)
-        return True
-    except Exception:  # noqa: BLE001
-        log.debug("Failed to sync session usage", exc_info=True)
-        return False
-    finally:
-        _close(db)
+
+    return _write(home, "sync session usage", op)
 
 
 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)
-    if not db:
-        return False
-    try:
+
+    def op(db) -> None:
         db.ensure_session(session_id=session_id, source="webui")
         source = getattr(db, "TITLE_SOURCE_LLM", "llm")
 
@@ -118,28 +189,16 @@ def sync_session_title(home: Path, session_id: str, title: str, *, manual: bool
             alt = db.get_next_title_in_lineage(title)
             if alt and alt != title:
                 write(alt)
-        return True
-    except Exception:  # noqa: BLE001
-        log.debug("Failed to sync session title", exc_info=True)
-        return False
-    finally:
-        _close(db)
+
+    return _write(home, "sync session title", op)
 
 
 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.warning("Failed to append a %s row to state.db for %s", role, session_id, exc_info=True)
-        return False
-    finally:
-        _close(db)
+    return _write(home, f"append a {role} row to state.db for {session_id}",
+                  lambda db: db.append_message(session_id, role, content=content, tool_name=tool_name or None, timestamp=timestamp),
+                  level=logging.WARNING)
 
 
 def _close(db) -> None:
@@ -437,6 +496,11 @@ def _delete_runtime_rows(requested: str, home: Path, agent_db, guarded, delete_i
         return result["deleted_ids"]
 
     deleted_ids = agent_db._execute_write(write)
+    # Agent v0.22.3+ tells the profile's plugins after the commit, like its own deletes; the emitter is fail-open.
+    import hermes_state_common
+    emit_session_deleted = getattr(hermes_state_common, "emit_session_deleted", None)
+    if emit_session_deleted is not None:
+        emit_session_deleted(agent_db, deleted_ids, reason="delete", primary=requested, sessions_dir=home / "sessions")
     try:
         collect_retired_media(agent_db)
     except Exception:  # noqa: BLE001 - retirement committed; retain its targets for caller cleanup and manifest retry
@@ -624,6 +688,22 @@ def delete_cli_session(home: Path, sid: str, include_lineage: bool = False) -> d
         return {"ok": False}
 
 
+def prune_advice(home: Path) -> dict | None:
+    """The Agent's low-disk session auto-prune question for ``home`` (v0.22.3 ``hermes_cli.prune_advisor``) in its own
+    words; None while the Agent would not ask (disk not low, ``sessions.auto_prune`` set, snoozed) or has no advisor."""
+    try:
+        from hermes_cli import prune_advisor
+    except ImportError:
+        return None
+    advice, stale = prune_advisor.cached_advice(home)
+    if advice is None and not stale:
+        return None
+    if advice is None or stale:
+        # Measures state.db (seconds on a large store), on this request's own worker thread.
+        advice = prune_advisor.advise(home)
+    return {"lines": prune_advisor.advice_lines(advice, command_prefix="/")} if advice else None
+
+
 def register(registry) -> None:
     @registry.method("state_db.sync_start")
     def start(ctx: CallContext, params: dict) -> dict:
@@ -657,3 +737,9 @@ def register(registry) -> None:
         if not _is_safe_session_id(sid):
             raise InvalidParams("unsafe session_id")
         return delete_cli_session(profile_home_param(params).resolve(), sid, params.get("include_compression_lineage") is True)
+
+    @registry.method("state_db.prune_advice")
+    def prune_advice_(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        with scoped_home(home):
+            return {"advice": prune_advice(home)}

package/sidecar/talaria_sidecar/methods/toolsets.py

@@ -1,13 +1,15 @@
 """Profile toolset policy and catalog. All callers run under ``scoped_home``."""
 
+from __future__ import annotations
+
 from ..home import profile_home_param, scoped_home
 
 
-def disabled_toolsets() -> list[str]:
+def disabled_toolsets(cfg: dict | None = None) -> list[str]:
     from agent.skill_utils import parse_config_string_list
     from hermes_cli.config import load_config
 
-    section = (load_config() or {}).get('agent') or {}
+    section = ((load_config() or {}) if cfg is None else cfg).get('agent') or {}
     return [name.strip() for name in parse_config_string_list(section.get('disabled_toolsets')) if name.strip()]
 
 

package/sidecar/talaria_sidecar/methods/worktree.py

@@ -1,10 +1,14 @@
-"""``worktree.*``: Hermes Agent git worktree creation (``hermes_cli.worktree_ops._setup_worktree``)."""
+"""``worktree.*``: Hermes Agent git worktree creation (``hermes_cli.worktree_ops._setup_worktree``) and lock retention."""
 
 from __future__ import annotations
 
+import contextlib
 import io
 import logging
+import os
+import re
 import subprocess
+import uuid
 from contextlib import redirect_stderr, redirect_stdout
 from pathlib import Path
 
@@ -41,6 +45,112 @@ def _refuse_unneutralized_repo_filters(repo_root: str) -> None:
                        condition="worktree_unsafe_repo")
 
 
+# The Agent's own lock contract (``worktree_ops._worktree_lock_is_live``): its sweep keeps a tree whose ``hermes pid=`` owner runs.
+_HERMES_PID_LOCK = re.compile(r"hermes pid=(\d+)(?: db=.+)?", re.DOTALL)
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except (ProcessLookupError, OverflowError):  # gone, or a pid no process can have
+        return False
+    except OSError:
+        return True  # exists, owned by someone else
+    return True
+
+
+# Only these say the tree or its registration is gone; any other read failure leaves the tree unconfirmed (raised).
+_GONE = (FileNotFoundError, NotADirectoryError, IsADirectoryError)
+
+
+def _admin_dir(tree: Path) -> Path | None:
+    """The tree's ``<common-dir>/worktrees/<name>`` entry when git still registers it as a linked worktree."""
+    try:
+        link = (tree / ".git").read_text(encoding="utf-8-sig")
+    except _GONE:
+        return None
+    if not link.startswith("gitdir:"):
+        return None
+    admin = (tree / link[len("gitdir:"):].strip()).resolve()
+    try:
+        registered = Path((admin / "gitdir").read_text(encoding="utf-8-sig").strip()).resolve()
+    except _GONE:
+        return None
+    return admin if admin.parent.name == "worktrees" and registered == (tree / ".git").resolve() else None
+
+
+def _take_lock(admin: Path, expected: str) -> bool:
+    """Remove the tree's lock only while it still reads ``expected``: it is moved aside first, so a lock written since it
+    was read is never deleted; anything else is put back unless a newer lock already holds the tree."""
+    lock, aside = admin / "locked", admin / f"locked.talaria-{uuid.uuid4().hex}"
+    try:
+        os.rename(lock, aside)
+    except FileNotFoundError:
+        return True
+    try:
+        stale = aside.read_text(encoding="utf-8-sig", errors="replace").strip(" \t\n\v\f\r") == expected
+    except OSError:
+        stale = False
+    if not stale:
+        try:
+            os.link(aside, lock)
+        except FileExistsError:
+            pass  # a newer lock holds the tree
+        except OSError:
+            # No hard link here: move it back whole, never leave the tree unlocked by dropping it.
+            with contextlib.suppress(OSError):
+                os.rename(aside, lock)
+            return False
+    aside.unlink(missing_ok=True)
+    return stale
+
+
+def retain(path: str) -> str:
+    """Lock a Talaria worktree for this process, so the Agent's sweep reads its lock live (TAL-1254).
+
+    ``missing`` when the tree is gone or git no longer registers it; ``foreign_lock`` when a lock that is not a ``hermes
+    pid=`` lock (a user's own) holds it, which stays untouched. A ``hermes pid=`` lock of an exited process is replaced;
+    one of a live other process (a reused pid, another instance) is left alone and raises, so the caller retries until
+    this sidecar holds the lock.
+    """
+    tree = Path(path)
+    admin = _admin_dir(tree)
+    if admin is None:
+        return "missing"
+    ours = f"hermes pid={os.getpid()}"
+    try:
+        reason = (admin / "locked").read_text(encoding="utf-8-sig", errors="replace").strip(" \t\n\v\f\r")
+    except FileNotFoundError:
+        reason = None
+    if reason == ours:
+        return "retained"
+    if reason is not None:
+        lock = _HERMES_PID_LOCK.fullmatch(reason)
+        if lock is None:
+            return "foreign_lock"
+        if int(lock.group(1)) != os.getpid() and _pid_alive(int(lock.group(1))):
+            raise OSError(f"locked by running pid {lock.group(1)}")
+        if not _take_lock(admin, reason):
+            raise OSError("the lock changed while it was being replaced")
+    # git refuses to lock a tree someone locked meanwhile, so that lock stays too.
+    locked = subprocess.run(["git", "-C", str(tree), "worktree", "lock", "--reason", ours, str(tree)],
+                            capture_output=True, timeout=10, check=False, stdin=subprocess.DEVNULL)
+    if locked.returncode != 0:
+        raise OSError(locked.stderr.decode(errors="replace").strip() or "git worktree lock failed")
+    return "retained"
+
+
+def retain_all(paths: list[str]) -> dict[str, str]:
+    """``retain`` per path; a tree this sidecar cannot lock now is left out (unknown), never reported missing."""
+    results = {}
+    for path in dict.fromkeys(paths):
+        try:
+            results[path] = retain(path)
+        except (OSError, subprocess.SubprocessError) as exc:
+            log.warning("Could not retain worktree %s: %s", path, exc)
+    return results
+
+
 def create(repo_root: str) -> dict:
     root = Path(repo_root).expanduser()
     if not root.is_dir():
@@ -60,8 +170,10 @@ def create(repo_root: str) -> dict:
         log.debug("Hermes Agent worktree helper output: %s", emitted)
     if not info or not info.get("path") or not info.get("branch"):
         raise RpcError("Hermes Agent failed to create a git worktree", condition="worktree_failed")
+    path = str(Path(info["path"]).expanduser().resolve())
+    retain_all([path])  # one owner for Talaria's lock text
     return {
-        "path": str(Path(info["path"]).expanduser().resolve()),
+        "path": path,
         "branch": str(info["branch"]),
         "repo_root": str(Path(info.get("repo_root") or probe.stdout.strip()).expanduser().resolve()),
         "base": str(info["base"]) if info.get("base") else None,
@@ -76,3 +188,10 @@ def register(registry) -> None:
             raise InvalidParams("repo_root is required")
         with scoped_home(profile_home_param(params)):
             return create(repo_root)
+
+    @registry.method("worktree.retain")
+    def retain_(ctx: CallContext, params: dict) -> dict:
+        paths = params.get("paths")
+        if not isinstance(paths, list) or not all(isinstance(p, str) and p for p in paths):
+            raise InvalidParams("paths must be a list of worktree paths")
+        return {"results": retain_all(paths)}

package/sidecar/talaria_sidecar/rpc.py

@@ -21,6 +21,8 @@ import threading
 import traceback
 from typing import Any, Callable
 
+from .startup_timing import StartupTiming, outcome_for
+
 from .errors import (
     APPLICATION_ERROR,
     INTERNAL_ERROR,
@@ -42,11 +44,12 @@ DEFAULT_MAX_CALLS = 64
 class CallContext:
     """Per-request handle: stream emission and cooperative cancellation."""
 
-    def __init__(self, server: "RpcServer", request_id: Any, method: str):
+    def __init__(self, server: "RpcServer", request_id: Any, method: str, request: dict | None = None):
         self.server = server
         self.id = request_id
         self.method = method
         self.cancel_event = threading.Event()
+        self.timing = StartupTiming(request) if method == "chat.start" and request is not None else None
         self._seq = 0
         self._seq_lock = threading.Lock()
 
@@ -63,6 +66,8 @@ class CallContext:
         with self._seq_lock:
             self._seq += 1
             seq = self._seq
+        if self.timing:
+            self.timing.frame(event, data)
         self.server.notify("stream", {"id": self.id, "seq": seq, "event": event, "data": data if data is not None else {}})
 
 
@@ -127,6 +132,8 @@ class RpcServer:
         with self._active_lock:
             for ctx in self._active.values():
                 ctx.cancel_event.set()
+                if ctx.timing:
+                    ctx.timing.finish("unknown")
 
     # ── dispatch ──────────────────────────────────────────────────────────
     def _register(self, request: dict) -> CallContext | None:
@@ -135,7 +142,7 @@ class RpcServer:
         method = request.get("method")
         if request_id is None or not isinstance(method, str):
             return None
-        ctx = CallContext(self, request_id, method)
+        ctx = CallContext(self, request_id, method, request)
         with self._active_lock:
             self._active[request_id] = ctx
         return ctx
@@ -147,6 +154,8 @@ class RpcServer:
         if params is None:
             params = {}
         if not isinstance(method, str) or not isinstance(params, dict):
+            if ctx and ctx.timing:
+                ctx.timing.finish("refused")
             if request_id is not None:
                 with self._active_lock:
                     self._active.pop(request_id, None)
@@ -160,19 +169,28 @@ class RpcServer:
                 self._error(request_id, METHOD_NOT_FOUND, f"unknown method {method}")
             return
         if ctx is None:
-            ctx = CallContext(self, request_id, method)
+            ctx = CallContext(self, request_id, method, request)
             if request_id is not None:
                 with self._active_lock:
                     self._active[request_id] = ctx
+        outcome = "error"
+        if ctx.timing:
+            ctx.timing.end("rpc_wait")
+            ctx.timing.observe("rpc_start")
         try:
             result = handler(ctx, params)
+            status = result.get("status") if isinstance(result, dict) else None
+            failed = isinstance(result, dict) and bool(result.get("failed") or result.get("partial") or result.get("error"))
+            outcome = "cancelled" if ctx.cancelled or status == "cancelled" else "error" if status == "error" or failed else "ok"
             if request_id is not None:
                 self._result(request_id, result if result is not None else {})
         except RpcError as exc:
+            outcome = outcome_for(exc)
             if request_id is not None:
                 error = exc.to_json()
                 self._error(request_id, error["code"], error["message"], error.get("data"))
         except TypeError as exc:
+            outcome = "refused"
             # Wrong keyword arguments reaching a wrapped Agent function.
             log.debug("invalid params for %s", method, exc_info=True)
             if request_id is not None:
@@ -182,6 +200,8 @@ class RpcServer:
             if request_id is not None:
                 self._error(request_id, INTERNAL_ERROR, f"{type(exc).__name__}: {exc}")
         finally:
+            if ctx.timing:
+                ctx.timing.finish(outcome)
             if request_id is not None:
                 with self._active_lock:
                     self._active.pop(request_id, None)
@@ -237,6 +257,8 @@ class RpcServer:
                 self._dispatch(request)
                 continue
             if not self._slots.acquire(blocking=False):
+                if request.get("method") == "chat.start":
+                    StartupTiming(request).finish("refused")
                 self._error(request.get("id"), APPLICATION_ERROR, "sidecar is at its concurrent call limit", {"condition": "sidecar_busy"})
                 continue
             ctx = self._register(request)

package/sidecar/talaria_sidecar/runtime.py

@@ -270,6 +270,7 @@ class AgentRuntime:
         self._stale = False
         self._source_changed = False
         self._stale_stamp: tuple | None = None
+        self._receipt_discovery: dict = {}
         self.agent_dir = Path(agent_dir).resolve() if agent_dir else None
         self.pin = read_pin()
         self.loaded = False
@@ -277,10 +278,14 @@ class AgentRuntime:
         self.revision: str | None = None
         self.import_error: str | None = None
         self._lock = threading.Lock()
+        self._handoff = None
+        self._retired = False
 
     # ── loading ───────────────────────────────────────────────────────────
     def load(self) -> None:
         with self._lock:
+            if self._retired:
+                raise AgentRuntimeStale(None)
             if self.loaded:
                 return
             try:
@@ -296,7 +301,20 @@ class AgentRuntime:
                 # a named profile's plugin loaded later never enters that process-wide snapshot.
                 importlib.import_module("hermes_cli.auth")
                 _check_site_packages_python()
+                try:
+                    handoff = importlib.import_module("hermes_cli.guest_handoff")
+                except ModuleNotFoundError as exc:
+                    if exc.name != "hermes_cli.guest_handoff":
+                        raise
+                else:
+                    # Retain custody even when startup raises after creating its thread.
+                    if not callable(handoff.start_worker) or not callable(handoff.stop_worker):
+                        raise RuntimeError("Native handoff lifecycle API is incomplete")
+                    self._handoff = handoff
+                    if not handoff.start_worker().is_alive():
+                        raise RuntimeError("Native handoff worker did not start")
             except Exception as exc:  # noqa: BLE001 - reported as a handshake condition
+                self._stop_handoff()
                 self.import_error = f"{type(exc).__name__}: {exc}"
                 raise AgentIncompatible(f"Hermes Agent could not be imported: {self.import_error}", import_error=self.import_error)
             module_file = getattr(module, "__file__", None)
@@ -306,6 +324,21 @@ class AgentRuntime:
             self.revision = read_agent_revision(self.agent_dir, self.module_path)
             self.loaded = True
 
+    def _stop_handoff(self) -> None:
+        if self._handoff is not None:
+            # Native requests are bounded. Join fully before code/dependencies may change.
+            self._handoff.stop_worker(timeout=None)
+            self._handoff = None
+
+    def retire(self) -> None:
+        """Release native background writes; only a fresh process may own them again."""
+        with self._lock:
+            if self._handoff is None:
+                return
+            self._retired = True
+            self.loaded = False
+            self._stop_handoff()
+
     @property
     def agent_version(self) -> str | None:
         try:
@@ -348,7 +381,8 @@ class AgentRuntime:
             return "absent"
         from .agent_mutation import recovery_receipts
         try:
-            receipts, _ = recovery_receipts(self)
+            with self._stale_lock:
+                receipts, _ = recovery_receipts(self, discovery_cache=self._receipt_discovery)
             return 'present' if receipts else 'absent'
         except (OSError, UnicodeError):
             return 'unknown'
@@ -377,12 +411,16 @@ class AgentRuntime:
             self._source_changed = fresh is not None and fresh != self.revision
             self._stale = fresh != self.revision
             self._stale_stamp = stamp if fresh is not None else None
-            return self._stale
+            stale = self._stale
+        if stale:
+            self.retire()
+        return stale
 
     def ensure_current(self) -> None:
         """Refuse Agent work until source drift or a durable Web update obligation is reconciled."""
         repair = self.web_repair_state()
         if repair != "absent":
+            self.retire()
             raise AgentRuntimeStale("unknown" if repair == "unknown" else self.update_transaction_state())
         if self.is_stale():
             raise AgentRuntimeStale(self.update_transaction_state(), source_changed=self._source_changed)
@@ -391,6 +429,7 @@ class AgentRuntime:
     def describe(self) -> dict:
         # The pin records official test coverage, not runtime capability. Each operation still checks its imports,
         # profile isolation and loaded-revision guard at the point of use.
+        stale = self.is_stale() or self._retired
         return {
             "rpc_version": SIDECAR_RPC_VERSION,
             "python": sys.executable,
@@ -402,7 +441,7 @@ class AgentRuntime:
             "pinned_version": self.pin["version"],
             "pinned_image": self.pin["image"],
             "compatible": self.loaded,
-            "stale": self.is_stale(),
+            "stale": stale,
             "agent_source_changed": self._source_changed,
             "update_state": self.update_transaction_state(),
             "import_error": self.import_error,

package/sidecar/talaria_sidecar/speed.py

@@ -30,6 +30,18 @@ def supported_speed_tiers(model: str, provider: str, base_url: str) -> list[dict
     tiers = []
     for tier in ("priority", "ultrafast"):
         override = fast_overrides(model, provider, base_url, tier)
-        if override:
+        if override and (tier != "ultrafast" or ultrafast_offered(model, provider, base_url)):
             tiers.append({"id": "fast" if override.get("speed") == "fast" else tier, "service_tier": tier})
     return [{"id": "standard", "service_tier": "default"}, *tiers] if tiers else []
+
+
+def ultrafast_offered(model: str, provider: str, base_url: str) -> bool:
+    """The Agent's account check: a Codex plan without Ultrafast accepts the tier and silently serves default."""
+    try:
+        from agent import codex_service_tiers
+    except ModuleNotFoundError as error:
+        if error.name not in ("agent", "agent.codex_service_tiers"):
+            raise
+        return True
+    offered = getattr(codex_service_tiers, "ultrafast_offered", None)
+    return offered is None or bool(offered(model, provider=provider, base_url=base_url))