@maudecode/talaria-web 1.15.0 → 1.17.2

package/sidecar/talaria_sidecar/methods/commands.py

@@ -7,14 +7,22 @@ import threading
 from typing import Any
 
 from ..errors import InvalidParams, RpcError
-from ..home import profile_home_param, scoped_home
+from ..home import _is_named_profile, profile_home_param, scoped_home
 from ..rpc import CallContext
+from .providers import plugin_providers
 
 log = logging.getLogger("talaria_sidecar.commands")
 
 _NEVER_EXPOSE = frozenset({"sethome", "restart", "update", "commands"})
 _ALIASES = {"reload_mcp": "reload-mcp", "reload_skills": "reload-skills", "codex_runtime": "codex-runtime"}
-_ALLOWED = frozenset({"reload-mcp", "reload-skills", "codex-runtime", "credits"})
+# The commands ``commands.exec`` runs, with the catalog row the sidecar lists when the Agent registry lacks one.
+_RUNTIME_COMMANDS = {
+    "reload-mcp": ("Reload MCP servers from config", "Tools & Skills", ""),
+    "reload-skills": ("Re-scan skills from disk", "Tools & Skills", ""),
+    "codex-runtime": ("Toggle codex app-server runtime for OpenAI/Codex models", "Configuration", "[auto|codex_app_server]"),
+    "credits": ("Show your Nous credits", "Info", ""),
+}
+_ALLOWED = frozenset(_RUNTIME_COMMANDS)
 _RELOAD_MCP_LOCK = threading.Lock()
 _RELOAD_SKILLS_LOCK = threading.Lock()
 _CODEX_RUNTIME_LOCK = threading.Lock()
@@ -45,7 +53,13 @@ def list_commands() -> list[dict[str, Any]]:
         out.append({
             "name": cmd.name, "description": cmd.description, "category": cmd.category, "aliases": list(cmd.aliases),
             "args_hint": cmd.args_hint, "subcommands": list(cmd.subcommands), "cli_only": bool(cmd.cli_only), "gateway_only": bool(cmd.gateway_only),
+            "exec": cmd.name in _ALLOWED,
         })
+    listed = {c["name"] for c in out}
+    for name, (description, category, args_hint) in _RUNTIME_COMMANDS.items():
+        if name not in listed:
+            out.append({"name": name, "description": description, "category": category, "aliases": [a for a, n in _ALIASES.items() if n == name],
+                        "args_hint": args_hint, "subcommands": [], "cli_only": False, "gateway_only": False, "exec": True})
     try:
         from hermes_cli.plugins import get_plugin_commands
 
@@ -54,25 +68,60 @@ def list_commands() -> list[dict[str, Any]]:
             if name in existing or name in _NEVER_EXPOSE:
                 continue
             out.append({"name": name, "description": str(info.get("description", "Plugin command")), "category": "Plugin", "aliases": [],
-                        "args_hint": str(info.get("args_hint", "")), "subcommands": [], "cli_only": False, "gateway_only": False})
+                        "args_hint": str(info.get("args_hint", "")), "subcommands": [], "cli_only": False, "gateway_only": False, "exec": True})
     except Exception:  # noqa: BLE001 - plugin registry is optional
         log.debug("plugin command listing failed", exc_info=True)
     return out
 
 
+def retire_unscoped_launch_mcp_servers() -> set[str]:
+    """Close the launch profile's connections opened before multiplexing started; returns their server names.
+
+    Until the first named-profile call, the launch profile's connections and tools are unscoped (process-wide). Once
+    multiplexing is active, a scoped shutdown never selects them and scoped discovery opens duplicates beside them, so
+    the launch profile's own calls close them first and its scope reconnects them from the current config."""
+    from agent.secret_scope import is_multiplex_active
+    from hermes_constants import get_hermes_home
+    from tools.mcp_tool import _lock, _servers
+    from tools.mcp_tool_lifecycle import shutdown_mcp_servers
+    from tools.mcp_tool_scope import _key_name, _key_scope
+
+    if not is_multiplex_active() or _is_named_profile(get_hermes_home()):
+        return set()
+    with _lock:
+        names = {_key_name(key) for key in _servers if _key_scope(key) is None}
+    if names:
+        shutdown_mcp_servers(scope=None, names=names)
+    return names
+
+
 def _reload_mcp() -> str:
     with _RELOAD_MCP_LOCK:
         try:
-            from tools.mcp_tool import _lock, _servers, discover_mcp_tools, shutdown_mcp_servers
+            from agent.secret_scope import is_multiplex_active
+            from tools.mcp_tool import _lock, _mcp_tool_server_names, _server_visible_in_scope, _servers
+            from tools.mcp_tool_discovery import discover_mcp_tools
+            from tools.mcp_tool_lifecycle import shutdown_mcp_servers
+            from tools.mcp_tool_scope import _key_name
+            from tools.registry import registry
         except Exception as exc:  # noqa: BLE001
             raise RpcError("MCP runtime unavailable", condition="mcp_unavailable") from exc
-        try:
-            with _lock:
-                old = set(_servers.keys())
-            shutdown_mcp_servers()
-            tools = discover_mcp_tools()
+        # Like the gateway's ``_execute_mcp_reload``: under multiplexing only this profile's connections go down and
+        # come back. The bare shutdown is the process-wide wildcard, which would drop every other profile's servers.
+        scope = registry.current_scope_key() if is_multiplex_active() else None
+
+        def server_names() -> set[str]:
             with _lock:
-                connected = set(_servers.keys())
+                return {_key_name(key) for key in _servers if _server_visible_in_scope(key, scope)}
+
+        try:
+            old = server_names() | retire_unscoped_launch_mcp_servers()
+            shutdown_mcp_servers(scope=scope)
+            tools = discover_mcp_tools() or []
+            connected = server_names()
+            if scope is not None:
+                with _lock:
+                    tools = [name for name in tools if _mcp_tool_server_names.get(name) in connected]
         except Exception as exc:  # noqa: BLE001
             log.warning("Failed to reload MCP servers", exc_info=True)
             raise RpcError("Failed to reload MCP servers", condition="mcp_reload_failed") from exc
@@ -84,7 +133,7 @@ def _reload_mcp() -> str:
         lines.append(f"Added: {', '.join(sorted(added))}")
     if removed:
         lines.append(f"Removed: {', '.join(sorted(removed))}")
-    lines.append(f"{len(tools or [])} tool(s) available across {len(connected)} server(s)" if connected else "No MCP servers connected")
+    lines.append(f"{len(tools)} tool(s) available across {len(connected)} server(s)" if connected else "No MCP servers connected")
     if not reconnected and not added and not removed:
         lines.append("Tooling state was already current")
     return "\n".join(lines)
@@ -230,27 +279,6 @@ def resolve_moa_config(preset: str | None) -> dict:
     return resolved
 
 
-def plugin_provider_profiles() -> list[dict]:
-    """Model-provider plugins registered with the Agent's provider registry."""
-    try:
-        from providers import list_providers
-    except Exception:  # noqa: BLE001
-        return []
-    out = []
-    try:
-        for profile in list_providers():
-            name = str(getattr(profile, "name", "") or "").strip().lower()
-            if not name:
-                continue
-            env_vars = [str(v) for v in (getattr(profile, "env_vars", ()) or ())]
-            api_key_env = next((v for v in env_vars if not v.upper().endswith(("_BASE_URL", "_URL", "_FOLDER_ID"))), None)
-            out.append({"name": name, "display_name": str(getattr(profile, "display_name", "") or name).strip(), "env_vars": env_vars, "api_key_env": api_key_env})
-    except Exception:  # noqa: BLE001
-        log.debug("Failed to enumerate model-provider plugins", exc_info=True)
-        return []
-    return out
-
-
 PLUGIN_VISIBILITY_HOOKS = ("pre_tool_call", "post_tool_call", "pre_llm_call", "post_llm_call")
 
 
@@ -332,7 +360,7 @@ def register(registry) -> None:
     @registry.method("plugins.providers")
     def providers(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):
-            return {"providers": plugin_provider_profiles()}
+            return {"providers": plugin_providers()}
 
     @registry.method("plugins.list")
     def list_(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/config.py

@@ -2,12 +2,13 @@
 Agent's per-model reasoning capability.
 
 The TypeScript server owns every config.yaml *policy* (which keys mean what);
-the sidecar only parses and serialises YAML with the Agent's PyYAML so the Node
-side needs no YAML dependency. Writes are atomic and keep the file's mode.
+the sidecar only parses and serialises YAML with the Agent's own parser so the
+Node side needs no YAML dependency. Writes are atomic and keep the file's mode.
 """
 
 from __future__ import annotations
 
+import importlib
 import logging
 import os
 import tempfile
@@ -20,12 +21,15 @@ from ..rpc import CallContext
 log = logging.getLogger("talaria_sidecar.config")
 
 
-def _yaml():
-    try:
-        import yaml
-    except Exception as exc:  # noqa: BLE001
-        raise RpcError(f"PyYAML unavailable: {exc}", condition="yaml_unavailable") from exc
-    return yaml
+def yaml_parser():
+    """The Agent's YAML module: ``hermes_yaml`` on Agents that ship it, PyYAML on released Agents."""
+    failures = []
+    for name in ("hermes_yaml", "yaml"):
+        try:
+            return importlib.import_module(name)
+        except Exception as exc:  # noqa: BLE001
+            failures.append(f"{name}: {exc}")
+    raise RpcError(f"No YAML parser available ({'; '.join(failures)})", condition="yaml_unavailable")
 
 
 def config_path_param(params: dict) -> Path:
@@ -45,7 +49,7 @@ def read_config(path: Path) -> dict:
     if not path.exists():
         return {"path": str(path), "exists": False, "config": {}}
     try:
-        data = _yaml().safe_load(path.read_text(encoding="utf-8"))
+        data = yaml_parser().safe_load(path.read_text(encoding="utf-8"))
     except RpcError:
         raise
     except Exception as exc:  # noqa: BLE001
@@ -70,7 +74,7 @@ def write_config(path: Path, config: dict) -> dict:
         raise InvalidParams("config must be an object")
     target = _write_target(path)
     target.parent.mkdir(parents=True, exist_ok=True)
-    text = _yaml().safe_dump(config, sort_keys=False, allow_unicode=True)
+    text = yaml_parser().safe_dump(config, sort_keys=False, allow_unicode=True)
     mode = None
     try:
         mode = target.stat().st_mode & 0o777

package/sidecar/talaria_sidecar/methods/cron.py

@@ -252,14 +252,18 @@ def _run_in_child(job, execution_home, ctx: CallContext):
                     process.join(timeout=5)
                     status, payload = "cancelled", ["cancelled", ""]
                     break
-                if time.monotonic() >= deadline:
-                    if process.is_alive():
-                        process.terminate()
-                        process.join(timeout=5)
-                        payload = [f"cron run subprocess produced no result within {_result_timeout(job):g}s and was terminated", ""]
-                    else:
+                if not process.is_alive():
+                    # The child may have put its result just before exiting; otherwise it died (OOM, signal) without one.
+                    try:
+                        status, *payload = result_queue.get_nowait()
+                    except queue.Empty:
                         payload = [f"cron run subprocess exited with code {process.exitcode} without producing a result", ""]
                     break
+                if time.monotonic() >= deadline:
+                    process.terminate()
+                    process.join(timeout=5)
+                    payload = [f"cron run subprocess produced no result within {_result_timeout(job):g}s and was terminated", ""]
+                    break
         process.join(timeout=5)
         if process.is_alive():
             process.terminate()

package/sidecar/talaria_sidecar/methods/kanban.py

@@ -8,6 +8,7 @@ server; the sidecar receives typed params.
 from __future__ import annotations
 
 import json
+import secrets
 import time
 from dataclasses import asdict, is_dataclass
 from typing import Any
@@ -82,10 +83,102 @@ def _obj_dict(value):
     return dict(getattr(value, "__dict__", {}))
 
 
-def _task_dict(task):
+LIVE_CLAIM_MESSAGE = "task has a live worker; archive it to stop the worker"
+
+
+def _row_claim_live(row) -> bool:
+    """The Agent's ``_claim_is_live`` for a ``tasks`` row: a running task's worker process still holds its claim.
+
+    Releasing that claim (block, a direct status change) leaves the worker running, so the card
+    policy withholds those writes and the write paths refuse them (TAL-557). Unknown liveness counts as live.
+    """
+    if row is None or row["status"] != "running":
+        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")}
+    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"])
+
+
+def _claim_live(conn, task_id) -> bool:
+    return _row_claim_live(conn.execute("SELECT * FROM tasks WHERE id = ?", (task_id,)).fetchone())
+
+
+RUNNING_EXIT_MESSAGE = "task is running; confirm leaving Running"
+
+
+def _guard_running_exit(row, confirm_running_exit: bool) -> None:
+    """A write that takes a task out of Running needs the client's explicit confirmation, judged on the row the
+    write sees: a client's card policy can predate a dispatcher claim (TAL-557)."""
+    if row["status"] == "running" and not confirm_running_exit:
+        raise Conflict(RUNNING_EXIT_MESSAGE)
+
+
+FENCE_PREFIX = "talaria-fence:"
+FENCE_SECONDS = 60
+
+
+def _clear_stale_fences(conn) -> None:
+    """Release fences whose write never finished (the sidecar died mid-write), so the dispatcher can claim again."""
+    now = int(time.time())
+    stale = []
+    for row in conn.execute("SELECT id, claim_lock FROM tasks WHERE claim_lock LIKE ?", (FENCE_PREFIX + "%",)).fetchall():
+        try:
+            expires = int(str(row["claim_lock"])[len(FENCE_PREFIX):].split(":", 1)[0])
+        except ValueError:
+            expires = 0
+        if expires < now:
+            stale.append((row["id"], row["claim_lock"]))
+    if not stale:
+        return
+    kb = _kb()
+    with kb.write_txn(conn):
+        for task_id, fence in stale:
+            conn.execute("UPDATE tasks SET claim_lock = NULL WHERE id = ? AND claim_lock = ?", (task_id, fence))
+
+
+def _fenced(conn, task_id: str, write, *, confirm_running_exit: bool, releases_claim: bool = True):
+    """Run an Agent transition (block, complete, archive) with the dispatcher fenced out.
+
+    The Agent's helpers open their own write transaction, which cannot nest, so the checks and a fence lock share
+    one transaction first: ``claim_task`` claims only a ``ready`` task with ``claim_lock IS NULL``, so the card cannot
+    become a live run before the helper runs. ``releases_claim`` writes (block, complete) refuse a live worker's claim;
+    archive keeps it, because ``archive_task`` terminates that worker. The fence expires, so a write the sidecar never
+    finished stops holding the card once ``_clear_stale_fences`` next runs.
+    """
+    kb = _kb()
+    _clear_stale_fences(conn)
+    fence = f"{FENCE_PREFIX}{int(time.time()) + FENCE_SECONDS}:{secrets.token_hex(8)}"
+    with kb.write_txn(conn):
+        row = conn.execute("SELECT * FROM tasks WHERE id = ?", (task_id,)).fetchone()
+        if row is None:
+            raise NotFound("task not found")
+        _guard_running_exit(row, confirm_running_exit)
+        live = _row_claim_live(row)
+        if live and releases_claim:
+            raise Conflict(LIVE_CLAIM_MESSAGE)
+        # Only an unclaimed ready task is claimable; anything else needs no fence.
+        fenced = row["status"] == "ready" and row["claim_lock"] is None
+        if fenced:
+            conn.execute("UPDATE tasks SET claim_lock = ? WHERE id = ?", (fence, task_id))
+    try:
+        return write()
+    finally:
+        if fenced:
+            with kb.write_txn(conn):
+                conn.execute("UPDATE tasks SET claim_lock = NULL WHERE id = ? AND claim_lock = ?", (task_id, fence))
+
+
+def _task_dict(task, conn):
     data = _obj_dict(task)
     if not data:
         return data
+    # Facts the server's card policy needs (TAL-557): the Agent completes a non-review task only with
+    # stored or supplied evidence, and refuses to release a live worker's claim.
+    data["claim_live"] = data.get("status") == "running" and _claim_live(conn, data.get("id"))
+    data["has_completion_evidence"] = bool(str(data.get("result") or "").strip())
     try:
         age = _kb().task_age(task)
     except Exception:  # noqa: BLE001
@@ -131,12 +224,16 @@ def _validate_status(status: str) -> str:
     return value
 
 
-def _set_status_direct(conn, task_id: str, new_status: str) -> bool:
+def _set_status_direct(conn, task_id: str, new_status: str, *, confirm_running_exit: bool = False) -> bool:
     kb = _kb()
     with kb.write_txn(conn):
-        prev = conn.execute("SELECT status, current_run_id FROM tasks WHERE id = ?", (task_id,)).fetchone()
+        prev = conn.execute("SELECT * FROM tasks WHERE id = ?", (task_id,)).fetchone()
         if prev is None:
             return False
+        # Checked inside the write transaction, so a claim taken since the client's read is never released.
+        _guard_running_exit(prev, confirm_running_exit)
+        if _row_claim_live(prev):
+            raise Conflict(LIVE_CLAIM_MESSAGE)
         was_running = prev["status"] == "running"
         cur = conn.execute(
             "UPDATE tasks SET status = ?, "
@@ -202,14 +299,15 @@ def _patch_task(conn, task_id: str, body: dict) -> None:
     if "status" not in body or body.get("status") in (None, ""):
         return
     status = _validate_status(body.get("status"))
+    confirm = bool(body.get("confirm_running_exit"))
     if status == "done":
-        if not kb.complete_task(conn, task_id, result=body.get("result"), summary=body.get("summary")):
+        if not _fenced(conn, task_id, lambda: kb.complete_task(conn, task_id, result=body.get("result"), summary=body.get("summary")), confirm_running_exit=confirm):
             raise NotFound("task not found")
     elif status == "blocked":
-        if not kb.block_task(conn, task_id, reason=body.get("block_reason") or body.get("reason")):
+        if not _fenced(conn, task_id, lambda: kb.block_task(conn, task_id, reason=body.get("block_reason") or body.get("reason")), confirm_running_exit=confirm):
             raise NotFound("task not found")
     elif status == "archived":
-        if not kb.archive_task(conn, task_id):
+        if not _fenced(conn, task_id, lambda: kb.archive_task(conn, task_id), confirm_running_exit=confirm, releases_claim=False):
             raise NotFound("task not found")
     elif status == "running":
         raise InvalidParams("Cannot set status to 'running' directly; use the dispatcher/claim path")
@@ -220,10 +318,10 @@ def _patch_task(conn, task_id: str, body: dict) -> None:
         if current.status == "blocked":
             if not kb.unblock_task(conn, task_id):
                 raise NotFound("task not found")
-        elif not _set_status_direct(conn, task_id, "ready"):
+        elif not _set_status_direct(conn, task_id, "ready", confirm_running_exit=confirm):
             raise NotFound("task not found")
     elif status in ("triage", "todo"):
-        if not _set_status_direct(conn, task_id, status):
+        if not _set_status_direct(conn, task_id, status, confirm_running_exit=confirm):
             raise NotFound("task not found")
 
 
@@ -320,6 +418,7 @@ def board_payload(params: dict) -> dict:
         profile = _str(params, "profile") or "default"
         assignee = profile
     with _conn(board=board) as conn:
+        _clear_stale_fences(conn)
         latest = _latest_event_id(conn)
         if since is not None and since >= latest:
             return {"changed": False, "latest_event_id": latest, "read_only": False}
@@ -327,7 +426,7 @@ def board_payload(params: dict) -> dict:
         link_counts, comment_counts = _link_counts(conn, tasks), _comment_counts(conn)
 
         def row(task):
-            data = _task_dict(task)
+            data = _task_dict(task, conn)
             data["link_counts"] = link_counts.get(task.id, {"parents": 0, "children": 0})
             data["comment_count"] = comment_counts.get(task.id, 0)
             return data
@@ -365,7 +464,7 @@ def create_task_payload(params: dict) -> dict:
         )
         if body.get("status"):
             _patch_task(conn, task_id, {"status": body.get("status")})
-        return {"task": _task_dict(kb.get_task(conn, task_id)), "read_only": False}
+        return {"task": _task_dict(kb.get_task(conn, task_id), conn), "read_only": False}
 
 
 def patch_task_payload(params: dict) -> dict:
@@ -375,7 +474,7 @@ def patch_task_payload(params: dict) -> dict:
     kb = _kb()
     with _conn(board=_board(params)) as conn:
         _patch_task(conn, task_id, params.get("patch") or {})
-        return {"task": _task_dict(kb.get_task(conn, task_id)), "read_only": False}
+        return {"task": _task_dict(kb.get_task(conn, task_id), conn), "read_only": False}
 
 
 def comment_payload(params: dict) -> dict:
@@ -418,7 +517,7 @@ def task_detail_payload(params: dict) -> dict:
         if not task:
             raise NotFound("task not found")
         return {
-            "task": _task_dict(task),
+            "task": _task_dict(task, conn),
             "comments": [_obj_dict(c) for c in kb.list_comments(conn, task_id)],
             "events": [_obj_dict(e) for e in kb.list_events(conn, task_id)],
             "links": {"parents": kb.parent_ids(conn, task_id), "children": kb.child_ids(conn, task_id)},
@@ -533,7 +632,8 @@ def bulk_payload(params: dict) -> dict:
                     results.append(entry)
                     continue
                 if body.get("archive"):
-                    if not kb.archive_task(conn, task_id):
+                    # Bulk carries no running-exit confirmation, so a running row is refused like a card write.
+                    if not _fenced(conn, task_id, lambda: kb.archive_task(conn, task_id), confirm_running_exit=False, releases_claim=False):
                         entry.update(ok=False, error="archive refused")
                 elif body.get("status") is not None:
                     _patch_task(conn, task_id, {"status": body.get("status")})
@@ -578,7 +678,7 @@ def task_action_payload(params: dict) -> dict:
         if not kb.get_task(conn, task_id):
             raise NotFound("task not found")
         if action == "block":
-            ok = kb.block_task(conn, task_id, reason=params.get("reason"))
+            ok = _fenced(conn, task_id, lambda: kb.block_task(conn, task_id, reason=params.get("reason")), confirm_running_exit=bool(params.get("confirm_running_exit")))
         elif action == "unblock":
             if hasattr(kb, "unblock_task"):
                 ok = kb.unblock_task(conn, task_id)
@@ -589,7 +689,7 @@ def task_action_payload(params: dict) -> dict:
             raise InvalidParams(f"invalid action: {action}")
         if not ok:
             raise Conflict(f"{action} refused")
-        return {"task": _task_dict(kb.get_task(conn, task_id)), "read_only": False}
+        return {"task": _task_dict(kb.get_task(conn, task_id), conn), "read_only": False}
 
 
 def list_boards_payload(params: dict) -> dict: