@maudecode/talaria-web 1.18.0 → 1.19.0

package/sidecar/talaria_sidecar/methods/gateway_sessions.py

@@ -0,0 +1,234 @@
+"""Authenticated observations and fenced controls of an existing native owner.
+
+Never ensure/start a gateway, build an Agent, or write its transcript locally.
+Each call owns its connection and subscription; cancellation only detaches it.
+"""
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager, closing, suppress
+import json
+from pathlib import Path
+import sqlite3
+
+from ..errors import InvalidParams
+from ..home import profile_home_param, scoped_home
+
+_ACTIONS = {"snapshot", "watch", "submit", "receipt", "cancel", "interrupt", "approval", "clarify", "discard", "mutate"}
+_CAPABILITIES = {"durable-admission-v1", "event-replay-v1"}
+_CONTROL_REFUSALS = {"native_clarify_batch_unavailable", "owner_controls_unverified"}
+
+
+def _control_refusal(home: Path, sid: str) -> str | None:
+    """Only canonical PendingControls can be recovered on v0.22.1. Never infer a missing batch.
+
+    Read the owner's committed admission in a read-only connection; opening SessionDB here
+    would run its schema writer alongside the owner. Compression keeps the logical target.
+    """
+    try:
+        with closing(sqlite3.connect((home / "state.db").as_uri() + "?mode=ro", uri=True, timeout=2)) as db:
+            rows = db.execute("""SELECT payload_json FROM session_admissions
+                WHERE target_session_id=? AND status IN ('queued', 'started')""", (sid,))
+            for (raw,) in rows:
+                payload = json.loads(raw)
+                policy = payload.get("cli_turn_v1", {})
+                if not isinstance(policy, dict):
+                    return "owner_controls_unverified"
+                if "clarify_batch" in policy and not isinstance(policy["clarify_batch"], bool):
+                    return "owner_controls_unverified"
+                if policy.get("clarify_batch") is True:
+                    return "native_clarify_batch_unavailable"
+    except (sqlite3.Error, OSError, ValueError, TypeError, AttributeError):
+        return "owner_controls_unverified"
+    return None
+
+
+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"}
+    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}}
+
+
+def _refused(state: str, reason: str) -> dict:
+    return {"state": state, "reason": reason, "snapshot": None, "receipt": None}
+
+
+@asynccontextmanager
+async def _connect(home: Path, endpoint):
+    from hermes_constants import get_hermes_home
+    from hermes_cli.gateway_client import GatewayClientError, connect_gateway
+
+    # The supplied endpoint selects the native client's attach-only branch. The home
+    # 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:
+        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.
+        events = asyncio.Queue(maxsize=4096)
+
+        async def drain():
+            while True:
+                frame = await client.events.get()
+                if isinstance(frame, dict) and frame.get("method") in {"sudo", "secret"} and "id" in frame:
+                    await websocket.send(json.dumps({"jsonrpc": "2.0", "id": frame["id"], "result": {"value": ""}}))
+                else:
+                    await events.put(frame)
+
+        reader = asyncio.create_task(drain())
+        try:
+            yield client, events
+        finally:
+            reader.cancel()
+            with suppress(asyncio.CancelledError):
+                await reader
+
+
+async def _run(ctx, params: dict, home: Path, discovery) -> dict:
+    from hermes_cli.gateway_client import GatewayRPCError
+
+    endpoint = discovery.endpoint
+    # v1's served LOCAL route can lose its frozen policy when the shared runner pins
+    # transport identity. A dedicated owner's profile is isolated; a served profile
+    # needs a verified execution contract before Talaria may submit through it.
+    if endpoint.control_home and Path(endpoint.control_home).resolve() != home:
+        return _refused("incompatible", "served_profile_sessions_unavailable")
+    subscription = None
+    async with _connect(home, endpoint) as (client, events):
+        described = await client.rpc("runtime.describe")
+        if (described.get("instance_id") != endpoint.instance_id
+                or described.get("profile_id") != endpoint.profile_id
+                or described.get("authority_epoch") != endpoint.authority_epoch
+                or not _CAPABILITIES.issubset(described.get("capabilities", []))):
+            return _refused("incompatible", "owner_capabilities")
+        sid = params["session_id"]
+
+        async def snapshot():
+            nonlocal subscription, sid
+            value = await client.rpc("session.resume", session_id=sid)
+            sid = value["session_id"]
+            # Native attach reuses this actor's subscription; overflow retires it before
+            # a replacement is issued. A resume does not accumulate live subscriptions.
+            subscription = value["subscription_id"]
+            if reason := await asyncio.to_thread(_control_refusal, home, sid):
+                raise GatewayRPCError(reason)
+            return _snapshot(value)
+
+        receipt = None
+        try:
+            snap = await snapshot()
+            action = params["action"]
+            common = {"session_id": sid}
+            if action == "submit":
+                # The caller retains this identity across lost ACKs. An ambiguous error never
+                # causes this adapter to generate a replacement or replay started work.
+                receipt = await client.rpc("prompt.submit", **common, submission_id=params["request_id"], text=params["text"])
+            elif action == "receipt":
+                receipt = await client.rpc("prompt.receipt", **common, admission_id=params["admission_id"])
+            elif action in {"cancel", "discard"}:
+                method = "prompt.cancel" if action == "cancel" else "prompt.resolve_unknown"
+                receipt = await client.rpc(method, **common, admission_id=params["admission_id"],
+                    **({"execution_generation": params["execution_generation"]} if action == "discard" else {}))
+            elif action == "interrupt":
+                await client.rpc("session.interrupt", **common, execution_generation=params["execution_generation"])
+            elif action in {"approval", "clarify"}:
+                await client.rpc(action + ".respond", **common, prompt_id=params["prompt_id"],
+                    execution_generation=params["execution_generation"],
+                    **({"choice": params["choice"]} if action == "approval" else {"answer": params["text"]}))
+            elif action == "mutate":
+                await client.rpc("session.mutate", **common, request_id=params["request_id"],
+                    expected_revision=params["expected_revision"], expected_generation=params["execution_generation"],
+                    operation=params["operation"], payload=params["payload"], _timeout=660)
+            if action not in {"snapshot", "watch"}:
+                snap = await snapshot()
+            result = {"state": "attached", "reason": None, "snapshot": snap, "receipt": receipt}
+            if action != "watch":
+                return result
+            ctx.emit("snapshot", result)
+            epoch, sequence = snap["replay_epoch"], snap["last_sequence"]
+            # Rebuild the active turn's display from retained events, even when its initial
+            # tokens predate this viewer. A gap replaces the subscription, never invents replay.
+            replay = await client.rpc("session.events.since", **common, replay_epoch=epoch, last_sequence=0)
+            if replay.get("snapshot_required"):
+                snap = await snapshot()
+                ctx.emit("snapshot", {**result, "snapshot": snap, "replay_gap": True})
+                epoch, sequence = snap["replay_epoch"], snap["last_sequence"]
+            else:
+                for event in replay["events"]:
+                    if (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)
+                sequence = replay["last_sequence"]
+            while not ctx.cancelled:
+                try:
+                    frame = await asyncio.wait_for(events.get(), .25)
+                except TimeoutError:
+                    continue
+                if isinstance(frame, Exception):
+                    raise frame
+                if frame.get("method") == "clarify" and "id" in frame:
+                    raise GatewayRPCError("native_clarify_batch_unavailable")
+                event = frame.get("params", {})
+                if event.get("session_id") != sid:
+                    continue
+                if event.get("type") == "session.info":
+                    if reason := await asyncio.to_thread(_control_refusal, home, sid):
+                        raise GatewayRPCError(reason)
+                if (event.get("type") == "session.replay_gap" or event.get("replay_epoch") != epoch
+                        or event.get("seq", sequence + 1) > sequence + 1):
+                    snap = await snapshot()
+                    ctx.emit("snapshot", {**result, "snapshot": snap, "replay_gap": True})
+                    epoch, sequence = snap["replay_epoch"], snap["last_sequence"]
+                    continue
+                if event.get("seq", 0) <= sequence:
+                    continue
+                sequence = event["seq"]
+                ctx.emit("event", event)
+            return result
+        except GatewayRPCError as exc:
+            return {**_refused("incompatible" if str(exc) in _CONTROL_REFUSALS else "refused", str(exc)), "receipt": receipt}
+        except Exception:  # noqa: BLE001 - native transport/contract failures never authorize another writer
+            # A received receipt remains admission proof even if the following observation
+            # disconnects. Losing that ACK would invite a new request identity for admitted work.
+            return {**_refused("unavailable", "owner_connection_lost"), "receipt": receipt}
+        finally:
+            if subscription:
+                with suppress(Exception):
+                    await client.rpc("session.detach", session_id=sid, subscription_id=subscription)
+
+
+def session(ctx, params: dict) -> dict:
+    home = profile_home_param(params).resolve()
+    action = params.get("action", "snapshot")
+    sid = params.get("session_id")
+    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}
+    required = {
+        "submit": ("request_id", "text"), "receipt": ("admission_id",), "cancel": ("admission_id",),
+        "interrupt": ("execution_generation",), "approval": ("execution_generation", "prompt_id", "choice"),
+        "clarify": ("execution_generation", "prompt_id", "text"), "discard": ("execution_generation", "admission_id"),
+        "mutate": ("request_id", "expected_revision", "execution_generation", "operation", "payload"),
+    }.get(action, ())
+    if any(key not in params for key in required):
+        raise InvalidParams("missing gateway session action fields")
+    try:
+        from hermes_constants import set_hermes_home_override, reset_hermes_home_override  # noqa: F401
+        from hermes_cli.gateway_runtime import discover_gateway_endpoint
+        from hermes_cli.gateway_client import connect_gateway  # noqa: F401
+    except ImportError:
+        return _refused("incompatible", "native_sessions_unavailable")
+    with scoped_home(home):
+        discovery = discover_gateway_endpoint(home)
+        if discovery.state != "ready" or discovery.endpoint is None:
+            return _refused("stopped" if discovery.state in {"stopped", "absent"} else "unavailable", discovery.reason_code or discovery.state)
+        try:
+            return asyncio.run(_run(ctx, params, home, discovery))
+        except Exception:  # noqa: BLE001 - native transport/contract failures never authorize another writer
+            # Do not expose peer diagnostics, endpoint paths or bootstrap credentials.
+            return _refused("unavailable", "owner_connection_lost")

package/sidecar/talaria_sidecar/methods/goals.py

@@ -1,7 +1,8 @@
 """``goals.*``: Hermes persistent session goals (ported from api/goals.py).
 
-The server passes the session's ``profile_home`` and the configured turn
-budget; the sidecar never reads WebUI settings itself.
+The server passes the session's ``profile_home``, its workspace and the configured
+turn budget; the sidecar never reads WebUI settings itself. ``/goal`` parses through
+the Agent's own ``dispatch_goal_command``, like its CLI, gateway and TUI.
 """
 
 from __future__ import annotations
@@ -14,7 +15,7 @@ from pathlib import Path
 from typing import Any
 
 from ..errors import InvalidParams, RpcError
-from ..home import profile_home_param, scoped_home
+from ..home import profile_home_param, scoped_home, session_workspace
 from ..rpc import CallContext
 
 log = logging.getLogger("talaria_sidecar.goals")
@@ -29,17 +30,18 @@ def _native():
 
 
 class _Manager:
-    """Native GoalManager scoped to one profile home."""
+    """Native GoalManager scoped to one profile home and the session's workspace, where its gates run."""
 
-    def __init__(self, session_id: str, profile_home: Path, default_max_turns: int):
+    def __init__(self, session_id: str, profile_home: Path, default_max_turns: int, workspace: str | None = None):
         _, default, GoalManager, _, _ = _native()
         self.session_id = session_id
         self.profile_home = profile_home
+        self.workspace = workspace
         with scoped_home(profile_home):
             self._manager = GoalManager(session_id=session_id, default_max_turns=int(default_max_turns or default or 20))
 
     def scoped(self, func, *args, **kwargs):
-        with scoped_home(self.profile_home):
+        with scoped_home(self.profile_home), session_workspace(self.workspace):
             return func(*args, **kwargs)
 
     @property
@@ -123,13 +125,22 @@ def _decision_payload(decision: dict, state: Any) -> dict:
         turns_used, max_turns = _turns_from_message(str(decision.get("message") or ""))
     if status == "done":
         return {**decision, "message_key": "goal_achieved", "message_args": [reason]}
-    if status == "paused":
+    if status == "paused" and str(getattr(state, "paused_reason", "") or "").startswith("turn budget exhausted"):
         return {**decision, "message_key": "goal_paused_budget_exhausted", "message_args": [turns_used, max_turns]}
     if decision.get("should_continue"):
         return {**decision, "message_key": "goal_continuing", "message_args": [turns_used, max_turns, reason]}
     return decision
 
 
+def _parked(mgr: _Manager) -> dict | None:
+    """TAL-808: an active goal's live wait barrier, as the Agent's own ``is_waiting`` (which clears a satisfied one) sees it."""
+    if not mgr.is_waiting():
+        return None
+    state = mgr.state
+    until = float(getattr(state, "waiting_until", 0.0) or 0.0)
+    return {"reason": getattr(state, "waiting_reason", None) or None, "until": until or None}
+
+
 def _inactive(reason: str, status=None) -> dict:
     return {"status": status, "should_continue": False, "continuation_prompt": None, "verdict": "inactive", "reason": reason, "message": ""}
 
@@ -139,7 +150,41 @@ def _manager_from(params: dict) -> _Manager:
     if not session_id:
         raise InvalidParams("session_id is required")
     max_turns = params.get("default_max_turns") or 20
-    return _Manager(session_id, profile_home_param(params), int(max_turns))
+    return _Manager(session_id, profile_home_param(params), int(max_turns), str(params.get("workspace") or "") or None)
+
+
+#: Older Agents run gates in their launch directory, where a gate checks another project and can pass for it.
+_GATES_NEED_WORKSPACE = "Goal gates need Hermes Agent 0.21.6 or later, which runs them in the session workspace."
+
+
+def _gates_run_in_workspace() -> bool:
+    from hermes_cli import goals as agent_goals
+
+    return hasattr(agent_goals, "_gate_workspace")
+
+
+#: The response ``action`` of each control verb the Agent dispatches; any other command sets the goal.
+_CONTROL_ACTIONS = {
+    "": "status", "status": "status", "show": "show", "pause": "pause", "resume": "resume", "continue": "resume",
+    "unpause": "resume", "clear": "clear", "stop": "clear", "done": "clear", "unwait": "unwait", "wait": "wait", "gate": "gate",
+}
+
+
+def _localized(action: str, state: Any, had_goal: bool) -> dict:
+    """``message_key``/``message_args`` for the verbs Web already localizes; other verbs show the Agent's text."""
+    status = str(getattr(state, "status", "") or "")
+    goal = str(getattr(state, "goal", "") or "")
+    if action == "status":
+        return {k: v for k, v in _status_payload(state).items() if k != "message"}
+    if action == "set":
+        return {"message_key": "goal_set", "message_args": [int(getattr(state, "max_turns", 0) or 0), goal]}
+    if action == "pause":
+        return {"message_key": "goal_paused", "message_args": [goal]} if had_goal and status == "paused" else {"message_key": "goal_no_goal"}
+    if action == "resume":
+        return {"message_key": "goal_resumed", "message_args": [goal]} if had_goal and status == "active" else {"message_key": "goal_no_goal"}
+    if action == "clear":
+        return {"message_key": "goal_cleared" if had_goal else "goal_no_goal"}
+    return {}
 
 
 def register(registry) -> None:
@@ -147,45 +192,35 @@ def register(registry) -> None:
     def get(ctx: CallContext, params: dict) -> dict:
         mgr = _manager_from(params)
         state = mgr.state
-        return {"goal": _state_payload(state), "active": bool(state is not None and getattr(state, "status", None) == "active"), **_status_payload(state)}
+        active = bool(state is not None and getattr(state, "status", None) == "active")
+        return {"goal": _state_payload(state), "active": active, "parked": _parked(mgr) if active else None, **_status_payload(state)}
 
     @registry.method("goals.command")
     def command(ctx: CallContext, params: dict) -> dict:
-        """/goal <args> with the same semantics as the gateway command."""
+        """/goal <args> through the Agent's ``dispatch_goal_command``, as its TUI runs it."""
         mgr = _manager_from(params)
+        try:
+            from hermes_cli import goals as agent_goals
+            from hermes_cli.goal_command import dispatch_goal_command, is_goal_control
+        except Exception as exc:  # noqa: BLE001
+            raise RpcError(f"Hermes goals unavailable: {exc}", condition="goals_unavailable")
         text = str(params.get("args") or "").strip()
-        lower = text.lower()
-        stream_running = bool(params.get("stream_running", False))
-        if not text or lower == "status":
-            state = mgr.state
-            return _payload(action="status", state=state, **_status_payload(state))
-        if lower == "pause":
-            state = mgr.pause(reason="user-paused")
-            if state is None:
-                return _payload(ok=False, action="pause", error="no_goal", message="No goal set.", message_key="goal_no_goal")
-            return _payload(action="pause", message=f"⏸ Goal paused: {state.goal}", message_key="goal_paused", message_args=[str(state.goal)], state=state)
-        if lower == "resume":
-            state = mgr.resume()
-            if state is None:
-                return _payload(ok=False, action="resume", error="no_goal", message="No goal to resume.", message_key="goal_no_goal")
-            return _payload(action="resume", message=f"▶ Goal resumed: {state.goal}\nSend a new message, or type continue, to kick it off.", message_key="goal_resumed", message_args=[str(state.goal)], state=state)
-        if lower in ("clear", "stop", "done"):
-            had = bool(mgr.has_goal())
-            mgr.clear()
-            return _payload(action="clear", message="Goal cleared." if had else "No active goal.", message_key="goal_cleared" if had else "goal_no_goal", state=mgr.state)
-        if stream_running:
+        tokens = text.lower().split()
+        action = _CONTROL_ACTIONS.get(tokens[0] if tokens else "", "set") if is_goal_control(text) else "set"
+        if action == "set" and params.get("stream_running"):
             return _payload(ok=False, action="set", error="agent_running", message="Agent is running — use /goal status / pause / clear mid-run, or /stop before setting a new goal.")
-        try:
-            state = mgr.set(text)
-        except ValueError as exc:
-            return _payload(ok=False, action="set", error="invalid_goal", message=f"Invalid goal: {exc}")
-        return _payload(
-            action="set",
-            message=(f"⊙ Goal set ({state.max_turns}-turn budget): {state.goal}\n"
-                     "I'll keep working until the goal is done, you pause/clear it, or the budget is exhausted.\n"
-                     "Controls: /goal status · /goal pause · /goal resume · /goal clear"),
-            message_key="goal_set", message_args=[state.max_turns, state.goal], state=state, kickoff_prompt=state.goal,
-        )
+        if tokens[:2] == ["gate", "add"] and not _gates_run_in_workspace():
+            return _payload(ok=False, action="gate", error="gates_unsupported", state=mgr.state, message=_GATES_NEED_WORKSPACE)
+        had_goal = bool(mgr.has_goal())
+        # Only goal-setting text reads it: a re-pasted goal kicks off without repeating itself.
+        last_user_message = mgr.scoped(agent_goals.last_user_message_from_db, mgr.session_id) if action == "set" else None
+        result = mgr.scoped(dispatch_goal_command, mgr._manager, text, authorize_gate=lambda: None, last_user_message=last_user_message)
+        state = mgr.state
+        if result.error:
+            return _payload(ok=False, action=action, error="invalid_goal" if action == "set" else "invalid_command", message=result.output, state=state)
+        # A running turn's judge continues a resumed goal itself.
+        kickoff = result.prompt if result.prompt and not params.get("stream_running") else None
+        return _payload(action=action, message=result.output, state=state, kickoff_prompt=kickoff, **_localized(action, state, had_goal))
 
     @registry.method("goals.snapshot")
     def snapshot(ctx: CallContext, params: dict) -> dict:
@@ -212,6 +247,11 @@ def register(registry) -> None:
         try:
             if not mgr.is_active():
                 return _inactive("no active goal", getattr(mgr.state, "status", None) if mgr.state is not None else None)
+            # Gates set on a newer Agent persist across a channel switch; this one would run them outside the workspace.
+            if getattr(mgr.state, "gates", None) and not _gates_run_in_workspace():
+                mgr.pause(reason="gates need Hermes Agent 0.21.6 or later")
+                return {"status": "paused", "should_continue": False, "continuation_prompt": None, "verdict": "gate_failed", "reason": "gates not run",
+                        "message": f"⏸ Goal paused — quality gates not run. {_GATES_NEED_WORKSPACE} /goal gate clear, then /goal resume."}
             decision = mgr.evaluate_after_turn(str(params.get("last_response") or ""), user_initiated=bool(params.get("user_initiated", True)))
         except Exception as exc:  # noqa: BLE001 - never fail a turn on goal evaluation
             log.debug("goal evaluation failed", exc_info=True)

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
 
 
@@ -197,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
@@ -237,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
 
 
@@ -327,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")
 
 
@@ -373,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:
@@ -449,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)}),
@@ -472,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(
@@ -480,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}
 
 
@@ -534,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,
         }
@@ -583,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"):
@@ -761,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 "")