@maudecode/talaria-web 1.20.0 → 1.22.0

package/sidecar/talaria_sidecar/methods/gateway_sessions.py

@@ -17,8 +17,9 @@ from ..errors import InvalidParams
 from ..home import profile_home_param, scoped_home
 
 _ACTIONS = {"snapshot", "watch", "context_detail", "submit", "receipt", "cancel", "steer_queued", "replace_queued", "interrupt", "approval", "clarify",
-            "clarify_lock", "discard", "mutate", "export"}
-_EXPORT_MAX_BYTES = 4 * 1024 * 1024
+            "clarify_lock", "discard", "mutate", "export", "checkpoint_diff", "terminal_info", "shell_exec", "react"}
+_OWNER_READ_MAX_BYTES = 4 * 1024 * 1024
+_REACTION_EMOJIS = {"👍", "👎", "❤️", "😂", "😮", "🎉"}
 # A restart's after-turn wait keeps the owner reachable only to finish its parked turn (the owner's
 # RESTART_WAIT_WS_METHODS); new work waits for the next owner.
 _RESTART_ACTIONS = {"snapshot", "watch", "receipt", "approval", "clarify", "clarify_lock", "interrupt"}
@@ -69,14 +70,40 @@ def _control_refusal(home: Path, sid: str) -> str | None:
     return None
 
 
+def _todo_state(value: object) -> dict | None:
+    if not isinstance(value, dict) or not isinstance(value.get("todos"), list):
+        return None
+    fields = {"id": (str, int, float), "text": (str,), "content": (str,), "title": (str,),
+              "status": (str,), "done": (bool,), "completed": (bool,)}
+    revision = value.get("revision", 0)
+    if type(revision) is not int or revision < 0:
+        return None
+    return {"todos": [{k: v for k, v in item.items() if k in fields and type(v) in fields[k]}
+                      for item in value["todos"] if isinstance(item, dict)], "revision": revision}
+
+
+def _event(value: dict) -> dict:
+    if value.get("type") == "todo.updated":
+        return {**value, "payload": _todo_state(value.get("payload")) or {}}
+    return value
+
+
 def _snapshot(value: dict) -> dict:
     # Raw conversation rows contain private principal/admission metadata; the client needs
     # display rows, not those bindings or the inventory's system prompt and credential hint.
     message_keys = {"role", "content", "tool_calls", "tool_call_id", "name", "timestamp", "message_id", "row_id",
                     "reasoning", "reasoning_content", "display_kind", "finish_reason"}
     info_keys = {"title", "model", "cwd", "source", "provider", "config_warning"}
-    return {**value, "messages": [{k: v for k, v in row.items() if k in message_keys} for row in value["messages"]],
-            "info": {k: v for k, v in value["info"].items() if k in info_keys}}
+    rows = []
+    for row in value["messages"]:
+        metadata = row.get("display_metadata")
+        reactions = metadata.get("reactions", []) if isinstance(metadata, dict) else []
+        rows.append({**{k: v for k, v in row.items() if k in message_keys}, "reactions": [
+            {"author": reaction["author"], "emoji": reaction["emoji"]} for reaction in reactions
+            if isinstance(reaction, dict) and reaction.get("author") in ("user", "agent")
+            and isinstance(reaction.get("emoji"), str) and reaction["emoji"] in _REACTION_EMOJIS] if isinstance(reactions, list) else []})
+    return {**value, "messages": rows, "info": {k: v for k, v in value["info"].items() if k in info_keys},
+            **({"todo_state": _todo_state(value["todo_state"])} if "todo_state" in value else {})}
 
 
 def _refused(state: str, reason: str) -> dict:
@@ -84,7 +111,7 @@ def _refused(state: str, reason: str) -> dict:
 
 
 @asynccontextmanager
-async def _connect(home: Path, endpoint):
+async def _connect(home: Path, endpoint, *, subject: str | None = None):
     from hermes_constants import get_hermes_home
     from hermes_cli.gateway_client import GatewayClientError, connect_gateway
 
@@ -92,7 +119,7 @@ async def _connect(home: Path, endpoint):
     # override is mandatory so its bootstrap ticket cannot fall back to the launch profile.
     if Path(get_hermes_home()).resolve() != home:
         raise GatewayClientError("profile_mismatch")
-    async with connect_gateway(endpoint) as client:
+    async with connect_gateway(endpoint, **({"subject": subject} if subject is not None else {})) as client:
         websocket = client.websocket
         # GatewayClient queues server requests as events. Drain continuously, including
         # during an RPC, so unsupported sudo/secure inputs never wait for a Web renderer.
@@ -120,16 +147,20 @@ def _served(home: Path, endpoint, *, allow_verified: bool = False) -> bool:
         return False
     if not allow_verified:
         return True
+    return not _verified_contract(endpoint, "served-local-policy-v1")
+
+
+def _verified_contract(endpoint, name: str) -> bool:
     # The private control socket reports the owner's boot revision, not the sidecar's
     # checkout or a version label. The authenticated describe must still match below.
     try:
         record = json.loads((Path(__file__).resolve().parents[2] / "agent_support.json").read_text())
-        revisions = record["nativeContracts"]["served-local-policy-v1"]
-        return (not isinstance(revisions, list)
-                or not all(isinstance(sha, str) and re.fullmatch(r"[0-9a-f]{40}", sha) for sha in revisions)
-                or getattr(endpoint, "code_sha", None) not in revisions)
+        revisions = record["nativeContracts"][name]
+        return (isinstance(revisions, list)
+                and all(isinstance(sha, str) and re.fullmatch(r"[0-9a-f]{40}", sha) for sha in revisions)
+                and getattr(endpoint, "code_sha", None) in revisions)
     except (OSError, ValueError, KeyError, TypeError):
-        return True
+        return False
 
 
 def _owner_refusal(described: dict, endpoint) -> dict | None:
@@ -145,12 +176,41 @@ def _owner_refusal(described: dict, endpoint) -> dict | None:
     return None
 
 
+def _checkpoint_read(value, *, no_baseline=False):
+    comparison = {"provenance": "native_owner", "baseline": "earliest_retained_project_checkpoint",
+                  "available": False, "reason": None, "truncated": False}
+    result = {"diff": "", "stat": "", "comparison": comparison}
+    reason = None
+    if not isinstance(value, dict) or type(value.get("enabled")) is not bool:
+        reason = "invalid_payload"
+    elif not value["enabled"]:
+        reason = "checkpoints_disabled"
+    elif value.get("success") is not True:
+        reason = "checkpoint_unavailable"
+    elif (not isinstance(value.get("diff"), str) or not isinstance(value.get("stat"), str)
+          or type(value.get("diff_lines")) is not int or value["diff_lines"] < 0
+          or type(value.get("empty")) is not bool):
+        reason = "invalid_payload"
+    elif sum(len(json.dumps(value[key], ensure_ascii=False).encode("utf-8", "surrogatepass")) - 2
+             for key in ("stat", "diff")) > _OWNER_READ_MAX_BYTES:
+        reason = "payload_too_large"
+    elif no_baseline:
+        reason = "no_baseline"
+    else:
+        result.update(diff=value["diff"], stat=value["stat"])
+        comparison.update(available=True, truncated=value["diff_lines"] > len(value["diff"].splitlines()))
+    comparison["reason"] = reason
+    return result
+
+
 async def _run(ctx, params: dict, home: Path, discovery) -> dict:
     from hermes_cli.gateway_client import GatewayRPCError
 
     endpoint = discovery.endpoint
     if _served(home, endpoint, allow_verified=True):
         return _refused("incompatible", "served_profile_sessions_unavailable")
+    if params["action"] in {"terminal_info", "shell_exec"} and not _verified_contract(endpoint, "captured-command-v1"):
+        return _refused("incompatible", "owner_shell_unsupported")
     restarting = discovery.state != "ready"
     if restarting and params["action"] not in _RESTART_ACTIONS:
         return _refused("refused", "gateway_restarting")
@@ -170,10 +230,32 @@ async def _run(ctx, params: dict, home: Path, discovery) -> dict:
             subscription = value["subscription_id"]
             if reason := await asyncio.to_thread(_control_refusal, home, sid):
                 raise GatewayRPCError(reason)
-            return _snapshot(value)
+            gauge = None
+            if params["action"] in {"snapshot", "watch"}:
+                try:
+                    stats = await client.rpc("session.stats", session_id=sid)
+                    after = await client.rpc("session.resume", session_id=sid)
+                    if all(value.get(k) == after.get(k) for k in ("session_id", "authority_epoch", "replay_epoch", "execution_generation")):
+                        gauge = stats.get("plan_gauge")
+                except GatewayRPCError:
+                    pass  # older owners have no stats capability
+            return {**_snapshot(value), "plan_gauge": gauge,
+                    "reactions_supported": _verified_contract(endpoint, "message-reactions-v1")}
 
         receipt = lock = None
         try:
+            if params["action"] == "checkpoint_diff":
+                # The owner resolves the physical target and frozen policy. Never resume or read host files.
+                value = await asyncio.wait_for(client.rpc("rollback.session_diff", session_id=sid, _timeout=25), timeout=30)
+                read = _checkpoint_read(value)
+                if read["comparison"]["available"] and value["empty"] and not value["diff"] and not value["stat"]:
+                    listed = await asyncio.wait_for(client.rpc("rollback.list", session_id=sid, _timeout=3), timeout=3)
+                    if (not isinstance(listed, dict) or listed.get("enabled") is not True
+                            or not isinstance(listed.get("checkpoints"), list)):
+                        read = _checkpoint_read(None)
+                    elif not listed["checkpoints"]:
+                        read = _checkpoint_read(value, no_baseline=True)
+                return {"state": "attached", "reason": None, "snapshot": None, "receipt": None, "checkpoint_diff": read}
             if params["action"] == "export":
                 # No resume/subscription or mutation: the owner selects its current physical target.
                 fmt = "md" if params["format"] == "markdown" else params["format"]
@@ -183,14 +265,34 @@ async def _run(ctx, params: dict, home: Path, discovery) -> dict:
                         or not isinstance(value.get("filename"), str) or not 0 < len(value["filename"]) <= 255
                         or not isinstance(value.get("content"), str)):
                     return _refused("refused", "owner_export_invalid")
-                if len(value["content"]) > _EXPORT_MAX_BYTES or len(value["content"].encode("utf-8")) > _EXPORT_MAX_BYTES:
+                if len(value["content"]) > _OWNER_READ_MAX_BYTES or len(value["content"].encode("utf-8")) > _OWNER_READ_MAX_BYTES:
                     return _refused("refused", "export_too_large")
                 return {"state": "attached", "reason": None, "snapshot": None, "receipt": None,
                         "export": {"format": params["format"], "filename": value["filename"], "content": value["content"]}}
             snap = await snapshot()
             action = params["action"]
             common = {"session_id": sid}
-            if action == "context_detail":
+            if action == "terminal_info":
+                return {"state": "attached", "reason": None, "snapshot": snap, "receipt": None}
+            if action == "shell_exec":
+                if (snap.get("session_id") != params["session_id"] or snap.get("authority_epoch") != params["authority_epoch"]
+                        or snap.get("replay_epoch") != params["replay_epoch"]):
+                    return _refused("refused", "owner_changed")
+                # The native owner alone authorizes the frozen backend/cwd and redacts before bounding.
+                # No second observation may discard a received result; no retry after an unknown ACK.
+                value = await client.rpc("shell.exec", **common, command=params["command"], _timeout=35)
+                if (not isinstance(value, dict) or not isinstance(value.get("stdout"), str)
+                        or not isinstance(value.get("stderr"), str) or type(value.get("code")) is not int
+                        or len(value["stdout"]) > 4000 or len(value["stderr"]) > 2000):
+                    return _refused("refused", "owner_shell_invalid")
+                return {"state": "attached", "reason": None, "snapshot": None, "receipt": None, "shell": value}
+            if action == "react":
+                if not snap["reactions_supported"]:
+                    return _refused("refused", "owner_reactions_unsupported")
+                if not any(row.get("row_id") == params["row_id"] and row.get("role") in {"user", "assistant"} for row in snap["messages"]):
+                    return _refused("refused", "reaction_row_unavailable")
+                await client.rpc("message.react", **common, row_id=params["row_id"], emoji=params["emoji"], author="user")
+            elif action == "context_detail":
                 from ..context_detail import project, unavailable
                 # The authorized native read owns lookup and prompt interpretation. No local Agent is built.
                 try:
@@ -259,21 +361,27 @@ async def _run(ctx, params: dict, home: Path, discovery) -> dict:
                     if (event.get("type") in {"session.updated", "notification.show", "notification.clear"}
                             or event.get("execution_generation") == snap["execution_generation"]
                             or event.get("type") == "session.info" and event.get("payload", {}).get("execution_generation") == snap["execution_generation"]):
-                        ctx.emit("event", event)
+                        ctx.emit("event", _event(event))
                 sequence = replay["last_sequence"]
             ctx.emit("replay_complete", {})
             checked = asyncio.get_running_loop().time()
             while not ctx.cancelled:
+                now = asyncio.get_running_loop().time()
+                if not restarting and now - checked >= 2:
+                    checked = now
+                    if restarting := await asyncio.to_thread(_restart_wait, home):
+                        result["restarting"] = True
+                        ctx.emit("restarting", {"restarting": True})
+                    if not restarting and snap.get("reactions_supported"):
+                        # The owner emits no reaction event. Read through this viewer's existing subscription,
+                        # including while tokens keep the event queue busy.
+                        current = await snapshot()
+                        if [(r.get("row_id"), r.get("reactions")) for r in current["messages"] if r.get("reactions")] != [(r.get("row_id"), r.get("reactions")) for r in snap["messages"] if r.get("reactions")]:
+                            ctx.emit("snapshot", {**result, "snapshot": current, "reaction_only": True})
+                        snap = current
                 try:
                     frame = await asyncio.wait_for(events.get(), .25)
                 except TimeoutError:
-                    now = asyncio.get_running_loop().time()
-                    if not restarting and now - checked >= 2:
-                        checked = now
-                        # One-way for this owner: its next state is exit, which ends the watch.
-                        if restarting := await asyncio.to_thread(_restart_wait, home):
-                            result["restarting"] = True
-                            ctx.emit("restarting", {"restarting": True})
                     continue
                 if isinstance(frame, Exception):
                     raise frame
@@ -307,9 +415,11 @@ async def _run(ctx, params: dict, home: Path, discovery) -> dict:
                 if event.get("seq", 0) <= sequence:
                     continue
                 sequence = event["seq"]
-                ctx.emit("event", event)
+                ctx.emit("event", _event(event))
             return result
         except GatewayRPCError as exc:
+            if params["action"] == "react" and str(exc) not in {"invalid_params", "not_found", "permission_denied", "profile_mismatch"}:
+                return _refused("unavailable", "reaction_outcome_unknown")
             if params["action"] == "export":
                 return _refused("refused", "export_too_large" if str(exc) == "export_too_large" else "owner_export_unsupported")
             return {**_refused("incompatible" if str(exc) in _CONTROL_REFUSALS else "refused", str(exc)), "receipt": receipt}
@@ -330,9 +440,18 @@ def session(ctx, params: dict) -> dict:
     if action not in _ACTIONS or not isinstance(sid, str) or not sid.strip() or sid != sid.strip():
         raise InvalidParams("session_id and supported action are required")
     params = {**params, "action": action}
+    if action == "react" and (set(params) - {"profile_home", "session_id", "action", "row_id", "emoji"}
+                              or type(params.get("row_id")) is not int or params["row_id"] <= 0
+                              or "emoji" not in params or (params["emoji"] is not None and (not isinstance(params["emoji"], str) or params["emoji"] not in _REACTION_EMOJIS))):
+        raise InvalidParams("react requires a visible row and an allowed emoji")
     if action == "export" and (params.get("format") not in ("json", "markdown", "html")
                                or not isinstance(params.get("redact"), bool)):
         raise InvalidParams("export requires an allowed format and redaction policy")
+    if action == "shell_exec" and (not isinstance(params.get("command"), str)
+            or not params["command"].strip() or len(params["command"]) > 8192
+            or type(params.get("authority_epoch")) is not int or params["authority_epoch"] < 0
+            or not isinstance(params.get("replay_epoch"), str) or not params["replay_epoch"]):
+        raise InvalidParams("captured command requires command and owner identity")
     required = {
         "submit": ("request_id", "text"), "receipt": ("admission_id",), "cancel": ("admission_id",),
         "steer_queued": ("admission_id",), "replace_queued": ("admission_id", "submission_id", "text"),

package/sidecar/talaria_sidecar/methods/groups.py

@@ -0,0 +1,120 @@
+"""Closed native room operations. Attach only, with the Web principal's own grant."""
+from __future__ import annotations
+
+import asyncio
+import json
+from contextlib import suppress
+
+from ..errors import InvalidParams
+from ..home import profile_home_param
+from .gateway_sessions import _connect, _owner_refusal, _with_owner
+
+_FIELDS = {
+    "capabilities": set(), "list": {"offset", "limit"}, "state": {"room_id", "include_disbanded"},
+    "log": {"room_id", "since_seq", "limit"}, "create": {"room_id", "name", "members"},
+    "rename": {"room_id", "event_id", "name"}, "disband": {"room_id", "cancel_id"},
+    "send": {"room_id", "event_id", "payload"}, "stop": {"room_id", "cancel_id"},
+    "retry": {"room_id", "member_id", "task_id", "execution_generation"},
+    "discard": {"room_id", "member_id", "task_id", "execution_generation"},
+    "approve": {"room_id", "member_id", "task_id", "execution_generation", "request_id", "choice"},
+    "attachment.upload": {"room_id", "upload_id", "kind", "name", "mime", "data_base64"},
+    "attachment.download": {"room_id", "event_id", "attachment_id"},
+}
+_READS = {"capabilities", "list", "state", "log", "attachment.download"}
+_REFUSALS = {"permission_denied", "profile_mismatch", "invalid_params", "stale_generation", "unknown_execution",
+             "unsupported_operation", "session_busy", "runtime_coordination_required"}
+
+
+def _result(state, reason=None, value=None):
+    return {"state": state, "reason": reason, "value": value}
+
+
+async def _run(home, subject, operation, discovery, expected_room=None):
+    from hermes_cli.gateway_client import GatewayRPCError
+    action = operation["action"]
+    method = "groups." + action
+    dispatched = False
+    try:
+        if discovery.state != "ready":
+            return _result("unavailable", "stopped")
+        principal = 'auth:v1:' + json.dumps(['talaria', '', subject], separators=(',', ':'))
+        async with _connect(home, discovery.endpoint, subject=principal) as (client, _):
+            # A native 15 MB attachment expands to 20 MB on the wire. Keep the shared native client,
+            # with a bounded receiver large enough for the owner's supported attachment envelope.
+            client.websocket.protocol.max_size = 24 * 1024 * 1024
+            described = await client.rpc("runtime.describe")
+            if _owner_refusal(described, discovery.endpoint):
+                return _result("unavailable", "unsupported")
+            caps = await client.rpc("groups.capabilities")
+            if (not isinstance(caps, dict) or type(caps.get("driver")) is not bool
+                    or not isinstance(caps.get("methods"), list) or method not in caps["methods"]):
+                return _result("unavailable", "unsupported")
+            if not caps["driver"]:
+                return _result("unavailable", "driver_inactive")
+            if action == "capabilities":
+                return _result("available", value=caps)
+            if expected_room is not None:
+                current = await client.rpc("groups.state", room_id=expected_room["room_id"], include_disbanded=True)
+                room = current.get("room", {})
+                if (room.get("room_id") != expected_room["room_id"]
+                        or room.get("authority_gateway_id") != expected_room["gateway_id"]
+                        or room.get("authority_epoch") != expected_room["authority_epoch"]):
+                    return _result("refused", "refused")
+            if action == "send":
+                operation = {**operation, "payload": {**operation["payload"], "thread_id": operation["event_id"]}}
+            dispatched = True
+            value = await client.rpc(method, **{k: v for k, v in operation.items() if k != "action"}, _timeout=25)
+            if not isinstance(value, dict) or len(json.dumps(value).encode()) > 24 * 1024 * 1024:
+                return _result("unknown" if action not in _READS else "unavailable", "unknown")
+            return _result("available", value=value)
+    except GatewayRPCError as exc:
+        reason = str(exc)
+        # Native errors are data, never public diagnostics. Only fixed refusals prove non-admission.
+        if reason in _REFUSALS:
+            return _result("refused", "refused")
+        if "method" in reason.lower() and not dispatched:
+            return _result("unavailable", "unsupported")
+        return _result("unknown" if dispatched and action not in _READS else "unavailable", "unknown")
+    except Exception:  # noqa: BLE001 - a transport loss never authorizes automatic replay
+        return _result("unknown" if dispatched and action not in _READS else "unavailable", "unknown")
+
+
+async def _read(ctx, coroutine):
+    task = asyncio.create_task(coroutine)
+    try:
+        while not task.done():
+            await asyncio.wait({task}, timeout=.1)
+            ctx.check_cancelled()
+        return await task
+    finally:
+        if not task.done():
+            task.cancel()
+            with suppress(asyncio.CancelledError):
+                await task
+
+
+def groups(ctx, params):
+    operation, subject = params.get("operation"), params.get("subject")
+    if (set(params) - {"profile_home", "subject", "operation", "expected_room"}
+            or not {"profile_home", "subject", "operation"} <= set(params)
+            or not isinstance(subject, str) or not 0 < len(subject) <= 128
+            or not isinstance(operation, dict) or operation.get("action") not in _FIELDS
+            or set(operation) - (_FIELDS[operation["action"]] | {"action"})):
+        raise InvalidParams("invalid room operation")
+    expected = params.get("expected_room")
+    if expected is not None and (not isinstance(expected, dict)
+            or set(expected) != {"room_id", "gateway_id", "authority_epoch"}
+            or expected.get("room_id") != operation.get("room_id")
+            or not isinstance(expected.get("gateway_id"), str)
+            or type(expected.get("authority_epoch")) is not int):
+        raise InvalidParams("invalid room authority fence")
+    home = profile_home_param(params).resolve()
+    ctx.check_cancelled()
+    def run(discovery):
+        coroutine = _run(home, subject, operation, discovery, expected)
+        return _read(ctx, coroutine) if operation["action"] in _READS else coroutine
+    result = _with_owner(home, run)
+    if "value" not in result:
+        return _result("unavailable", "stopped" if result["state"] == "stopped" else "unsupported"
+                       if result["state"] == "incompatible" else "unavailable")
+    return result

package/sidecar/talaria_sidecar/methods/kanban.py

@@ -10,8 +10,11 @@ from __future__ import annotations
 import functools
 import json
 import secrets
+import sqlite3
 import time
+from contextlib import closing
 from dataclasses import asdict, is_dataclass
+from pathlib import Path
 from typing import Any, NamedTuple
 
 from ..errors import InvalidParams, RpcError
@@ -463,6 +466,50 @@ def _bool(params: dict, key: str, default: bool = False) -> bool:
 
 # ── payload builders ──────────────────────────────────────────────────────
 
+def inspection_payload(params: dict) -> dict:
+    """Read only the selected profile's live boards, with shared global row/edge budgets."""
+    kb = _kb()
+    selected = _board(params)
+    boards = sorted((b for b in kb.list_boards(include_archived=False) if not b.get("archived")), key=lambda b: b["slug"])
+    if selected is not None:
+        boards = [b for b in boards if b["slug"] == selected]
+        if not boards:
+            raise NotFound("board not found")
+    nodes, edges = [], []
+    truncated = len(boards) > 32
+    for meta in boards[:32]:
+        slug = _normalize_existing_slug(meta["slug"])
+        if len(nodes) >= 500:
+            truncated = True
+            break
+        # An inspection must never initialize a missing database or run migrations.
+        uri = Path(kb.kanban_db_path(slug)).resolve().as_uri() + "?mode=ro"
+        with closing(sqlite3.connect(uri, uri=True)) as conn:
+            conn.row_factory = sqlite3.Row
+            conn.execute("BEGIN")
+            where = "" if _bool(params, "include_archived") else "WHERE t.status != 'archived'"
+            rows = conn.execute(
+                f"SELECT t.*, r.started_at AS current_run_started_at FROM tasks t LEFT JOIN task_runs r ON r.id = t.current_run_id {where} ORDER BY t.id LIMIT ?",
+                (501 - len(nodes),),
+            ).fetchall()
+            remaining = 500 - len(nodes)
+            truncated = truncated or len(rows) > remaining
+            rows = rows[:remaining]
+            ids = [row["id"] for row in rows]
+            for row in rows:
+                task = _task_dict(dict(row), conn)
+                nodes.append({"key": f"{slug}/{row['id']}", "board": slug, "board_name": meta.get("name") or slug, "task": task})
+            if ids:
+                placeholders = ",".join("?" for _ in ids)
+                links = conn.execute(
+                    f"SELECT parent_id, child_id FROM task_links WHERE parent_id IN ({placeholders}) AND child_id IN ({placeholders}) ORDER BY parent_id, child_id LIMIT ?",
+                    [*ids, *ids, 2001 - len(edges)],
+                ).fetchall()
+                remaining_edges = 2000 - len(edges)
+                truncated = truncated or len(links) > remaining_edges
+                edges.extend({"source": f"{slug}/{r['parent_id']}", "target": f"{slug}/{r['child_id']}"} for r in links[:remaining_edges])
+    return {"nodes": nodes, "edges": edges, "generated_at": time.time(), "truncated": truncated, "read_only": False}
+
 def board_payload(params: dict) -> dict:
     board = _board(params)
     kb = _kb()
@@ -852,6 +899,7 @@ def normalize_board_payload(params: dict) -> dict:
 
 
 METHODS = {
+    "kanban.inspection": inspection_payload,
     "kanban.normalize_board": normalize_board_payload,
     "kanban.board": board_payload,
     "kanban.boards": list_boards_payload,

package/sidecar/talaria_sidecar/methods/managed_buffers.py

@@ -0,0 +1,110 @@
+"""Fixed devkit REST adapter through the existing admitted Agent plugin host."""
+import base64
+import json
+import re
+
+from .. import home as homes
+from ..errors import InvalidParams, RpcError
+from . import dashboard_plugins as host
+
+MAX_BYTES = 256 * 1024
+_NAME = re.compile(r'[A-Za-z0-9][A-Za-z0-9._-]{0,127}')
+_DIR = re.compile(r'[A-Za-z0-9_-]{1,96}')
+
+
+def _text_size(value):
+    try:
+        return len(value.encode('utf-8')) if isinstance(value, str) else -1
+    except UnicodeError:
+        return -1
+
+
+def _bad():
+    raise RpcError('Managed buffer response is invalid or too large', condition='buffer_invalid')
+
+
+def _json(ctx, plugin, home, method, path, content=None):
+    # Recheck admission for each native call, including the PUT after inventory.
+    current = host._named(home, 'devkit', require_panel=False)
+    if current is None or current['_dir'] != plugin['_dir'] or current.get('_api_file') != plugin.get('_api_file'):
+        raise RpcError('Managed buffer backend changed or was disabled', condition='buffer_unavailable')
+    body = b'' if content is None else json.dumps({'content': content}, ensure_ascii=False).encode()
+    result = host._request(ctx, plugin, dict(profile_home=str(home), authenticated=True, method=method, path=path, query='',
+        headers={'content-type': 'application/json'}, body=base64.b64encode(body).decode()), require_panel=False)
+    if result['status'] != 200:
+        # A PUT may have committed before an error or malformed acknowledgement. Never replay it here.
+        raise RpcError('Managed buffer unavailable' if method == 'GET' else 'Save outcome is unknown; reload before retrying',
+                       condition='buffer_unavailable' if method == 'GET' else 'buffer_save_unconfirmed')
+    try:
+        value = json.loads(base64.b64decode(result['body']))
+    except (ValueError, UnicodeDecodeError):
+        _bad()
+    if not isinstance(value, dict):
+        _bad()
+    return value
+
+
+def run(ctx, params):
+    action, sid = params.get('action'), params.get('session_id')
+    if action not in ('list', 'read', 'save') or not isinstance(sid, str) or not 0 < len(sid) <= 200:
+        raise InvalidParams('Invalid managed buffer request')
+    name = params.get('name')
+    if action != 'list' and (not isinstance(name, str) or not _NAME.fullmatch(name)):
+        raise InvalidParams('Invalid managed buffer name')
+    content = params.get('content')
+    if action == 'save' and (not 0 <= _text_size(content) <= MAX_BYTES):
+        raise InvalidParams('Managed buffer content is too large or is not text')
+    home = homes.profile_home_param(params)
+    with homes.scoped_home(home, load_plugins=False):
+        plugin = host._named(home, 'devkit', require_panel=False) if host._supported() else None
+        result = {'supported': plugin is not None, 'buffers': [], 'write_semantics': 'unconditional'}
+        if plugin is None:
+            if action != 'list':
+                raise RpcError('Enable and approve the devkit backend in Plugins', condition='buffer_unavailable')
+            return result
+        rows = _json(ctx, plugin, home, 'GET', '/sessions').get('sessions')
+        if not isinstance(rows, list) or len(rows) > 2000 or any(not isinstance(r, dict) for r in rows):
+            _bad()
+        matches = [r for r in rows if r.get('session_id') == sid]
+        if len(matches) > 1:
+            _bad()
+        row = matches[0] if matches else None
+        if row is None:
+            if action != 'list':
+                raise RpcError('Managed buffer no longer exists', condition='buffer_unavailable')
+            return result
+        directory, buffers = row.get('dir'), row.get('buffers')
+        if not isinstance(directory, str) or not _DIR.fullmatch(directory) or not isinstance(buffers, list) or len(buffers) > 200:
+            _bad()
+        seen = set()
+        for buf in buffers:
+            if not isinstance(buf, dict):
+                _bad()
+            key, size = buf.get('name'), buf.get('bytes')
+            if not isinstance(key, str) or not _NAME.fullmatch(key) or key in seen or type(size) is not int or not 0 <= size <= MAX_BYTES:
+                _bad()
+            seen.add(key)
+            result['buffers'].append({'name': key, 'size': size, 'read_only': row.get('exists') is not True})
+        if action == 'list':
+            return result
+        selected = next((b for b in result['buffers'] if b['name'] == name), None)
+        if selected is None:
+            raise RpcError('Managed buffer no longer exists', condition='buffer_unavailable')
+        if action == 'save' and selected['read_only']:
+            raise RpcError('Managed session is deleted or cannot be verified', condition='buffer_read_only')
+        value = _json(ctx, plugin, home, 'PUT' if action == 'save' else 'GET', f'/sessions/{directory}/buffers/{name}', content if action == 'save' else None)
+        if action == 'read':
+            text = value.get('content')
+            if value.get('session_id') != sid or value.get('name') != name or not 0 <= _text_size(text) <= MAX_BYTES:
+                _bad()
+            result.update(content=text, size=_text_size(text), read_only=selected['read_only'])
+        else:
+            # Native PUT acknowledgements may omit session_id, but an explicit identity must match.
+            if value.get('session_id', sid) != sid or value.get('name') != name or type(value.get('bytes')) is not int or not 0 <= value['bytes'] <= MAX_BYTES:
+                raise RpcError('Save outcome is unknown; reload before retrying', condition='buffer_save_unconfirmed')
+            result.update(size=value['bytes'], read_only=False)
+        return result
+
+
+def register(registry):
+    registry.method('plugins.buffers')(run)