@agentsdock/server 1.0.7-beta.5 → 1.0.8

package/server/agentsdock_chats.py

@@ -1096,7 +1096,8 @@ def parser() -> argparse.ArgumentParser:
     command.set_defaults(handler=send)
     ask_command = commands.add_parser(
         "ask",
-        help="ask a same-server agent and wait until it answers or is stopped",
+        help=("send one request; async_route_v1 returns a durable delivery receipt without waiting for a reply; "
+              "legacy routes wait until answered or stopped"),
         allow_abbrev=False,
     )
     ask_destination = ask_command.add_mutually_exclusive_group(required=True)

package/server/chat_mailbox.py

@@ -103,23 +103,37 @@ _VALID = """m.excluded_at IS NULL AND e.status='stored' AND e.delivery_mode='mai
     AND e.source_session_id=m.source_session_id AND e.target_session_id=m.target_session_id
     AND e.authorization_pair_id=m.pair_id"""
 _COLUMNS = """m.*, e.body AS original_body, e.target_body, e.message_revision, e.created_at,
-    e.source_user_instruction"""
+    e.source_run_id, e.source_user_instruction, e.source_user_delegation_action"""
 
 
 def _message(row: sqlite3.Row) -> dict:
     edited = row["message_revision"] > 0 and isinstance(row["target_body"], str)
-    return {
+    message = {
         "message_id": row["message_id"], "mailbox_seq": row["mailbox_seq"],
         "source_session_id": row["source_session_id"], "target_session_id": row["target_session_id"],
         "conversation_id": row["pair_id"],
         "body": row["target_body"] if edited else row["original_body"],
-        "source_user_instruction": row["source_user_instruction"] or "",
         "created_at": row["created_at"], "stored_at": row["stored_at"],
         "in_reply_to_message_id": row["in_reply_to_message_id"],
         "read_id": row["read_id"], "read_at": row["read_at"],
         "message_revision": row["message_revision"] if edited else 0,
         "message_edited_by_user": edited,
     }
+    if (row["source_user_delegation_action"] in ("route", "instruction", "request_reply")
+            and isinstance(row["source_user_instruction"], str) and row["source_user_instruction"].strip()
+            and row["message_revision"] == 0):
+        # Only the server's immutable admission marker can attest user origin.
+        # An edited body is no longer the originally delegated handoff. Keep
+        # it readable, but do not let it inherit the original attestation.
+        message["user_delegation"] = {
+            "version": 1,
+            "source_session_id": row["source_session_id"],
+            "source_run_id": row["source_run_id"],
+            "target_session_id": row["target_session_id"],
+            "reference_action": row["source_user_delegation_action"],
+            "source_user_instruction": row["source_user_instruction"],
+        }
+    return message
 
 
 def store_message(connection: sqlite3.Connection, message_id: str, *, now: str,
@@ -158,10 +172,13 @@ def store_message(connection: sqlite3.Connection, message_id: str, *, now: str,
             or row["in_reply_to_message_id"] != parent):
         raise MailboxConflict("Stored mailbox identity changed")
     message = _message(row)
-    # Reject before the caller commits, rather than accepting mail that no
-    # bounded read can deliver. Include the metadata added on its first read.
+    # Include all provenance in the same bounded response before accepting.
     readable = {**message, "read_id": "mailread_" + "0" * 32, "read_at": now}
-    if 8192 + len(json.dumps(readable, ensure_ascii=False, separators=(",", ":")).encode("utf-8")) > MAX_PAGE_BYTES:
+    try:
+        size = len(json.dumps(readable, ensure_ascii=False, separators=(",", ":")).encode("utf-8"))
+    except UnicodeEncodeError as exc:
+        raise MailboxConflict("Message and user delegation must be valid UTF-8") from exc
+    if 8192 + size > MAX_PAGE_BYTES:
         raise MailboxConflict("Message and source user instruction exceed the bounded mailbox response")
     return message
 

package/server/claude_history_repair.py

@@ -23,6 +23,7 @@ from typing import Callable
 
 from claude_history_provenance import ClaudeInterruptionTracker
 from claude_goals import ClaudeGoalHistoryNormalizer, is_claude_synthetic_no_response
+from claude_sdk_client import CLAUDE_SDK_LITERAL_MESSAGE_PREFIX
 
 
 MAX_BYTES = 96 * 1024 * 1024
@@ -165,6 +166,7 @@ class _AssistantReplays:
         self.candidates, self.sources, self.identities, self.source_credits = [], {}, {}, {}
         self.source_display, self.source_message_counts = {}, {}
         self.source_parents, self.source_users, self.source_input = OrderedDict(), {}, {}
+        self.source_commands, self.local_command_prompts = {}, {}
 
     def display_key(self, text: str) -> str | None:
         if self.normalize_assistant is None:
@@ -211,13 +213,33 @@ class _AssistantReplays:
         tool_result = isinstance(content, list) and any(isinstance(part, dict) and part.get("type") == "tool_result" for part in content)
         if event.get("type") == "user" and event.get("isMeta") is not True and text.strip() and not tool_result:
             self.source_users.setdefault(identity, []).append((offset, _text_key(text.strip())))
+            command = re.fullmatch(
+                r"<command-name>/([A-Za-z0-9_][A-Za-z0-9_.:-]{0,127})</command-name>\s*"
+                r"<command-message>\1</command-message>\s*<command-args>([\s\S]*)</command-args>",
+                text.strip(),
+            )
+            if command is not None:
+                self.source_commands[identity] = command.groups()
             parent_input = identity
         self.source_parents[identity[0]] = parent_input
         while len(self.source_parents) > 256:
             self.source_parents.popitem(last=False)
         if len(self.source_users) > MAX_KEYS:
             raise _Unproven()
-        if event.get("type") != "assistant":
+        local_output = None
+        if event.get("type") == "system" and event.get("subtype") == "local_command":
+            command = event.get("commandRun")
+            output = event.get("content")
+            wrapper = self.source_commands.get(parent_input)
+            if (not isinstance(command, dict) or wrapper is None
+                    or wrapper != (command.get("command"), command.get("args"))
+                    or not isinstance(output, str)):
+                return
+            local_output = re.fullmatch(r"<local-command-stdout>([\s\S]*)</local-command-stdout>", output)
+            if local_output is None:
+                return
+            self.local_command_prompts[identity] = "/" + wrapper[0] + (" " + wrapper[1] if wrapper[1] else "")
+        elif event.get("type") != "assistant":
             return
         if parent_input is not None:
             self.source_input[identity] = parent_input
@@ -229,7 +251,9 @@ class _AssistantReplays:
         content = message.get("content") if isinstance(message, dict) else None
         # Only public text blocks. Thinking/tool payloads cannot establish a
         # public replay, even if their wording happens to match another row.
-        if isinstance(content, str):
+        if local_output is not None:
+            text = local_output[1]
+        elif isinstance(content, str):
             text = content
         elif isinstance(content, list):
             text = "\n".join(block["text"] for block in content if isinstance(block, dict)
@@ -270,7 +294,21 @@ class _AssistantReplays:
             assistants.add((identity, digest))
             source_input = self.source_input.get(identity)
             inputs = self.source_users.get(source_input, ())
-            if len(inputs) == 1 and isinstance(matches[0], str) and inputs[0][1] == _text_key(matches[0].strip()):
+            expected_inputs = set()
+            if isinstance(matches[0], str):
+                expected_inputs.add(_text_key(matches[0].strip()))
+                if re.sub(r"^[\s\ufeff]+", "", matches[0]).startswith("/"):
+                    # Older transports prepended this exact sentence. The
+                    # native assistant UUID and source ancestry above prove
+                    # which immutable user prompt owns this imported copy.
+                    # Never strip matching prose from an unowned user quote.
+                    expected_inputs.add(_text_key(
+                        (CLAUDE_SDK_LITERAL_MESSAGE_PREFIX + matches[0]).strip()))
+            # A native local-command result owns its XML input only when the
+            # commandRun metadata, source wrapper and original prompt agree.
+            command_match = (identity in self.local_command_prompts
+                             and self.local_command_prompts[identity] == matches[0])
+            if len(inputs) == 1 and (inputs[0][1] in expected_inputs or command_match):
                 users.add((source_input, inputs[0][1], inputs[0][0]))
         return assistants, users
 
@@ -1288,6 +1326,7 @@ def _prove_recent_scheduled(session_id: str, provider_id: str, events: Path, roo
         if len(identity_counts) + len(source_matches) > MAX_KEYS:
             raise _Unproven()
     targets, counts = set(), {}
+    _owned_assistants, owned_inputs = assistant_replays.exact_owned_sources()
     for target, identity in candidates:
         seq, run, key = target
         batch, matched = eligible.get(run), source_matches.get((identity, key), ())
@@ -1299,7 +1338,9 @@ def _prove_recent_scheduled(session_id: str, provider_id: str, events: Path, roo
         proven_metadata = len(metadata) == 1 and start < metadata[0] <= end
         proven_scheduled = (len(matched) == 1 and occurrence_counts.get(matched[0][1]) == 1
                             and start < matched[0][0] <= end)
-        if first < seq < last and (proven_metadata or proven_scheduled):
+        proven_owned_input = any(source == identity and digest == key and start < offset <= end
+                                 for source, digest, offset in owned_inputs)
+        if first < seq < last and (proven_metadata or proven_scheduled or proven_owned_input):
             targets.add(target)
             counts[run] = counts.get(run, 0) + 1
     targets.update(async_inputs.prove(eligible))

package/server/claude_model_catalog.py

@@ -0,0 +1,200 @@
+"""Passive Claude model metadata from real SDK connections.
+
+Catalog reads never start a CLI, renew credentials, or terminate a process.
+Only bounded model IDs/labels are retained; account/command data is discarded.
+"""
+from __future__ import annotations
+
+from collections import OrderedDict
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import threading
+import time
+import unicodedata
+from typing import Any
+
+MAX_MODELS = 512
+MODEL_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:/\-\[\]]{0,255}")
+VERSIONED_ID = re.compile(
+    r"claude-([a-z][a-z0-9]*)-(\d+(?:-\d{1,2})*)(?:-\d{8})?(\[[a-z0-9]+\])?"
+)
+NATIVE_DESCRIPTION = re.compile(
+    r"(?:Claude )?((?:Opus|Sonnet|Haiku|Fable|Mythos) \d+(?:\.\d+)*)"
+    r"(?: with (\w+) context)?(?:\s*[·|—]|$)"
+)
+class ClaudeModelCatalogUnavailable(RuntimeError):
+    """A metadata probe failed; never include provider output in this error."""
+
+
+def _safe_label(value: Any) -> str:
+    if not isinstance(value, str) or not value or len(value) > 160:
+        return ""
+    if any(unicodedata.category(char).startswith("C") for char in value):
+        return ""
+    return value.strip()
+
+
+def _model_label(model: dict[str, Any], value: str) -> str:
+    display = _safe_label(model.get("displayName")) or value[:160]
+    # New CLI versions identify the alias target explicitly. Do not guess it
+    # from the CLI's version, the newest website announcement, or our fallback.
+    resolved = model.get("resolvedModel")
+    matched = VERSIONED_ID.fullmatch(resolved) if isinstance(resolved, str) and len(resolved) <= 256 else None
+    if matched:
+        family, version, context = matched.groups()
+        label = f"{family.capitalize()} {version.replace('-', '.')}"
+        if context or value.endswith("[1m]"):
+            label += f" ({(context or '[1m]')[1:-1].upper()} context)"
+    elif not resolved:
+        # Older SDK initialize responses expose the version only in the
+        # picker description. Accept its leading native model name, not prose
+        # mentioning an unrelated model or arbitrary numbers in custom names.
+        description = model.get("description")
+        match = NATIVE_DESCRIPTION.match(description) if isinstance(description, str) and len(description) <= 800 else None
+        if match:
+            label = match[1]
+            if match[2] or value.endswith("[1m]"):
+                label += f" ({(match[2] or '1M').upper()} context)"
+        else:
+            label = display
+    else:
+        # Gateway deployment IDs are opaque: retain the provider's display
+        # name rather than inventing an Anthropic version for them.
+        label = display
+    if value == "default" and label != display:
+        label = f"Default — {label}"
+    return _safe_label(label) or display
+
+
+def parse_native_models(info: Any) -> list[dict[str, str]]:
+    if not isinstance(info, dict) or not isinstance(info.get("models"), list):
+        raise ClaudeModelCatalogUnavailable("Native model metadata is unavailable")
+    models = info["models"]
+    if len(models) > MAX_MODELS:
+        raise ClaudeModelCatalogUnavailable("Native model metadata exceeds its limit")
+    options: list[dict[str, str]] = []
+    seen: set[str] = set()
+    for model in models:
+        if not isinstance(model, dict):
+            continue
+        value = model.get("value")
+        if not isinstance(value, str) or not MODEL_ID.fullmatch(value) or value in seen:
+            continue
+        seen.add(value)
+        # Never replace an alias with its resolved ID: that would pin new
+        # chats to today's version instead of following native updates.
+        if model.get("disabled") is not True:
+            options.append({"value": value, "label": _model_label(model, value)})
+    if models and not seen:
+        raise ClaudeModelCatalogUnavailable("Native model metadata is invalid")
+    return options
+
+
+
+CACHE_TTL_SECONDS = 300.0
+CACHE_LIMIT = 16
+_CACHE_LOCK = threading.Lock()
+_CACHE: OrderedDict[str, tuple[float, list[dict[str, str]]]] = OrderedDict()
+
+
+def _file_revision(path: Path) -> tuple:
+    try:
+        stat = path.stat()
+        return (str(path.resolve()), stat.st_dev, stat.st_ino, stat.st_size, stat.st_mtime_ns)
+    except FileNotFoundError:
+        return (str(path.absolute()), None)
+
+
+def _account_identity(config: Path, home: Path) -> list:
+    # Claude writes counters and picker caches to .claude.json on every
+    # startup. Its mtime is not a settings revision. Only fingerprint the
+    # account identity; never retain email, tokens or the whole document.
+    paths = {home / ".claude.json", config / ".claude.json"}
+    result = []
+    for path in sorted(paths):
+        try:
+            with path.open("rb") as stream:
+                raw = stream.read(2 * 1024 * 1024 + 1)
+            if len(raw) > 2 * 1024 * 1024:
+                raise ValueError("Native identity metadata exceeds its limit")
+            value = json.loads(raw)
+        except FileNotFoundError:
+            value = {}
+        account = value.get("oauthAccount", {}) if isinstance(value, dict) else {}
+        result.append([str(path), *(
+            str(account.get(field) or "")[:256] if isinstance(account, dict) else ""
+            for field in ("accountUuid", "organizationUuid")
+        )])
+    return result
+
+
+def native_catalog_key(executable: str, env: dict[str, str]) -> str:
+    """Fingerprint runtime/config identity without reading native credentials.
+
+    Environment credentials are hashed, never retained in plaintext. Native
+    credential rotation alone is not evidence of login or logout; this cache
+    is short lived and is never used as authentication/authorization evidence.
+    """
+    home = Path(env.get("HOME") or str(Path.home()))
+    config = Path(env.get("CLAUDE_CONFIG_DIR") or home / ".claude")
+    relevant = {key: value for key, value in env.items()
+                if key.startswith(("ANTHROPIC_", "CLAUDE_")) or key == "HOME"}
+    resolved = shutil.which(executable, path=env.get("PATH")) or executable
+    revisions = [_file_revision(Path(resolved)), *(
+        _file_revision(path) for path in (
+            config / "settings.json", config / ".credentials.json",
+            Path("/Library/Application Support/ClaudeCode/managed-settings.json"),
+            Path("/etc/claude-code/managed-settings.json"),
+        )
+    )]
+    return hashlib.sha256(json.dumps([relevant, revisions, _account_identity(config, home)], sort_keys=True).encode()).hexdigest()
+
+
+def _has_project_settings(cwd: str, env: dict[str, str]) -> bool:
+    """Do not promote a workspace-specific picker to the server-wide catalog."""
+    root = Path(cwd).resolve()
+    config = Path(env.get("CLAUDE_CONFIG_DIR") or Path(env.get("HOME") or str(Path.home())) / ".claude").resolve()
+    for parent in (root, *root.parents):
+        folder = parent / ".claude"
+        for name in ("settings.json", "settings.local.json"):
+            path = folder / name
+            if name == "settings.json" and folder.resolve() == config:
+                continue  # This is the fingerprinted user config, not project config.
+            if path.exists():
+                return True
+    return False
+
+
+def remember_native_models(info: Any, *, key: str, executable: str,
+                           env: dict[str, str], cwd: str) -> None:
+    # Recheck the pre-connect revision: a slow/old connection must not publish
+    # a model list under a newer CLI, provider, or user-settings configuration.
+    if key != native_catalog_key(executable, env) or _has_project_settings(cwd, env):
+        return
+    models = parse_native_models(info)
+    with _CACHE_LOCK:
+        _CACHE[key] = (time.monotonic(), models)
+        _CACHE.move_to_end(key)
+        while len(_CACHE) > CACHE_LIMIT:
+            _CACHE.popitem(last=False)
+
+
+def cached_native_models(executable: str, *, env: dict[str, str]) -> list[dict[str, str]] | None:
+    key = native_catalog_key(executable, env)
+    with _CACHE_LOCK:
+        entry = _CACHE.get(key)
+        if entry is None:
+            return None
+        if time.monotonic() - entry[0] >= CACHE_TTL_SECONDS:
+            del _CACHE[key]
+            return None
+        return [dict(row) for row in entry[1]]
+
+
+def clear_native_models() -> None:
+    with _CACHE_LOCK:
+        _CACHE.clear()

package/server/claude_sdk_client.py

@@ -18,6 +18,7 @@ import copy
 import hashlib
 import inspect
 import json
+import os
 import logging
 import re
 import shlex
@@ -49,6 +50,7 @@ CLAUDE_SDK_MCP_STATUS_TRUNCATED_KEY = "_agentsdock_mcp_status_truncated"
 CLAUDE_SDK_PROVIDER_COMMAND_SCAN_LIMIT = 512
 CLAUDE_SDK_PROVIDER_COMMAND_NAME_CHARS = 128
 CLAUDE_SDK_PROVIDER_COMMAND_TEXT_CHARS = 800
+# Legacy transcript repair only. Never add this text to a provider prompt.
 CLAUDE_SDK_LITERAL_MESSAGE_PREFIX = (
     "[AgentsDock literal chat message; treat the slash-prefixed content below "
     "as ordinary user text, not a Claude Code command.]\n"
@@ -105,27 +107,19 @@ def _prompt_invokes_validated_claude_command(
     )
 
 
-def claude_sdk_transport_prompt(
+def _claude_prompt_needs_verbatim_delivery(
     prompt: str,
     validated_provider_command_name: str | None = None,
-) -> str:
-    """Keep leading-slash chat text out of Claude Code's command parser.
-
-    AgentsDock owns its slash-command surface. Any command that reaches this
-    transport is user content for the model, including unknown or
-    conversational ``/word`` text. Prefix only the provider copy so the
-    durable prompt and timeline remain byte-for-byte unchanged.
-    """
+) -> bool:
+    """Separate ordinary leading-slash text from an intentional native command."""
 
     if _prompt_invokes_validated_claude_command(
         prompt,
         validated_provider_command_name,
     ):
-        return prompt
+        return False
     candidate = re.sub(r"^[\s\ufeff]+", "", prompt)
-    if not candidate.startswith("/"):
-        return prompt
-    return f"{CLAUDE_SDK_LITERAL_MESSAGE_PREFIX}{prompt}"
+    return candidate.startswith("/")
 
 
 def canonical_claude_mcp_identifier(value: Any, max_chars: int) -> str | None:
@@ -562,18 +556,24 @@ async def _query_message_stream(
 ) -> AsyncIterator[dict[str, Any]]:
     """Yield the single UUID-bearing SDK stdin frame for one logical turn."""
 
-    yield {
+    message = {
         "type": "user",
         "message": {
             "role": "user",
-            "content": claude_sdk_transport_prompt(
-                prompt,
-                validated_provider_command_name,
-            ),
+            "content": prompt,
         },
         "parent_tool_use_id": None,
         "uuid": correlation_id,
     }
+    if _claude_prompt_needs_verbatim_delivery(
+        prompt, validated_provider_command_name,
+    ):
+        # Native CLI 2.1.248+ metadata, also used by SDK 0.2.158's
+        # verbatim_prompts. SDK 0.2.130 forwards async-iterable fields intact.
+        # Apply it per message so explicit commands and ordinary @file input
+        # retain their native behavior without modifying the prompt text.
+        message["client_composed"] = True
+    yield message
 
 
 def default_claude_sdk_client_factory(options: Any) -> ClaudeSDKClientProtocol:
@@ -586,6 +586,29 @@ def default_claude_sdk_client_factory(options: Any) -> ClaudeSDKClientProtocol:
             "claude-agent-sdk is not installed; use the claude -p fallback"
         ) from exc
     class GoalAwareClaudeSDKClient(ClaudeSDKClient):
+        async def connect(self, prompt=None) -> None:
+            from claude_model_catalog import native_catalog_key, remember_native_models
+
+            # Read metadata already produced by this real connection. Never
+            # open a second connection merely to populate a model picker.
+            env = {**os.environ, **(getattr(options, "env", None) or {})}
+            executable = str(getattr(options, "cli_path", None) or "claude")
+            cwd = str(getattr(options, "cwd", None) or os.getcwd())
+            key = None
+            try:
+                key = native_catalog_key(executable, env)
+            except (OSError, ValueError):
+                pass  # Optional metadata must not block actual work.
+            await super().connect(prompt)
+            if key is not None:
+                try:
+                    # Pinned SDK get_server_info returns its cached initialize
+                    # response; it sends no control request or model prompt.
+                    info = await super().get_server_info()
+                    remember_native_models(info, key=key, executable=executable, env=env, cwd=cwd)
+                except Exception:
+                    pass  # Do not log raw initialization/account data.
+
         async def receive_messages(self) -> AsyncIterator[Any]:
             # SDK 0.2.130 drops local-command provenance and active_goal. Keep
             # those native fields without changing parsing of normal messages.
@@ -1348,6 +1371,7 @@ class ClaudeSDKSupervisor:
         ack_timeout_seconds: float = 60.0,
         query_delivery_timeout_seconds: float = 10.0,
         control_timeout_seconds: float = 15.0,
+        usage_observer: Callable[[str, str, Any], Awaitable[None]] | None = None,
     ) -> None:
         clean_chat_id = str(chat_id or "").strip()
         if not clean_chat_id:
@@ -1359,6 +1383,7 @@ class ClaudeSDKSupervisor:
         bind_permission_owner(self.options, self.ownership_token)
         self._client_factory = client_factory
         self._is_result_message = is_result_message
+        self._usage_observer = usage_observer
         if connect_timeout_seconds <= 0:
             raise ValueError("connect_timeout_seconds must be positive")
         self._connect_timeout_seconds = float(connect_timeout_seconds)
@@ -2117,10 +2142,7 @@ class ClaudeSDKSupervisor:
                 provider_id = self.options.get("resume") if isinstance(self.options, dict) else getattr(self.options, "resume", None)
             background_hook.bind(
                 handle,
-                claude_sdk_transport_prompt(
-                    command.prompt,
-                    command.validated_provider_command_name,
-                ),
+                command.prompt,
                 _receipt_field(provider_id),
                 lambda: self._active_run is handle and not self._closed
                 and self._background_reconciliation_hook is background_hook,
@@ -2692,6 +2714,14 @@ class ClaudeSDKSupervisor:
     async def _handle_received(self, command: _ReceivedMessage) -> None:
         if command.generation != self._generation:
             return
+        if _message_type(command.message) in {"ratelimitevent", "rate_limit_event"} and self._usage_observer is not None:
+            generation = self.control_generation
+            if generation is not None:
+                try:
+                    await self._usage_observer(self.chat_id, generation, command.message)
+                except Exception:
+                    logger.debug("Claude usage observer unavailable")
+            return
         pending = self._pending_goal_clear
         if pending is not None:
             local_run = _message_field(command.message, "local_command_run")
@@ -2924,6 +2954,7 @@ class ClaudeSDKSupervisorManager:
         ack_timeout_seconds: float = 60.0,
         query_delivery_timeout_seconds: float = 10.0,
         control_timeout_seconds: float = 15.0,
+        usage_observer: Callable[[str, str, Any], Awaitable[None]] | None = None,
     ) -> None:
         if max_clients < 1:
             raise ValueError("max_clients must be positive")
@@ -2931,6 +2962,7 @@ class ClaudeSDKSupervisorManager:
             raise ValueError("idle_ttl_seconds must be non-negative or None")
         self._client_factory = client_factory
         self._is_result_message = is_result_message
+        self._usage_observer = usage_observer
         self._max_clients = int(max_clients)
         self._idle_ttl_seconds = idle_ttl_seconds
         if connect_timeout_seconds <= 0:
@@ -3043,6 +3075,7 @@ class ClaudeSDKSupervisorManager:
                 ack_timeout_seconds=self._ack_timeout_seconds,
                 query_delivery_timeout_seconds=self._query_delivery_timeout_seconds,
                 control_timeout_seconds=self._control_timeout_seconds,
+                usage_observer=self._usage_observer,
             )
             self._supervisors[chat_id] = supervisor
         else:
@@ -3372,7 +3405,6 @@ class ClaudeSDKSupervisorManager:
         history: list[dict[str, str]] | None = None,
         options: Any,
         configuration_key: str,
-        timeout_seconds: float = 150.0,
         expected_provider_id: str | None = None,
     ) -> dict[str, Any]:
         """Lease native parent context without occupying its main-turn actor.
@@ -3418,7 +3450,6 @@ class ClaudeSDKSupervisorManager:
             side_task = asyncio.create_task(
                 ask_native_side_question(
                     lease.client, question, history=history,
-                    timeout_seconds=timeout_seconds,
                 ),
                 name=f"claude-sdk-side-question:{clean_chat_id}",
             )
@@ -3603,6 +3634,14 @@ class ClaudeSDKSupervisorManager:
             and not supervisor.closed
         )
 
+    def usage_generation(self, chat_id: str, *, run_id: str | None = None) -> str | None:
+        """Identify the existing native owner without connecting or issuing RPCs."""
+        supervisor = self._supervisors.get(str(chat_id))
+        if (supervisor is None or supervisor.closed or not supervisor.connected
+                or (run_id is not None and supervisor.active_run_id != run_id)):
+            return None
+        return supervisor.control_generation
+
     async def evict(
         self,
         chat_id: str,

package/server/claude_side_question.py

@@ -22,7 +22,6 @@ from typing import Any
 from side_questions import (
     MAX_OUTPUT_BYTES,
     MAX_QUESTION_CHARS,
-    REQUEST_TIMEOUT_SECONDS,
     SideQuestionError,
 )
 
@@ -128,7 +127,6 @@ async def ask_native_side_question(
     question: str,
     *,
     history: list[dict] | None = None,
-    timeout_seconds: float = REQUEST_TIMEOUT_SECONDS,
 ) -> dict:
     """Ask native /btw without acquiring the parent's main-turn authority.
 
@@ -138,8 +136,6 @@ async def ask_native_side_question(
     """
     request = _request(question, history)
     query = _native_query(client)
-    if timeout_seconds <= 0:
-        raise ValueError("timeout_seconds must be positive")
     request_id = f"agentsdock_side_{uuid.uuid4().hex}"
     event = asyncio.Event()
     query.pending_control_responses[request_id] = event
@@ -187,14 +183,11 @@ async def ask_native_side_question(
                 await cleanup
 
     try:
-        result = await asyncio.wait_for(asyncio.shield(receiving), timeout_seconds)
+        result = await asyncio.shield(receiving)
         return _answer(result)
     except asyncio.CancelledError:
         await cancel_and_settle()
         raise
-    except TimeoutError:
-        await cancel_and_settle()
-        raise SideQuestionError(504, "Claude native side question timed out") from None
     except SideQuestionError:
         raise
     except Exception: