@maudecode/talaria-web 1.16.1 → 1.17.2

package/sidecar/talaria_sidecar/methods/commands.py

@@ -15,7 +15,14 @@ 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()
@@ -46,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
 
@@ -55,7 +68,7 @@ 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

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:

package/sidecar/talaria_sidecar/methods/process.py

@@ -12,7 +12,7 @@ import time
 from contextlib import closing
 from pathlib import Path
 
-from ..errors import InvalidParams
+from ..errors import InvalidParams, RpcError
 from ..home import profile_home_param, scoped_home
 from ..rpc import CallContext
 
@@ -54,6 +54,14 @@ def drain(max_events: int) -> list[dict]:
     completion_queue = getattr(registry, "completion_queue", None) if registry is not None else None
     if completion_queue is None:
         return []
+    try:
+        # A recovered process has no reader thread; only this probe notices its exit and queues its completion (TAL-533).
+        with registry._lock:
+            detached = [s for s in registry._running.values() if getattr(s, "detached", False)]
+        for session in detached:
+            registry._refresh_detached_session(session)
+    except Exception:  # noqa: BLE001
+        log.debug("Failed to reconcile recovered processes", exc_info=True)
     out = []
     while len(out) < max_events:
         try:
@@ -94,6 +102,22 @@ def mark_consumed(process_id: str) -> bool:
         return False
 
 
+def consumed_ids(process_ids: list[str]) -> list[str]:
+    """The processes the agent already holds from its own turn: consumed via wait/log, or observed exiting via poll.
+    Checked at wakeup delivery, since the completion is usually drained before the agent's wait returns (TAL-532)."""
+    registry = _registry()
+    if registry is None:
+        return []
+    out = []
+    for process_id in process_ids:
+        try:
+            if registry.is_completion_consumed(process_id) or process_id in (getattr(registry, "_poll_observed", None) or ()):
+                out.append(process_id)
+        except Exception:  # noqa: BLE001
+            log.debug("Completion consumed check failed for %r", process_id, exc_info=True)
+    return out
+
+
 def _delivery_api():
     """The Agent's durable delivery ledger (``tools.async_delegation``), or None on an Agent without it."""
     try:
@@ -387,12 +411,40 @@ def delegation_result(home: Path, session_id: str, delegation_id: str) -> str:
     return format_notification(event) if event else ""
 
 
+def recover(base_home: Path) -> int:
+    """TAL-533: re-adopt every profile's checkpointed processes when a sidecar starts, so a process in a profile nobody
+    uses yet is watched (and its exit reported) from the start. Entering a home's scope recovers it once; a failed
+    recovery fails the call, so the server retries."""
+    from hermes_cli.profiles import _PROFILE_ID_RE
+
+    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 []
+    failed = []
+    for home in [base_home, *named]:
+        try:
+            with scoped_home(home):
+                pass
+        except RpcError as exc:
+            if exc.data.get("condition") != "agent_incompatible":
+                failed.append(str(exc))
+                continue
+            # An Agent without profile isolation refuses named profiles for good; their processes stay unadopted.
+            log.warning("Background process recovery skipped for %s", home, exc_info=True)
+    if failed:
+        raise RpcError("; ".join(failed))
+    return 1 + len(named)
+
+
 def register(registry_) -> None:
     @registry_.method("process.drain")
     def drain_(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):
             return {"events": drain(int(params.get("max_events") or 256))}
 
+    @registry_.method("process.recover")
+    def recover_(ctx: CallContext, params: dict) -> dict:
+        return {"homes": recover(profile_home_param(params, "base_home"))}
+
     @registry_.method("process.requeue")
     def requeue_(ctx: CallContext, params: dict) -> dict:
         events = params.get("events")
@@ -407,6 +459,13 @@ def register(registry_) -> None:
             raise InvalidParams("process_id is required")
         return {"ok": mark_consumed(process_id)}
 
+    @registry_.method("process.consumed")
+    def consumed_(ctx: CallContext, params: dict) -> dict:
+        ids = params.get("process_ids")
+        if not isinstance(ids, list) or not all(isinstance(i, str) and i for i in ids):
+            raise InvalidParams("process_ids must be a list of process ids")
+        return {"consumed": consumed_ids(ids)}
+
     def _delivery_params(params: dict) -> dict:
         evt = params.get("event")
         if not isinstance(evt, dict):

package/sidecar/talaria_sidecar/methods/profiles.py

@@ -241,7 +241,13 @@ def register(registry) -> None:
 
     @registry.method("profiles.delete")
     def delete(ctx: CallContext, params: dict) -> dict:
-        delete_profile(profile_home_param(params, "base_home"), str(params.get("name") or "").strip())
+        base_home, name = profile_home_param(params, "base_home"), str(params.get("name") or "").strip()
+        validate_name(name)
+        # Idle cached agents end their memory sessions while the profile's home still exists.
+        from .chat import release_profile_agents
+
+        release_profile_agents(base_home / "profiles" / name)
+        delete_profile(base_home, name)
         return {"ok": True}
 
     @registry.method("profiles.runtime_env")

package/sidecar/talaria_sidecar/methods/runtime.py

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

package/sidecar/talaria_sidecar/methods/text.py

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