@maudecode/talaria-web 1.17.2 → 1.19.0

package/sidecar/talaria_sidecar/methods/kanban.py

@@ -7,17 +7,20 @@ server; the sidecar receives typed params.
 
 from __future__ import annotations
 
+import functools
 import json
 import secrets
 import time
 from dataclasses import asdict, is_dataclass
-from typing import Any
+from typing import Any, NamedTuple
 
 from ..errors import InvalidParams, RpcError
 from ..home import profile_home_param, scoped_home
 from ..rpc import CallContext
 
-BOARD_COLUMNS = ["triage", "todo", "ready", "running", "blocked", "done"]
+# Agent 2026.9.24 predates ``kanban_workflow``; its ``VALID_STATUSES`` set holds these columns, in this board order.
+# Delete with that release's entry in ``agent_support.json``.
+_LEGACY_COLUMNS = ("triage", "todo", "scheduled", "ready", "running", "blocked", "review", "done")
 
 
 class NotFound(RpcError):
@@ -38,6 +41,27 @@ def _kb():
     return kb
 
 
+class _Workflow(NamedTuple):
+    columns: tuple[tuple[str, str], ...]  # (key, label) in board order
+    manual: dict | None  # src -> [dst]; None on an Agent without a move table
+
+
+@functools.cache
+def _workflow() -> _Workflow:
+    """The Agent's board columns and manual move table from ``kanban_workflow.DEFAULT_WORKFLOW`` (Agent 0.21.6+, TAL-796)."""
+    try:
+        from hermes_cli.kanban_workflow import DEFAULT_WORKFLOW
+    except ImportError:
+        statuses = getattr(_kb(), "VALID_STATUSES", _LEGACY_COLUMNS)
+        return _Workflow(tuple((key, key.title()) for key in _LEGACY_COLUMNS if key in statuses), None)
+    workflow = DEFAULT_WORKFLOW.to_dict()
+    return _Workflow(tuple((c["key"], c["label"]) for c in workflow["columns"]), workflow["manual"])
+
+
+def _columns() -> list[str]:
+    return [key for key, _ in _workflow().columns]
+
+
 def _board(params: dict):
     raw = params.get("board")
     if raw is None or (isinstance(raw, str) and raw.strip() == ""):
@@ -49,9 +73,16 @@ def _board(params: dict):
         raise InvalidParams(f"invalid board slug: {raw!r}") from exc
     if not normed:
         return None
-    default_slug = getattr(kb, "DEFAULT_BOARD", "default")
-    if normed != default_slug and not kb.board_exists(normed):
-        raise NotFound(f"board {normed!r} does not exist")
+    if normed == getattr(kb, "DEFAULT_BOARD", "default"):
+        return normed
+    return _live_board(kb, normed, normed)
+
+
+def _live_board(kb, normed: str, shown, *, archived_ok: bool = False) -> str:
+    """``normed`` when it names a live board. Agent 0.21.6 leaves an ``archived`` ``board.json`` tombstone at an
+    archived board's slug, so ``board_exists`` alone would let a stale link reach it (TAL-795)."""
+    if not kb.board_exists(normed) or (not archived_ok and kb.read_board_metadata(normed).get("archived")):
+        raise NotFound(f"board {shown!r} does not exist")
     return normed
 
 
@@ -96,10 +127,28 @@ def _row_claim_live(row) -> bool:
         return False
     columns = row.keys()
     claim = {k: row[k] if k in columns else None for k in ("status", "claim_lock", "worker_pid", "worker_started_at")}
+    claimed = bool(claim["claim_lock"] and claim["worker_pid"])
     try:
-        return bool(_kb()._claim_is_live(claim))
-    except Exception:  # noqa: BLE001 - an older Agent without the helper
-        return bool(claim["claim_lock"] and claim["worker_pid"])
+        helper = getattr(_kb(), "_claim_is_live", None)
+    except RpcError:
+        return claimed
+    if helper is not None:
+        try:
+            return bool(helper(claim))
+        except Exception:  # noqa: BLE001 - the Agent could not decide: unknown liveness counts as live
+            return claimed
+    if not claimed:
+        return False
+    try:
+        # Agent 0.21.3 has no _claim_is_live, but its dispatcher's own worker PID check. Like its crash sweep, probe
+        # only a claim this host issued: another host's PID means nothing here, so a remote claim stays live.
+        from hermes_cli.kanban_db_dispatch import _pid_alive
+
+        if not str(claim["claim_lock"]).startswith(_kb()._host_prefix()):
+            return True
+        return bool(_pid_alive(int(claim["worker_pid"])))
+    except Exception:  # noqa: BLE001
+        return True
 
 
 def _claim_live(conn, task_id) -> bool:
@@ -179,6 +228,8 @@ def _task_dict(task, conn):
     # 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())
+    manual = _workflow().manual
+    data["agent_move_targets"] = None if manual is None else list(manual.get(data.get("status"), []))
     try:
         age = _kb().task_age(task)
     except Exception:  # noqa: BLE001
@@ -219,8 +270,13 @@ def _comment_counts(conn):
 
 def _validate_status(status: str) -> str:
     value = str(status or "").strip().lower()
-    if value not in set(BOARD_COLUMNS) | {"archived"}:
+    if value not in {*_columns(), "archived"}:
         raise InvalidParams(f"invalid status: {value}")
+    if value == "running":
+        raise InvalidParams("Cannot set status to 'running' directly; use the dispatcher/claim path")
+    if value in ("scheduled", "review"):
+        # The Agent reaches these through verbs with extra input (a wake time, a reviewer), which Talaria does not offer.
+        raise InvalidParams(f"Cannot set status to {value!r} directly")
     return value
 
 
@@ -309,19 +365,21 @@ def _patch_task(conn, task_id: str, body: dict) -> None:
     elif status == "archived":
         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")
-    elif status == "ready":
+    else:
         current = kb.get_task(conn, task_id)
         if not current:
             raise NotFound("task not found")
-        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", confirm_running_exit=confirm):
-            raise NotFound("task not found")
-    elif status in ("triage", "todo"):
-        if not _set_status_direct(conn, task_id, status, confirm_running_exit=confirm):
+        # Like the Agent's dashboard: leaving review reopens it, and blocked/scheduled -> ready unblocks; both re-gate on
+        # parents. Triage is a direct write there too. The reopen lands in ready whatever the target, so todo is refused.
+        if current.status == "review" and status == "todo":
+            raise Conflict("A task in review reopens to ready")
+        if current.status == "review" and status == "ready":
+            ok = kb.reopen_review_task(conn, task_id)
+        elif status == "ready" and current.status in ("blocked", "scheduled"):
+            ok = kb.unblock_task(conn, task_id)
+        else:
+            ok = _set_status_direct(conn, task_id, status, confirm_running_exit=confirm)
+        if not ok:
             raise NotFound("task not found")
 
 
@@ -355,15 +413,15 @@ def _board_counts(slug):
             pass
 
 
-def _normalize_existing_slug(slug) -> str:
+def _normalize_existing_slug(slug, *, archived_ok: bool = False) -> str:
     kb = _kb()
     try:
         normed = kb._normalize_board_slug(slug)
     except (ValueError, AttributeError) as exc:
         raise InvalidParams(f"invalid board slug: {slug!r}") from exc
-    if not normed or not kb.board_exists(normed):
+    if not normed:
         raise NotFound(f"board {slug!r} does not exist")
-    return normed
+    return _live_board(kb, normed, slug, archived_ok=archived_ok)
 
 
 def _current_board() -> str:
@@ -431,9 +489,9 @@ def board_payload(params: dict) -> dict:
             data["comment_count"] = comment_counts.get(task.id, 0)
             return data
 
-        columns = [{"name": name, "tasks": [row(t) for t in tasks if t.status == name]} for name in BOARD_COLUMNS]
+        columns = [{"name": key, "label": label, "tasks": [row(t) for t in tasks if t.status == key]} for key, label in _workflow().columns]
         if include_archived:
-            columns.append({"name": "archived", "tasks": [row(t) for t in tasks if t.status == "archived"]})
+            columns.append({"name": "archived", "label": "Archived", "tasks": [row(t) for t in tasks if t.status == "archived"]})
         return {
             "columns": columns,
             "tenants": sorted({t.tenant for t in tasks if getattr(t, "tenant", None)}),
@@ -454,6 +512,8 @@ def create_task_payload(params: dict) -> dict:
         priority = int(body.get("priority") or 0)
     except (TypeError, ValueError):
         raise InvalidParams("priority must be an integer")
+    # Checked before the insert, so a refused status leaves no task behind.
+    status = _validate_status(body.get("status")) if body.get("status") else None
     kb = _kb()
     with _conn(board=_board(params)) as conn:
         task_id = kb.create_task(
@@ -462,8 +522,8 @@ def create_task_payload(params: dict) -> dict:
             workspace_kind=body.get("workspace_kind") or "scratch", workspace_path=body.get("workspace_path") or None,
             idempotency_key=body.get("idempotency_key") or None, max_runtime_seconds=body.get("max_runtime_seconds") or None, skills=body.get("skills") or None,
         )
-        if body.get("status"):
-            _patch_task(conn, task_id, {"status": body.get("status")})
+        if status:
+            _patch_task(conn, task_id, {"status": status})
         return {"task": _task_dict(kb.get_task(conn, task_id), conn), "read_only": False}
 
 
@@ -516,11 +576,17 @@ def task_detail_payload(params: dict) -> dict:
         task = kb.get_task(conn, task_id)
         if not task:
             raise NotFound("task not found")
+        data = _task_dict(task, conn)
+        # ``started_at`` is the first-ever start; a retried task's run clock counts from its current run (TAL-809).
+        data["current_run_started_at"] = kb.current_run_started_ats(conn, [task_id]).get(task_id)
+        links = {"parents": kb.parent_ids(conn, task_id), "children": kb.child_ids(conn, task_id)}
+        linked = (kb.get_task(conn, link_id) for link_id in dict.fromkeys([*links["parents"], *links["children"]]))
         return {
-            "task": _task_dict(task, conn),
+            "task": data,
             "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)},
+            "links": links,
+            "link_tasks": [{"id": t.id, "title": t.title, "status": t.status} for t in linked if t],
             "runs": [_obj_dict(r) for r in kb.list_runs(conn, task_id)],
             "read_only": False,
         }
@@ -565,13 +631,17 @@ def config_payload(params: dict) -> dict:
         cfg = {}
     k = ((cfg.get("dashboard") or {}).get("kanban") or {})
     return {
-        "columns": BOARD_COLUMNS, "assignees": assignees, "default_tenant": k.get("default_tenant") or "",
+        "columns": _columns(), "assignees": assignees, "default_tenant": k.get("default_tenant") or "",
         "lane_by_profile": bool(k.get("lane_by_profile", True)), "include_archived_by_default": bool(k.get("include_archived_by_default", False)),
         "render_markdown": bool(k.get("render_markdown", True)), "read_only": False,
     }
 
 
 def stats_payload(params: dict) -> dict:
+    return {**_stats(params), "column_order": _columns()}
+
+
+def _stats(params: dict) -> dict:
     kb = _kb()
     with _conn(board=_board(params)) as conn:
         if hasattr(kb, "board_stats"):
@@ -655,11 +725,14 @@ def bulk_payload(params: dict) -> dict:
 
 
 def dispatch_payload(params: dict) -> dict:
-    kb = _kb()
-    if not hasattr(kb, "dispatch_once"):
-        raise InvalidParams("dispatcher is unavailable")
+    _kb()
+    try:
+        # Agent 0.21.6 dropped the kanban_db re-export; every supported release defines it here.
+        from hermes_cli.kanban_db_dispatch import dispatch_once
+    except Exception as exc:  # noqa: BLE001
+        raise InvalidParams("dispatcher is unavailable") from exc
     with _conn(board=_board(params)) as conn:
-        result = kb.dispatch_once(conn, dry_run=_bool(params, "dry_run"), max_spawn=_int(params, "max", 8, minimum=1, maximum=100))
+        result = dispatch_once(conn, dry_run=_bool(params, "dry_run"), max_spawn=_int(params, "max", 8, minimum=1, maximum=100))
     if isinstance(result, dict):
         return result
     try:
@@ -740,7 +813,8 @@ def create_board_payload(params: dict) -> dict:
 def update_board_payload(params: dict) -> dict:
     kb = _kb()
     body = params.get("board_spec") or {}
-    normed = _normalize_existing_slug(params.get("slug"))
+    # Metadata edits stay open on an archived board: clearing ``archived`` is how one archived in place comes back.
+    normed = _normalize_existing_slug(params.get("slug"), archived_ok=True)
     kwargs = {}
     if "default_workdir" in body:
         kwargs["default_workdir"] = str(body.get("default_workdir") or "")

package/sidecar/talaria_sidecar/methods/mcp.py

@@ -17,7 +17,7 @@ log = logging.getLogger("talaria_sidecar.mcp")
 
 def status() -> list[dict]:
     try:
-        from tools.mcp_tool import get_mcp_status
+        from tools.mcp_tool_discovery import get_mcp_status
 
         statuses = get_mcp_status()
     except Exception:  # noqa: BLE001

package/sidecar/talaria_sidecar/methods/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: