@maudecode/talaria-web 1.18.0 → 1.19.0

package/sidecar/talaria_sidecar/methods/memory.py

@@ -0,0 +1,84 @@
+"""``memory.*``: the Agent's ``MemoryStore`` reading of a memory page save (TAL-886) and its compare-and-write (TAL-784)."""
+
+from __future__ import annotations
+
+import errno
+import hashlib
+import os
+import stat
+import threading
+from pathlib import Path
+
+from ..errors import InvalidParams, RpcError
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+
+# Agents without the per-file lock helper: this sidecar's saves still run one at a time.
+_SAVE_LOCK = threading.Lock()
+
+
+def check(target: str, content: str) -> dict:
+    """``content``'s char count as the Agent's memory tool parses it, and the profile's limit for ``target``."""
+    from hermes_cli.config import load_config
+    from tools.memory_tool_store import ENTRY_DELIMITER, MemoryStore
+
+    mem = (load_config() or {}).get("memory") or {}
+    store = MemoryStore(**{key: int(mem[key]) for key in ("memory_char_limit", "user_char_limit") if mem.get(key) is not None})
+    # The store keeps each entry once (first occurrence wins), as its load and write paths do.
+    entries = list(dict.fromkeys(MemoryStore._parse_entries(content)))
+    return {"count": len(ENTRY_DELIMITER.join(entries)), "limit": store._char_limit(target)}
+
+
+def _digest(path: Path) -> str | None:
+    """SHA-256 hex of the regular file at ``path`` (of no bytes when there is none), never following a link; None otherwise."""
+    try:
+        fd = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0))
+    except FileNotFoundError:
+        return hashlib.sha256(b"").hexdigest()
+    except OSError as exc:
+        if exc.errno == errno.ELOOP:
+            return None
+        raise
+    with os.fdopen(fd, "rb") as handle:
+        if not stat.S_ISREG(os.fstat(handle.fileno()).st_mode):
+            return None
+        return hashlib.sha256(handle.read()).hexdigest()
+
+
+def write(home: Path, section: str, base: str, content: str) -> dict:
+    """Replace ``section``'s file with ``content`` only while its bytes still hash to ``base``, the server's read.
+
+    Each file is checked and written under the Agent's own per-file lock (``<file>.lock``), so neither a memory tool
+    call nor a concurrent save can land between the two; an Agent without the lock helper gets this sidecar's lock.
+    """
+    from tools.memory_tool_store import MemoryStore
+    from utils import atomic_write_text
+
+    if section not in ("memory", "user", "soul"):
+        raise InvalidParams("section must be memory, user, or soul")
+    # The files the server read: SOUL.md in the profile home, MEMORY.md / USER.md in its memories folder.
+    path = home / "SOUL.md" if section == "soul" else home / "memories" / ("USER.md" if section == "user" else "MEMORY.md")
+    file_lock = getattr(MemoryStore, "_file_lock", None)
+    try:
+        with file_lock(path) if file_lock else _SAVE_LOCK:
+            if _digest(path) != base:
+                return {"written": False}
+            atomic_write_text(path, content, tmp_prefix=".mem_", preserve_mode=True)
+    except OSError as exc:
+        if exc.errno not in (errno.EACCES, errno.EPERM, errno.EROFS):
+            raise
+        raise RpcError(f"{path.name} is not writable: {exc.strerror}", condition="memory_not_writable") from exc
+    return {"written": True}
+
+
+def register(registry) -> None:
+    @registry.method("memory.check")
+    def check_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return check(str(params["target"]), str(params["content"]))
+
+    @registry.method("memory.write")
+    def write_(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        with scoped_home(home):
+            return write(home, str(params["section"]), str(params["base"]), str(params["content"]))

package/sidecar/talaria_sidecar/methods/oauth.py

@@ -121,10 +121,13 @@ def _nous_begin() -> tuple[dict, dict]:
     from hermes_cli import anon_auth
     from hermes_cli.auth import PROVIDER_REGISTRY, _request_device_code
 
-    if anon_auth.guest_enabled() and anon_auth.has_guest():
+    # v0.22.0 replaced ``guest_enabled`` with ``guest_allowed``; 0.21.x releases only have the former.
+    guest_gate = getattr(anon_auth, "guest_allowed", None) or getattr(anon_auth, "guest_enabled")
+    if guest_gate() and anon_auth.has_guest():
         # The free tier's sign-in moves its connectors to the account (``anon_auth.run_sign_in``); a plain device-code
         # sign-in here would orphan them.
-        raise RpcError("This profile uses the Nous free tier. Sign in from Hermes with `hermes portal`.", condition="oauth_unsupported")
+        hint = getattr(anon_auth, "UPGRADE_HINT", None) or "Sign in from Hermes with `hermes auth upgrade`."
+        raise RpcError(f"This profile uses the Nous free tier. {hint}", condition="oauth_unsupported")
     pconfig = PROVIDER_REGISTRY["nous"]
     portal = (os.getenv("HERMES_PORTAL_BASE_URL") or os.getenv("NOUS_PORTAL_BASE_URL") or pconfig.portal_base_url).rstrip("/")
     with _client(15.0) as client:

package/sidecar/talaria_sidecar/methods/process.py

@@ -14,7 +14,7 @@ from contextlib import closing
 from pathlib import Path
 
 from ..errors import InvalidParams, RpcError
-from ..home import profile_home_param, scoped_home
+from ..home import _PROCESS_HOME, _is_named_profile, profile_home_param, scoped_home
 from ..rpc import CallContext
 
 log = logging.getLogger("talaria_sidecar.process")
@@ -28,11 +28,23 @@ def _registry():
     return process_registry
 
 
+def _is_child_process(row: dict) -> bool:
+    """TAL-933: a subagent's own process notice, which the server surfaces only when the owning profile opts in."""
+    try:
+        from tools.process_registry_notifications import is_child_process_notification
+    except Exception:  # noqa: BLE001 - before Agent 0.21.7, the same rule inline
+        if row.get("type") in ("async_delegation", "async_delegation_work_closeout"):
+            return False
+        return str(row.get("owner_task_id") or row.get("task_id") or "").startswith("sa-")
+    return bool(is_child_process_notification(row))
+
+
 def _event_row(evt: dict) -> dict:
     registry = _registry()
     row = {str(k): v for k, v in evt.items()} if isinstance(evt, dict) else {}
     process_id = str(row.get("delegation_id") or row.get("session_id") or row.get("task_id") or "") if row.get("type") == "async_delegation" else str(row.get("session_id") or "")
     row["process_id"] = process_id
+    row["child_process"] = _is_child_process(row)
     if registry is not None and process_id and (not row.get("session_key") or not row.get("origin_ui_session_id")):
         try:
             proc = registry.get(process_id)
@@ -102,12 +114,112 @@ def _publish_recovered_exits(registry) -> None:
                 _RECOVERED.setdefault(session.id, session)
 
 
+_COMPLETION_BASE_HOME: Path | None = None
+_RESTORED_COMPLETION_HOMES: set[Path] = set()
+
+
+def _completion_homes() -> list[Path]:
+    from hermes_constants import get_hermes_home
+    from .profiles import named_profile_homes
+
+    homes = [_PROCESS_HOME, Path(get_hermes_home())]
+    if _COMPLETION_BASE_HOME is not None:
+        # The server drains one global queue. Re-enumerate so new profiles join and removed/escaped ones leave.
+        homes += [_COMPLETION_BASE_HOME, *(home for _, home in named_profile_homes(_COMPLETION_BASE_HOME))]
+    return list(dict.fromkeys(home.resolve() for home in homes))
+
+
+def _restore_and_sweep_completions(registry) -> None:
+    from tools import async_delegation
+
+    restore = getattr(registry, "restore_completions", None)
+    if not callable(restore):
+        return  # Older Agents already restore at registry import and have no orphan sweep.
+    # The Agent binds the launch home itself, even when the first drain is in a named profile.
+    restore()
+    for home in _completion_homes():
+        try:
+            with scoped_home(home):
+                if _is_named_profile(home) and home not in _RESTORED_COMPLETION_HOMES:
+                    async_delegation.restore_undelivered_completions(registry.completion_queue)
+                    _RESTORED_COMPLETION_HOMES.add(home)
+                sweep = getattr(async_delegation, "maybe_sweep_orphaned_completions", None)
+                if callable(sweep):
+                    sweep(registry.completion_queue)
+        except Exception:  # noqa: BLE001 - retry this home without blocking other profiles or queued events
+            log.debug("Failed to restore or sweep delegation completions for %s", home, exc_info=True)
+
+
+_DELIVERY_RECONCILE_INTERVAL_S = 30
+_LAST_DELIVERY_RECONCILE: dict[Path, float] = {}
+_DELIVERY_RECONCILE_CURSOR: dict[Path, str] = {}
+_DELIVERY_RECONCILE_PAGE_SIZE = 200
+
+
+def _delivered_notifications(home: Path, delegation_id: str | None = None, after: str = "") -> tuple[list[dict], str]:
+    """Only typed transcript deliveries, never every delivered ledger row. No Agent state is changed."""
+    db_path = home / "state.db"
+    if not db_path.exists():
+        return [], ""
+    with closing(sqlite3.connect(f"{db_path.resolve().as_uri()}?mode=ro", uri=True, timeout=5)) as conn:
+        tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")}
+        if not {"async_delegations", "messages", "sessions"} <= tables:
+            return [], ""
+        rows = conn.execute("""WITH RECURSIVE candidates AS (
+            SELECT delegation_id, origin_ui_session_id, parent_session_id, origin_session_id, event_json
+            FROM async_delegations WHERE delivery_state='delivered' AND state NOT IN ('running','finalizing')
+            AND event_json IS NOT NULL AND origin_ui_session_id != '' AND delivered_at >= ?
+            AND (? IS NULL OR delegation_id=?) AND delegation_id > ?
+        ), lineage(delegation_id, id) AS (
+            SELECT delegation_id, parent_session_id FROM candidates WHERE parent_session_id != ''
+            UNION SELECT delegation_id, origin_session_id FROM candidates WHERE origin_session_id != ''
+            UNION SELECT l.delegation_id, s.id FROM lineage l
+                JOIN sessions parent ON parent.id=l.id AND parent.end_reason='compression'
+                JOIN sessions s ON s.parent_session_id=l.id
+        ) SELECT DISTINCT c.delegation_id, c.origin_ui_session_id, c.event_json
+        FROM candidates c JOIN lineage l ON l.delegation_id=c.delegation_id
+        JOIN messages m ON m.session_id=l.id
+        WHERE m.role='user' AND m.display_kind='async_delegation_complete'
+        AND json_valid(m.display_metadata)
+        AND json_extract(m.display_metadata, '$.delegation_id')=c.delegation_id
+        AND coalesce(json_extract(m.display_metadata, '$.delivery_notice'), '')=''
+        AND coalesce(json_extract(m.display_metadata, '$.presentation_suppressed'), 0)=0
+        ORDER BY c.delegation_id LIMIT ?""", (time.time() - 48 * 3600, delegation_id, delegation_id, after, _DELIVERY_RECONCILE_PAGE_SIZE)).fetchall()
+    events = []
+    for did, owner, payload in rows:
+        event = _json(payload)
+        if event.get("type") != "async_delegation" or event.get("delegation_id") != did or event.get("origin_ui_session_id") != owner or event.get("task_failure_notice"):
+            continue
+        events.append({**event, "reconciliation_profile_home": str(home.resolve())})
+    return events, rows[-1][0] if len(rows) == _DELIVERY_RECONCILE_PAGE_SIZE else ""
+
+
+def _reconcile_delivered_notifications() -> list[dict]:
+    out = []
+    for home in _completion_homes():
+        now = time.monotonic()
+        if now - _LAST_DELIVERY_RECONCILE.get(home, -float("inf")) < _DELIVERY_RECONCILE_INTERVAL_S:
+            continue
+        try:
+            events, cursor = _delivered_notifications(home, after=_DELIVERY_RECONCILE_CURSOR.get(home, ""))
+            out.extend(events)
+            _DELIVERY_RECONCILE_CURSOR[home] = cursor
+            _LAST_DELIVERY_RECONCILE[home] = now
+        except Exception:  # retry unreadable homes; never block live queue delivery
+            log.warning("Failed to reconcile typed delegation deliveries for %s", home, exc_info=True)
+    return out
+
+
 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:
+        _restore_and_sweep_completions(registry)
+    except Exception:  # noqa: BLE001 - maintenance must not prevent delivery of live queued events
+        log.debug("Failed to reconcile delegation completions", exc_info=True)
     try:
         # A recovered process has no reader thread; only this probe notices its exit and queues its completion (TAL-533).
         with registry._lock:
@@ -117,6 +229,12 @@ def drain(max_events: int) -> list[dict]:
         _publish_recovered_exits(registry)
     except Exception:  # noqa: BLE001
         log.debug("Failed to reconcile recovered processes", exc_info=True)
+    # Use the existing queue and its bound, so reconciliation cannot starve live or foreign events.
+    try:
+        for event in _reconcile_delivered_notifications():
+            completion_queue.put_nowait(event)
+    except Exception:
+        log.warning("Failed to offer typed delegation deliveries", exc_info=True)
     out = []
     while len(out) < max_events:
         try:
@@ -138,7 +256,7 @@ def requeue(events: list[dict]) -> int:
     count = 0
     for evt in events:
         try:
-            completion_queue.put_nowait({k: v for k, v in evt.items() if k not in ("process_id", "consumed")})
+            completion_queue.put_nowait({k: v for k, v in evt.items() if k not in ("process_id", "consumed", "child_process")})
             count += 1
         except Exception:  # noqa: BLE001
             log.debug("Failed to requeue process completion", exc_info=True)
@@ -196,6 +314,15 @@ def claim_delivery(evt: dict, consumer: str) -> str | None:
     if api is None:
         return ""
     claim_id = api.claim_event_delivery(_ledger_event(evt), consumer)
+    if claim_id is None and consumer == "webui" and evt.get("origin_ui_session_id"):
+        from hermes_constants import get_hermes_home
+        home = Path(get_hermes_home()).resolve()
+        if evt.get("reconciliation_profile_home", str(home)) == str(home):
+            # A live queue copy can race the transcript-only consumer too. Recheck the same proof here.
+            transport = {"process_id", "consumed", "child_process", "restored", "reconciliation_profile_home"}
+            for candidate in _delivered_notifications(home, str(evt.get("delegation_id") or ""))[0]:
+                if {k: v for k, v in candidate.items() if k not in transport} == {k: v for k, v in evt.items() if k not in transport}:
+                    return ""  # Web's session receipt acknowledges this admission, not the Agent ledger.
     return None if claim_id is None else str(claim_id)
 
 
@@ -230,11 +357,14 @@ def defer_delivery(evt: dict, claim_id: str) -> bool:
 
 
 def format_notification(evt: dict) -> str:
-    if evt.get("type") == "async_delegation":
+    if evt.get("type") in ("async_delegation", "heartbeat", "watch_match", "watch_disabled", "watch_overflow_tripped", "watch_overflow_released"):
         try:
-            from tools.process_registry import format_process_notification
+            from tools import process_registry
 
-            return format_process_notification(evt) or ""
+            # Older formatters fall through unknown events to an exit notification.
+            if evt.get("type") == "heartbeat" and not callable(getattr(getattr(process_registry, "ProcessRegistry", None), "_emit_heartbeat", None)):
+                return ""
+            return process_registry.format_process_notification(evt) or ""
         except Exception:  # noqa: BLE001
             return ""
     if evt.get("type") != "completion":
@@ -404,12 +534,21 @@ def _goal_text(content) -> str:
         return ""
     if content.startswith(_CONTENT_JSON_PREFIX):
         try:
-            parts = json.loads(content[len(_CONTENT_JSON_PREFIX):])
-        except ValueError:
-            return ""
-        texts = [p.get("text") for p in parts if isinstance(p, dict) and p.get("type") == "text"] if isinstance(parts, list) else []
+            from hermes_state import SessionDB
+            decode = getattr(SessionDB, "_decode_content", None)
+        except ImportError:
+            decode = None
+        if callable(decode):
+            content = decode(content)
+        else:
+            try:
+                content = json.loads(content[len(_CONTENT_JSON_PREFIX):])
+            except ValueError:
+                pass  # Legacy malformed marker rows remain literal text, as in the Agent.
+    if isinstance(content, list):
+        texts = [p.get("text") for p in content if isinstance(p, dict) and p.get("type") == "text"]
         return str(texts[0]) if texts and texts[0] else ""
-    return content.split(_IMAGE_HINTS, 1)[0]
+    return content.split(_IMAGE_HINTS, 1)[0] if isinstance(content, str) else ""
 
 
 def unit_children(unit: dict, owner: str, live: list[dict], finished: list[dict], now: float) -> list[dict]:
@@ -472,6 +611,8 @@ def recover(base_home: Path) -> int:
     recovery fails the call, so the server retries."""
     from .profiles import named_profile_homes
 
+    global _COMPLETION_BASE_HOME
+    _COMPLETION_BASE_HOME = base_home
     named = [home for _, home in named_profile_homes(base_home)]
     failed = []
     for home in [base_home, *named]:
@@ -533,7 +674,15 @@ def register(registry_) -> None:
         if not consumer:
             raise InvalidParams("consumer is required")
         with scoped_home(profile_home_param(params)):
-            return {"claim_id": claim_delivery(evt, consumer)}
+            claim = claim_delivery(evt, consumer)
+            result = {"claim_id": claim}
+            if claim is None:
+                api = _delivery_api()
+                lookup = getattr(api, "get_durable_delegation", None)
+                row = lookup(str(evt.get("delegation_id") or "")) if callable(lookup) else None
+                if row and row.get("delivery_state") == "pending":
+                    result["retryable"] = True
+            return result
 
     @registry_.method("process.complete_delivery")
     def complete_(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/profiles.py

@@ -151,20 +151,58 @@ def canonical_bot_chat(home: Path) -> dict | None:
             pass
 
 
+GATEWAY_RUNNING_MODES = ("own", "served")
+
+
+def gateway_mode(home: Path, name: str, is_default: bool) -> str:
+    """The profile's gateway under the host multiplexer (TAL-805): ``served`` by the live host gateway, ``own`` gateway
+    process, ``parked`` (``hermes -p X gateway stop`` left its marker and nothing runs; the marker records intent, so a
+    live ``--force`` gateway still counts, as in ``hermes -p X gateway status``), ``standalone`` (opted out of the host and
+    not running), else ``stopped``. The default profile is the host itself.
+    A helper the installed Agent lacks answers no, so an Agent without the multiplexer helpers reports ``own`` or
+    ``stopped``; a helper that fails answers no too, except the parked check, which fails closed to ``stopped``."""
+    from hermes_cli import profiles as agent
+
+    def probe(helper: str, arg) -> bool | None:
+        check = getattr(agent, helper, None)
+        if check is None:
+            return False
+        try:
+            return bool(check(arg))
+        except Exception:  # noqa: BLE001
+            log.debug("gateway mode probe %s failed for %s", helper, home, exc_info=True)
+            return None
+
+    def asks(helper: str, arg) -> bool:
+        return probe(helper, arg) is True
+
+    named = not is_default
+    parked = probe("profile_is_parked", home) if named else False
+    if parked is None:
+        return "stopped"
+    if named and asks("_served_by_running_multiplexer", name):
+        return "served"
+    if asks("_check_gateway_running", home):
+        return "own"
+    if parked:
+        return "parked"
+    if named and asks("profile_is_standalone", home):
+        return "standalone"
+    return "stopped"
+
+
 def _row(home: Path, name: str, is_default: bool) -> dict:
-    from hermes_cli.profiles import _check_gateway_running, _read_config_model
+    from hermes_cli.profiles import _read_config_model
 
     try:
         model, provider = _read_config_model(home)
     except Exception:  # noqa: BLE001
         model, provider = None, None
-    try:
-        gateway_running = bool(_check_gateway_running(home))
-    except Exception:  # noqa: BLE001
-        gateway_running = False
+    mode = gateway_mode(home, name, is_default)
     enabled, total = skills_stats(home)
     return {
-        "name": name, "path": str(home), "is_default": is_default, "gateway_running": gateway_running, "model": model, "provider": provider,
+        "name": name, "path": str(home), "is_default": is_default, "gateway_running": mode in GATEWAY_RUNNING_MODES, "gateway_mode": mode,
+        "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),
     }