@maudecode/talaria-web 1.21.0 → 1.22.0

package/sidecar/talaria_sidecar/methods/chat.py

@@ -18,6 +18,7 @@ import importlib.util
 import inspect
 import json
 import logging
+import math
 import os
 import queue
 import re
@@ -34,7 +35,7 @@ from ..errors import InvalidParams, RpcError
 from ..home import profile_home_param, scoped_home, session_workspace
 from ..rpc import CallContext
 from .checkpoints import checkpoint_kwargs
-from .providers import runtime_failure
+from .providers import require_runtime_ownership, runtime_failure
 from .state_db import release_all, release_home, release_session_db
 from .toolsets import disabled_toolsets
 
@@ -69,6 +70,12 @@ class _Run:
         self.session_ended = False
         self.home = None  # the profile home its agent runs under, set by ``start``
         self.mcp_discovery_outcome = "ok"
+        self.deadline: float | None = None
+
+    def prompt_cancelled(self, data: dict) -> bool:
+        # Vault answers racing a clear retain their existing unlock-then-release cleanup at turn end.
+        ended = self.session_ended and not str(data.get("kind") or "").startswith("vault_")
+        return self.ctx.cancelled or self.cancel.is_set() or self.finished.is_set() or ended
 
 
 class _ClarifyEntry:
@@ -80,7 +87,77 @@ class _ClarifyEntry:
         self.deadline: float | None = None
 
 
+def _ask_clarify(run: _Run, data: dict, timeout: int, emit=None) -> str | None:
+    """Park on a prompt the server relays until it is answered, the turn is cancelled or ends, or ``timeout``
+    passes (``<= 0``: no limit). The answer, or None, goes back to the Agent and is never emitted."""
+    emit = emit or run.ctx.emit
+    entry = _ClarifyEntry(data)
+    entry.data["clarify_id"] = entry.clarify_id
+    entry.deadline = None if timeout <= 0 else time.monotonic() + float(timeout)
+    if run.deadline is not None:
+        entry.deadline = min(entry.deadline, run.deadline) if entry.deadline is not None else run.deadline
+    with run.lock:
+        if run.prompt_cancelled(data) or (entry.deadline is not None and entry.deadline <= time.monotonic()):
+            return None
+        run.clarify_entries[entry.clarify_id] = entry
+    try:
+        emit("clarify", dict(entry.data))
+        while not entry.event.is_set():
+            if run.prompt_cancelled(data):
+                break
+            if entry.deadline is None:
+                entry.event.wait(0.1)
+                continue
+            remaining = entry.deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            entry.event.wait(min(0.1, remaining))
+    finally:
+        with run.lock:
+            run.clarify_entries.pop(entry.clarify_id, None)
+        emit("clarify_resolved", {"clarify_id": entry.clarify_id, "session_id": run.session_id})
+    return None if run.prompt_cancelled(data) else entry.result
+
+
+def _clarify_callback(run: _Run, params: dict, emit=None):
+    def clarify_callback(question, choices=None, multi_select=False, questions=None):
+        # TAL-351: remove the legacy signature path when v0.21.6 is the oldest supported Agent.
+        structured = isinstance(question, list)
+        if structured:
+            questions, question = question, ""
+        choices_list = [str(c) for c in (choices or [])]
+        # Predecessor `_clarify_timeout_seconds`: the Agent's own resolver over this profile's config
+        # (``clarify.timeout`` else ``agent.clarify_timeout`` else 3600); ``<= 0`` waits until answered or cancelled.
+        # The advertised ``timeout_seconds`` is what the clients count down, so it is the same number.
+        timeout = _clarify_timeout(params)
+        if run.deadline is not None:
+            remaining = max(1, math.ceil(run.deadline - time.monotonic()))
+            timeout = min(timeout, remaining) if timeout > 0 else remaining
+        data = {"question": str(question or ""), "choices_offered": choices_list, "session_id": run.session_id, "kind": "clarify", "requested_at": time.time(), "timeout_seconds": timeout}
+        if multi_select:
+            data["multi_select"] = True
+        # Batch prompts (the Agent's ``_run_batch``) carry no top-level question and expect the ``{"answers": {...}}`` reply.
+        if isinstance(questions, list) and questions:
+            data["questions"] = questions
+        answer = _ask_clarify(run, data, timeout, emit)
+        if answer is not None:
+            if structured:
+                return {"answers": json.loads(answer)["answers"], "outcome": "submitted"}
+            return answer
+        cancelled = run.prompt_cancelled(data)
+        if structured:
+            return {"answers": {}, "outcome": "cancelled" if cancelled else "timed_out",
+                    "notice": "The user cancelled the clarification." if cancelled else "The clarification timed out."}
+        # Older tools have no outcome field. A batch understands timed_out; a single needs an empty answer.
+        if questions:
+            return json.dumps({"answers": {}, "timed_out": not cancelled})
+        return ""
+
+    return clarify_callback
+
+
 _RUNS: dict[str, _Run] = {}
+_COMMAND_RUNS: dict[str, _Run] = {}
 _RUNS_BY_SESSION: dict[str, str] = {}
 # Which run owns the Agent's gateway approval callback per session; register/unregister happen under one lock so a
 # stale run can never remove a successor's callback, and a successor can never leak a predecessor's.
@@ -108,6 +185,43 @@ _MCP_REDISCOVERY_WAIT = 2.0
 _MCP_PENDING_KEY = "mcp_discovery_pending"
 
 
+def cancel_command_choices(session_id: str | None = None, home=None) -> None:
+    with _RUNS_LOCK:
+        for run in _COMMAND_RUNS.values():
+            if (session_id is None or run.session_id == session_id) and (home is None or run.home == os.path.realpath(home)):
+                run.session_ended = True
+                run.cancel.set()
+
+
+@contextlib.contextmanager
+def command_choices(ctx: CallContext, params: dict):
+    session_id = str(params.get("session_id") or "").strip()
+    try:
+        from hermes_cli.plugin_choices import bind_asker, clarify_asker
+    except ImportError:
+        yield
+        return
+    if not session_id:
+        yield
+        return
+    run = _Run(uuid.uuid4().hex, session_id, ctx)
+    # The server's commands.exec budget includes every question and the handler's final output.
+    run.deadline = time.monotonic() + 120
+    run.home = os.path.realpath(profile_home_param(params))
+    with _MCP_DISCOVERY_LOCK, _RUNS_LOCK:
+        ctx.check_cancelled()
+        if _DRAINING.is_set() or run.home in _MCP_CLOSING_HOMES:
+            raise RpcError("Command profile is unavailable", condition="profile_unavailable")
+        _COMMAND_RUNS[run.stream_id] = run
+    try:
+        with bind_asker(clarify_asker(_clarify_callback(run, params))):
+            yield
+    finally:
+        run.finished.set()
+        with _RUNS_LOCK:
+            _COMMAND_RUNS.pop(run.stream_id, None)
+
+
 def _snippet(raw: Any, limit: int = _TOOL_RESULT_SNIPPET_MAX) -> str:
     """Predecessor ``_tool_result_snippet``: the ``output``/``result``/``error`` of a dict (or JSON) result, hard-cut."""
     if limit <= 0:
@@ -313,8 +427,14 @@ def _usage(agent: Any) -> dict:
         value = getattr(agent, name, None)
         return value if isinstance(value, (int, float)) else 0
 
+    try:
+        from gateway.session_usage import plan_gauge
+        gauge = plan_gauge(agent)
+    except Exception:  # noqa: BLE001 - older Agent capability omission clears a complete snapshot
+        gauge = None
     cost = getattr(agent, "session_estimated_cost_usd", None)
     return {
+        **({"plan_gauge": gauge} if gauge is not None else {}),
         "prompt_tokens": int(_num("session_prompt_tokens")),
         "completion_tokens": int(_num("session_completion_tokens")),
         "cache_read_tokens": int(_num("session_cache_read_tokens")),
@@ -695,6 +815,7 @@ def _cancel_checkpoint(run: _Run) -> list | None:
 
 
 def _resolve_runtime(provider: str | None, model: str) -> dict:
+    require_runtime_ownership(provider)
     try:
         from hermes_cli.runtime_provider import resolve_runtime_provider
     except Exception as exc:  # noqa: BLE001
@@ -1363,6 +1484,7 @@ def _cancel_background_reviews(entries, message: str) -> list[threading.Thread]:
 
 def evict_all_agents() -> int:
     """Drop every cached agent (credentials or environment changed underneath them)."""
+    cancel_command_choices()
     with _AGENT_CACHE_LOCK:
         entries = list(_AGENT_CACHE.values())
         _AGENT_CACHE.clear()
@@ -1387,7 +1509,7 @@ def drain_agents(timeout: float = _AGENT_RELEASE_TIMEOUT) -> None:
         run.cancel.set()
     while time.monotonic() < deadline:
         with _AGENT_CACHE_LOCK, _RUNS_LOCK:
-            if not _COMMITTING and not any(_RUNS.get(run.stream_id) is run for run in runs):
+            if not _COMMITTING and not _COMMAND_RUNS and not any(_RUNS.get(run.stream_id) is run for run in runs):
                 break
         time.sleep(0.05)
     # A turn may have cached its agent after the first eviction.
@@ -1440,6 +1562,7 @@ def release_profile_agents(home):
             raise RpcError("The profile is already being deleted.", condition="profile_unavailable")
         _MCP_CLOSING_HOMES.add(target)
     try:
+        cancel_command_choices(home=home)
         with _AGENT_CACHE_LOCK:
             entries = [_AGENT_CACHE.pop(sid) for sid, entry in list(_AGENT_CACHE.items()) if os.path.realpath(entry[2]) == target]
             started = _release_agents_locked(entries)
@@ -1470,8 +1593,8 @@ def release_profile_agents(home):
 
 
 def _holding_home(target: str) -> bool:
-    with _AGENT_CACHE_LOCK:
-        return any(os.path.realpath(home) == target for _agent, home in _COMMITTING)
+    with _AGENT_CACHE_LOCK, _RUNS_LOCK:
+        return any(os.path.realpath(home) == target for _agent, home in _COMMITTING) or any(run.home == target for run in _COMMAND_RUNS.values())
 
 
 def _acquire_session_db(home):
@@ -1889,28 +2012,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
                 emit("notice_clear", {"key": str(key)})
 
         def ask(data: dict, timeout: int) -> str | None:
-            """Park on a prompt the server relays until it is answered, the turn is cancelled or ends, or ``timeout``
-            passes (``<= 0``: no limit). The answer, or None, goes back to the Agent and is never emitted."""
-            entry = _ClarifyEntry(data)
-            entry.data["clarify_id"] = entry.clarify_id
-            entry.deadline = None if timeout <= 0 else time.monotonic() + float(timeout)
-            with run.lock:
-                run.clarify_entries[entry.clarify_id] = entry
-            emit("clarify", dict(entry.data))
-            while not entry.event.is_set():
-                if run.cancel.is_set() or run.finished.is_set() or (data.get("kind") == "skill_secret" and (ctx.cancelled or run.session_ended)):
-                    break
-                if entry.deadline is None:
-                    entry.event.wait(1.0)
-                    continue
-                remaining = entry.deadline - time.monotonic()
-                if remaining <= 0:
-                    break
-                entry.event.wait(min(1.0, remaining))
-            with run.lock:
-                run.clarify_entries.pop(entry.clarify_id, None)
-            emit("clarify_resolved", {"clarify_id": entry.clarify_id, "session_id": session_id})
-            return entry.result
+            return _ask_clarify(run, data, timeout, emit)
 
         def ask_vault(kind: str, fields: dict) -> str:
             """TAL-887: a password-manager prompt; an empty answer is the Agent's decline, as are expiry and cancel."""
@@ -1966,35 +2068,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
             except Exception:  # noqa: BLE001 - never expose an exception that could include the submitted value
                 return {**skipped, "success": False}
 
-        def clarify_callback(question, choices=None, multi_select=False, questions=None):
-            # TAL-351: remove the legacy signature path when v0.21.6 is the oldest supported Agent.
-            structured = isinstance(question, list)
-            if structured:
-                questions, question = question, ""
-            choices_list = [str(c) for c in (choices or [])]
-            # Predecessor `_clarify_timeout_seconds`: the Agent's own resolver over this profile's config
-            # (``clarify.timeout`` else ``agent.clarify_timeout`` else 3600); ``<= 0`` waits until answered or cancelled.
-            # The advertised ``timeout_seconds`` is what the clients count down, so it is the same number.
-            timeout = _clarify_timeout(params)
-            data = {"question": str(question or ""), "choices_offered": choices_list, "session_id": session_id, "kind": "clarify", "requested_at": time.time(), "timeout_seconds": timeout}
-            if multi_select:
-                data["multi_select"] = True
-            # Batch prompts (the Agent's ``_run_batch``) carry no top-level question and expect the ``{"answers": {...}}`` reply.
-            if isinstance(questions, list) and questions:
-                data["questions"] = questions
-            answer = ask(data, timeout)
-            if answer is not None:
-                if structured:
-                    return {"answers": json.loads(answer)["answers"], "outcome": "submitted"}
-                return answer
-            cancelled = run.cancel.is_set() or run.finished.is_set()
-            if structured:
-                return {"answers": {}, "outcome": "cancelled" if cancelled else "timed_out",
-                        "notice": "The user cancelled the clarification." if cancelled else "The clarification timed out."}
-            # Older tools have no outcome field. A batch understands timed_out; a single needs an empty answer.
-            if questions:
-                return json.dumps({"answers": {}, "timed_out": not cancelled})
-            return ""
+        clarify_callback = _clarify_callback(run, params, emit)
 
         # TAL-818: a ``manage_connections`` card (a hosted connect, an MCP install) opened; the server turns the frame into
         # the chat's connect card, which reads and answers the operation through ``connectors.operation`` / ``respond``.
@@ -2465,10 +2539,18 @@ def refine(params: dict) -> str:
     return f"⚗ Reviewing this conversation in the background{tail} — any memory/skill updates will be reported when done."
 
 
-def _run_for(params: dict) -> _Run | None:
+def _run_for(params: dict, *, include_commands: bool = False) -> _Run | None:
     stream_id = str(params.get("stream_id") or "").strip()
     session_id = str(params.get("session_id") or "").strip()
     with _RUNS_LOCK:
+        clarify_id = str(params.get("clarify_id") or "")
+        home = params.get("profile_home")
+        if include_commands and clarify_id and session_id and home:
+            for run in _COMMAND_RUNS.values():
+                if run.session_id == session_id and run.home == os.path.realpath(home):
+                    with run.lock:
+                        if clarify_id in run.clarify_entries:
+                            return run
         if stream_id:
             return _RUNS.get(stream_id)
         if session_id:
@@ -2619,6 +2701,7 @@ def register(registry) -> None:
         in place."""
         session_id = str(params.get("session_id") or "").strip()
         end_session = params.get("clear_session") is True
+        cancel_command_choices(session_id)
         with _AGENT_CACHE_LOCK:
             with _RUNS_LOCK:
                 run = _RUNS.get(_RUNS_BY_SESSION.get(session_id) or "")
@@ -2775,7 +2858,7 @@ def register(registry) -> None:
     def clarify_respond_(ctx: CallContext, params: dict) -> dict:
         response = str(params.get("response") or "")
         clarify_id = str(params.get("clarify_id") or "").strip()
-        run = _run_for(params)
+        run = _run_for(params, include_commands=True)
         if run is None:
             return {"ok": False}
         if params.get("session_id") and str(params["session_id"]) != run.session_id:
@@ -2786,7 +2869,7 @@ def register(registry) -> None:
             if target is None or target.event.is_set() or (target.deadline is not None and time.monotonic() >= target.deadline):
                 return {"ok": False}
             skill_secret = target.data.get("kind") == "skill_secret"
-            if skill_secret and (not clarify_id or ctx.cancelled or run.ctx.cancelled or run.cancel.is_set() or run.finished.is_set() or run.session_ended):
+            if ctx.cancelled or run.prompt_cancelled(target.data) or (skill_secret and not clarify_id):
                 return {"ok": False}
             # Secure answers are as typed; an empty reply is their decline. Only the first answer releases a waiter.
             secure = str(target.data.get("kind") or "").startswith("vault_") or skill_secret

package/sidecar/talaria_sidecar/methods/commands.py

@@ -239,7 +239,7 @@ def forget_profile_mcp_tools(home) -> None:
         _MCP_DISCOVERED_HOMES.discard(os.path.realpath(home))
 
 
-def _reload_mcp() -> str:
+def _reload_mcp(*, log_errors=True) -> str:
     with _RELOAD_MCP_LOCK:
         try:
             from agent.secret_scope import is_multiplex_active
@@ -274,7 +274,8 @@ def _reload_mcp() -> str:
                 with _lock:
                     tools = [name for name in tools if _mcp_tool_server_names.get(name) in connected]
         except Exception as exc:  # noqa: BLE001
-            log.warning("Failed to reload MCP servers", exc_info=True)
+            if log_errors:
+                log.warning("Failed to reload MCP servers", exc_info=True)
             raise RpcError("Failed to reload MCP servers", condition="mcp_reload_failed") from exc
     added, removed, reconnected = connected - old, old - connected, connected & old
     lines = ["Reloaded MCP servers from configuration."]
@@ -846,11 +847,12 @@ def register(registry) -> None:
             output = execute_agent_command(command, session_id, workspace)
             source = "agent"
             if output is None:
-                from .chat import _turn_identity
+                from .chat import _turn_identity, command_choices
 
                 # TAL-904: a chat's plugin command runs under that chat's session and workspace, as its turns do.
-                with _turn_identity(session_id, workspace) if session_id else contextlib.nullcontext():
+                with command_choices(ctx, params), (_turn_identity(session_id, workspace) if session_id else contextlib.nullcontext()):
                     output = execute_plugin_command(command, session_id)
+                ctx.check_cancelled()
                 source = "plugin"
         if output is None:
             raise RpcError(f"unknown command {parse_slash_command(command)[0]!r}", condition="command_not_found")

package/sidecar/talaria_sidecar/methods/config.py

@@ -133,9 +133,8 @@ def _split_config_aliases(text: str, desired: dict) -> str:
     return output.getvalue()
 
 
-def write_config(path: Path, config: dict, *, profile_home: Path | None = None) -> dict:
-    if not isinstance(config, dict):
-        raise InvalidParams("config must be an object")
+def assert_config_writable(profile_home: Path | None = None) -> None:
+    """Verify the owning profile policy before any config publication; uncertainty refuses."""
     try:
         managed = importlib.import_module("hermes_constants").get_managed_system(profile_home)
     except Exception as exc:  # noqa: BLE001
@@ -144,6 +143,12 @@ def write_config(path: Path, config: dict, *, profile_home: Path | None = None)
     if managed is not None:
         raise RpcError("config.yaml is package-managed. Update the declarative configuration instead.",
                        condition="config_write_refused")
+
+
+def write_config(path: Path, config: dict, *, profile_home: Path | None = None) -> dict:
+    if not isinstance(config, dict):
+        raise InvalidParams("config must be an object")
+    assert_config_writable(profile_home)
     target = _write_target(path)
     target.parent.mkdir(parents=True, exist_ok=True)
     try:

package/sidecar/talaria_sidecar/methods/connectors.py

@@ -8,10 +8,13 @@ registers its session operation here through ``remember_chat_operation``. Every
 
 from __future__ import annotations
 
+import contextvars
+import hashlib
 import inspect
 import json
 import logging
 import threading
+import uuid
 from collections import OrderedDict
 from pathlib import Path
 from types import SimpleNamespace
@@ -130,11 +133,46 @@ def accounts() -> dict:
     client = _portal()
     if not _authenticated(client):
         return {"accounts": []}
+    rows = client.list_accounts()
+    try:
+        from hermes_cli.free_tier_offer import note_connected_apps_seen
+        note_connected_apps_seen([{"connected": row.get("active") is True and not row.get("disabled")} for row in rows])
+    except ImportError:
+        pass  # older Agents have no connector offer
+    except Exception:
+        log.warning("connector sighting unavailable")
     return {"accounts": [{
         "connection_id": row["connectionId"], "connector": row["connector"], "status": row["status"],
         "status_reason": row.get("statusReason"), "label": row["label"], "alias": row.get("alias"),
         "active": bool(row["active"]), "disabled": bool(row.get("disabled")), "created_at": row["createdAt"],
-    } for row in client.list_accounts()]}
+    } for row in rows]}
+
+
+def sign_in_offer(home: Path, claim_guest: str | None = None) -> dict:
+    """Native policy and CAS only. The server owns retention of the delivered page result."""
+    result = {"available": False, "guest_id": None, "eligible": False, "due_in": None, "claimed": False}
+    try:
+        from hermes_cli import anon_auth, free_tier_offer as native
+        if not all(callable(getattr(native, name, None)) for name in ("_eligible", "offer_due_in", "claim_offer")):
+            return result
+
+        def identity():
+            state = anon_auth.current_nous_state()
+            token = state.get("anon_token") if anon_auth.is_guest_state(state) else None
+            return hashlib.sha256(f"{home.resolve()}\0{token}".encode()).hexdigest() if isinstance(token, str) and token else None
+
+        guest = identity()
+        result["guest_id"] = guest
+        eligible = bool(native._eligible(native.CONNECTOR))
+        due = native.offer_due_in(native.CONNECTOR)
+        claimed = bool(guest and guest == claim_guest and native.claim_offer(native.CONNECTOR)) if claim_guest else False
+        if identity() != guest:
+            return {**result, "guest_id": None}
+        return {"available": True, "guest_id": guest, "eligible": eligible, "due_in": due, "claimed": claimed}
+    except ImportError:
+        return result
+    except Exception:
+        return result  # retain a proven identity, never raw auth or native error details
 
 
 def remove(connection_id: str) -> dict:
@@ -201,6 +239,14 @@ def _operation(home: Path, op_id: str):
         operation = _OPS.get((str(home), op_id))
     if operation is None:
         raise RpcError("No connection operation with that id.", condition="operation_not_found")
+    account_id = getattr(operation, "_talaria_nous_account_id", None)
+    if account_id:
+        from . import nous_account
+        current = nous_account.read(home)
+        if not current or current["account_id"] != account_id:
+            from tools.connectors.contract import SettleReason
+            operation.settle(SettleReason.interrupt)
+            raise RpcError("No connection operation for the current account.", condition="operation_not_found")
     return operation
 
 
@@ -226,8 +272,62 @@ def operation_view(operation) -> dict:
     }
 
 
-def connect(home: Path, connector: str) -> dict:
+def _reconnect(home: Path, connector: str, account_id: str) -> dict:
+    """Compose the existing native operation with an account-fenced, noncreating client.
+
+    Native account.find_or_start_operation always uses a creating, live-credential client
+    in its later thread. Its lifecycle primitives accept the client this result needs.
+    """
+    from tools.connectors import account, live, managed
+    from tools.connectors.gateway.client import ConnectorClient
+    from tools.connectors.operation import ConnectionOperation, Target
+    from tools.connectors.run import drive_operation
+    from tools.connectors.contract import SettleReason
+    from . import nous_account
+
+    with account._start_lock:
+        existing = live.find_target(connector, profile_home=str(home))
+        if existing is not None:
+            if getattr(existing, "_talaria_nous_account_id", None) != account_id:
+                raise RpcError("Finish the current app connection before reconnecting this result.", condition="operation_refused")
+            _remember(home, existing)
+            return operation_view(_operation(home, existing.op_id))
+        client = ConnectorClient(initiator="desktop_page", header_provider=lambda url: nous_account.connector_headers(home, account_id, url))
+        operation = ConnectionOperation([Target(connector, "connector", "connect")], session_key=f"account:{uuid.uuid4().hex}")
+        operation._talaria_nous_account_id = account_id
+        operation._talaria_nous_client = client
+        start = account.AccountOperationStart(operation=operation, started=True)
+        context = contextvars.copy_context()
+
+        def run():
+            try:
+                drive_operation(operation, managed.managed_kind(client, "connect", force=False),
+                                connection_callback=lambda payload: start.done.set(),
+                                tick_seconds=managed.WATCH_TICK_SECONDS, with_urls_in_result=False)
+            except Exception:
+                start.failed = True
+                operation.settle(SettleReason.interrupt)
+            finally:
+                live.close(operation)
+                start.done.set()
+
+        live.open(operation)
+        _remember(home, operation)
+        try:
+            threading.Thread(target=lambda: context.run(run), daemon=True, name="connector-account-operation").start()
+        except Exception:
+            live.close(operation)
+            operation.settle(SettleReason.interrupt)
+            raise
+    if account.wait_for_prepare(start) and start.failed:
+        raise RpcError("Connector request failed.", condition="connectors_failed")
+    return operation_view(_operation(home, operation.op_id))
+
+
+def connect(home: Path, connector: str, *, account_id: str | None = None) -> dict:
     """Start (or rejoin) the account-owned connect for ``connector`` and wait for its authorization link."""
+    if account_id is not None:
+        return _reconnect(home, connector, account_id)
     from tools.connectors import account
     from tools.connectors.contract import TargetState
     from tools.connectors.run import reissue
@@ -236,8 +336,11 @@ def connect(home: Path, connector: str) -> dict:
     page = {"initiator": "desktop_page"} if "initiator" in inspect.signature(account.find_or_start_operation).parameters else {}
     start = account.find_or_start_operation([connector], action="connect", profile_home=str(home), **page)
     _remember(home, start.operation)
+    _operation(home, start.operation.op_id)
     if not start.started:
         target = start.operation.target(connector)
+        if target is not None and target.state in (TargetState.failed, TargetState.expired) and getattr(start.operation, "_talaria_nous_client", None) is not None:
+            return respond(home, start.operation.op_id, "retry", connector, {})
         if target is not None and target.state in (TargetState.failed, TargetState.expired) and reissue(start.operation, [connector], **page):
             raise RpcError("This connection cannot be started again.", condition="operation_refused")
         return operation_view(start.operation)
@@ -262,7 +365,14 @@ def respond(home: Path, op_id: str, action: str, target: str | None, env: dict)
         if action == "continue":
             apply_answer(operation, json.dumps({"settled_by": SettleReason.continue_.value}))
         elif action == "retry" and row.kind == "connector":
-            if reissue(operation, [row.name]):
+            client = getattr(operation, "_talaria_nous_client", None)
+            if client is not None:
+                from tools.connectors.managed import mint
+                from tools.connectors.contract import Actor, TargetState
+                if row.state not in (TargetState.failed, TargetState.expired):
+                    raise RpcError("This target cannot be run again.", condition="operation_refused")
+                mint(client, operation, [row.name], reinitiate=True, actor=Actor.user)
+            elif reissue(operation, [row.name]):
                 raise RpcError("This target cannot be run again.", condition="operation_refused")
         else:
             status = "skipped" if action == "skip" else "approved"
@@ -288,6 +398,21 @@ def remember_chat_operation(home: Path, payload: dict) -> dict | None:
 
 
 def register(registry_) -> None:
+    @registry_.method("connectors.offer.status")
+    def offer_status_(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        with scoped_home(home):
+            return sign_in_offer(home)
+
+    @registry_.method("connectors.offer.claim")
+    def offer_claim_(ctx: CallContext, params: dict) -> dict:
+        guest = params.get("guest_id")
+        if not isinstance(guest, str) or not guest:
+            raise InvalidParams("guest_id is required")
+        home = profile_home_param(params)
+        with scoped_home(home):
+            return sign_in_offer(home, guest)
+
     def page(params: dict, read, *, creates_guest: bool = False):
         with scoped_home(profile_home_param(params)):
             _open(creates_guest=creates_guest)
@@ -346,7 +471,16 @@ def register(registry_) -> None:
     def connect_(ctx: CallContext, params: dict) -> dict:
         slug = _slug(params)
         home = profile_home_param(params)
-        return page(params, lambda: connect(home, slug), creates_guest=True)
+        def begin():
+            if "nous_account_id" in params:
+                from . import nous_account
+                view = nous_account.read(home)
+                if not view or view["account_id"] != params["nous_account_id"] or slug not in view["reconnect"]:
+                    raise RpcError("The signed-in account or reconnect result changed. Refresh before reconnecting.", condition="connectors_forbidden")
+                if not any(row["slug"] == slug for row in catalog()["connectors"]):
+                    raise RpcError("This app is not available to reconnect.", condition="connectors_forbidden")
+            return connect(home, slug, account_id=params.get("nous_account_id"))
+        return page(params, begin, creates_guest="nous_account_id" not in params)
 
     def gated() -> None:
         # Reads and moves on an operation pass the availability gate too, without creating an identity.

package/sidecar/talaria_sidecar/methods/dashboard_plugins.py

@@ -190,6 +190,27 @@ def _plugins(home):
     return out
 
 
+def reviewed_producer(home, name, pin, sources):
+    """Verify a store adapter's native registration, profile consent and reviewed bytes without loading it."""
+    try:
+        from hermes_cli import plugins_cmd as pc
+        metadata = pc._read_install_metadata()
+        for plugin in _plugins(home):
+            if plugin['name'] != name or not plugin['enabled'] or plugin.get('source') != 'user':
+                continue
+            root, anchor = Path(plugin['_dir']).parent, Path(plugin['_asset_anchor'])
+            record = metadata.get(root.name, {})
+            catalog = record.get('catalog', {})
+            if catalog.get('name') != name or catalog.get('sha') != pin or record.get('revision') != pin:
+                continue
+            if all((body := _read(root, file, anchor=anchor)) is not None
+                   and hashlib.sha256(body).hexdigest() == digest for file, digest in sources.items()):
+                return pin
+    except (ImportError, AttributeError, OSError, ValueError, TypeError):
+        pass
+    return None
+
+
 def _named(home, name, *, require_panel=True):
     return next((p for p in _plugins(home) if p['name'] == name and p['enabled'] and (p['panel'] if require_panel else p.get('_api_file'))), None)