@agentsdock/server 1.0.8 → 1.0.10-beta.1

package/server/install.sh

@@ -1839,7 +1839,7 @@ if [[ "$TEAM_HUB_MODE" == "host" && "$TEAM_HUB_OPERATION_PENDING" != "true" \
   fi
 fi
 
-RELEASE_FILES=(activation_transaction.py execution_activation.py execution_legacy_runner.py execution_preparation.py update_preparation.py update_handoff.py update_recovery.py execution_update_status.py execution_uninstall.py execution_recovery.py execution_recovery_status.py execution_http.py execution_durability.py execution_control.py execution_install.py execution_maintenance.py execution_manage.py execution_ownership.py execution_service.py execution_transport.py agent_server.py local_session_ownership.py cursor_history.py workspace_git.py team_hub_host.py secure_peer_runtime.py team_mail_runtime.py team_mail_websocket.py team_mail_grants.py secure_peer_delivery.py agentsdock_jobs.py agentsdock_chats.py chat_mailbox.py agentsdock_emergency.py agentsdock_publish.py agentsdock_mail.py agentsdock_team.py provider_commands.py provider_usage.py claude_sdk_client.py claude_model_catalog.py claude_goals.py claude_background_reconciliation.py codex_app_server.py codex_auth.py codex_provider.py provider_connections.py cursor_api_key.py side_questions.py title_generation.py codex_side_question.py claude_side_question.py cursor_agent_client.py cursor_provider_mcp.py opencode_agent_client.py cursor_process_guard.py claude_history_repair.py claude_history_provenance.py codex_history_repair.py public_chat_shares.py public_chat_transcript.py public_chat_share_routes.py interactive_chat_shares.py interactive_chat_share_routes.py interactive_chat_share_web.py interactive_chat_projection.py interactive_chat_runtime.py interactive_chat_native.py shared_chat_videos.py shared_chat_video_stream.py interactive_chat_controls.py install.sh uninstall.sh instances.sh server_instances.py update_runner.py pyproject.toml uv.lock VERSION release-public-key.pem LICENSE NOTICE)
+RELEASE_FILES=(activation_transaction.py execution_activation.py execution_legacy_runner.py execution_preparation.py update_preparation.py update_handoff.py update_recovery.py execution_update_status.py execution_uninstall.py execution_recovery.py execution_recovery_status.py execution_http.py execution_durability.py execution_control.py execution_install.py execution_maintenance.py execution_manage.py execution_ownership.py execution_service.py execution_transport.py agent_server.py local_session_ownership.py cursor_history.py workspace_git.py team_hub_host.py secure_peer_runtime.py team_mail_runtime.py team_mail_websocket.py team_mail_grants.py secure_peer_delivery.py agentsdock_jobs.py agentsdock_chats.py chat_mailbox.py agentsdock_emergency.py agentsdock_publish.py agentsdock_mail.py agentsdock_team.py provider_commands.py provider_usage.py claude_sdk_client.py claude_model_catalog.py claude_goals.py claude_background_reconciliation.py codex_app_server.py codex_auth.py codex_provider.py codex_response_stream.py provider_connections.py cursor_api_key.py side_questions.py title_generation.py codex_side_question.py codex_side_chat_progress.py claude_side_question.py cursor_agent_client.py cursor_provider_mcp.py opencode_agent_client.py cursor_process_guard.py claude_history_repair.py claude_history_provenance.py codex_history_repair.py public_chat_shares.py public_chat_transcript.py public_chat_share_routes.py interactive_chat_shares.py interactive_chat_share_routes.py interactive_chat_share_web.py interactive_chat_projection.py interactive_chat_runtime.py interactive_chat_native.py shared_chat_videos.py shared_chat_video_stream.py interactive_chat_controls.py install.sh uninstall.sh instances.sh server_instances.py update_runner.py pyproject.toml uv.lock VERSION release-public-key.pem LICENSE NOTICE)
 RELEASE_DIRECTORIES=(agentsdock_team_hub)
 TEAM_HUB_RELEASE_FILES=(
   __init__.py
@@ -3055,21 +3055,37 @@ install_lock_control() {
   local action="$1"
   local expected_device="${2:-0}"
   local expected_inode="${3:-0}"
+  local wait_for_prepared="false"
+  # Old managed preparers do not pass a managed-update ID. The existing pinned
+  # preparation/activation modes may serialize briefly; this grants no update
+  # authority and leaves ordinary installation and recovery fail-fast.
+  if [[ "$action" == "acquire" && "${RECOVER_ONLY:-false}" != "true" \
+    && "${RECOVER_UNARMED_ONLY:-false}" != "true" \
+    && ( "${PREPARE_ONLY:-false}" == "true" || -n "${ACTIVATE_PREPARED:-}" ) \
+    && "${PREPARED_ARCHIVE_SHA256:-}" =~ ^[0-9a-f]{64}$ \
+    && "${EXPECTED_API_CONTRACT:-}" =~ ^[1-9][0-9]*$ \
+    && -n "${RELEASE_VERSION:-}" ]]; then
+    wait_for_prepared="true"
+  fi
   local python_path=""
   python_path="$(install_lock_python)" || return 1
   "$python_path" - \
-    "$action" "$INSTALL_ROOT" "$$" "$expected_device" "$expected_inode" <<'PY'
+    "$action" "$INSTALL_ROOT" "$$" "$expected_device" "$expected_inode" "$wait_for_prepared" <<'PY'
 import errno
 import os
 from pathlib import Path
 import secrets
+import signal
 import stat
 import sys
+import time
 
-action, raw_root, raw_pid, raw_device, raw_inode = sys.argv[1:]
+action, raw_root, raw_pid, raw_device, raw_inode, raw_wait = sys.argv[1:]
 root = Path(os.path.abspath(raw_root))
 pid = int(raw_pid)
 lock = root / ".install-lock"
+PREPARED_LOCK_WAIT_SECONDS = 30.0
+wait_for_prepared = action == "acquire" and raw_wait == "true"
 
 root_info = root.lstat()
 if (
@@ -3145,7 +3161,56 @@ def read_owner(directory_descriptor: int) -> tuple[int, tuple[int, int]]:
     return int(value), (int(info.st_dev), int(info.st_ino))
 
 
+def check_wait_root() -> None:
+    current = root.lstat()
+    if ((current.st_dev, current.st_ino) != (root_info.st_dev, root_info.st_ino)
+            or not stat.S_ISDIR(current.st_mode) or current.st_uid != os.geteuid()
+            or stat.S_IMODE(current.st_mode) & 0o022):
+        raise PermissionError("AgentsServer install root changed while waiting")
+
+
+def same_wait_owner(directory_descriptor, directory_info, owner_pid, owner_identity) -> bool:
+    check_wait_root()
+    current = lock.lstat()
+    if ((current.st_dev, current.st_ino) != (directory_info.st_dev, directory_info.st_ino)):
+        return False
+    if (not stat.S_ISDIR(current.st_mode) or current.st_uid != os.geteuid()
+            or stat.S_IMODE(current.st_mode) & 0o077):
+        raise PermissionError("AgentsServer install lock directory is unsafe")
+    return read_owner(directory_descriptor) == (owner_pid, owner_identity)
+
+
+def cleanup_wait_candidate(path, expected) -> None:
+    # Cancellation while waiting may remove only our still-unpublished draft.
+    # An acquired-but-unreported lock is left for ordinary dead-owner reaping.
+    try:
+        check_wait_root()
+        descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_DIRECTORY)
+        try:
+            current = os.fstat(descriptor)
+            linked = path.lstat()
+            identity = (expected.st_dev, expected.st_ino)
+            if ((current.st_dev, current.st_ino) != identity
+                    or (linked.st_dev, linked.st_ino) != identity):
+                return
+            owner, owner_identity = read_owner(descriptor)
+            if owner != pid or read_owner(descriptor) != (owner, owner_identity):
+                return
+            os.unlink("pid", dir_fd=descriptor)
+            os.fsync(descriptor)
+            linked = path.lstat()
+            if (linked.st_dev, linked.st_ino) == identity:
+                path.rmdir()
+        finally:
+            os.close(descriptor)
+    except (OSError, RuntimeError):
+        pass  # Preserve the original cancellation/failure; never guess ownership.
+
+
 if action == "acquire":
+    # One budget includes owner/namespace changes. Waiting only observes an
+    # existing safe lock; all authority checks still follow atomic acquisition.
+    deadline = time.monotonic() + PREPARED_LOCK_WAIT_SECONDS
     candidate = root / f".install-lock.{pid}.{secrets.token_hex(12)}.tmp"
     os.mkdir(candidate, 0o700)
     os.chmod(candidate, 0o700)
@@ -3165,21 +3230,44 @@ if action == "acquire":
         finally:
             os.close(descriptor)
         fsync_directory(candidate)
-        for _attempt in range(32):
+        if wait_for_prepared:
+            def cancelled(signum, _frame):
+                raise SystemExit(128 + signum)
+            for signum in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP):
+                signal.signal(signum, cancelled)
+        namespace_attempts = 0
+        while namespace_attempts < 32:
+            if wait_for_prepared:
+                check_wait_root()
+                if time.monotonic() >= deadline:
+                    raise RuntimeError("AgentsServer prepared update timed out waiting for the installation lock")
             try:
                 os.rename(candidate, lock)
             except OSError as exc:
                 if exc.errno not in {errno.EEXIST, errno.ENOTEMPTY}:
                     raise
-                directory_descriptor, directory_info = open_lock_directory()
                 try:
+                    directory_descriptor, directory_info = open_lock_directory()
+                except FileNotFoundError:
+                    if not wait_for_prepared:
+                        raise
+                    # The incumbent retired after rename observed its lock.
+                    namespace_attempts += 1
+                    continue
+                try:
+                    if wait_for_prepared and any(
+                        name != "pid" for name in os.listdir(directory_descriptor)
+                    ):
+                        raise PermissionError("AgentsServer install lock contains unknown files")
                     try:
                         owner_pid, owner_identity = read_owner(directory_descriptor)
                     except FileNotFoundError:
                         # An old installer may have crashed in mkdir->pid. The
                         # next atomic directory rename replaces only that
                         # exact empty namespace; a populated replacement wins.
+                        namespace_attempts += 1
                         continue
+                    alive = False
                     try:
                         os.kill(owner_pid, 0)
                     except ProcessLookupError:
@@ -3189,6 +3277,22 @@ if action == "acquire":
                             f"another AgentsServer installation is active ({owner_pid})"
                         )
                     else:
+                        alive = True
+                    if alive:
+                        if wait_for_prepared:
+                            try:
+                                unchanged = same_wait_owner(directory_descriptor, directory_info,
+                                                            owner_pid, owner_identity)
+                            except FileNotFoundError:
+                                unchanged = False
+                            if not unchanged:
+                                namespace_attempts += 1
+                                continue
+                            remaining = deadline - time.monotonic()
+                            if remaining <= 0:
+                                raise RuntimeError("AgentsServer prepared update timed out waiting for the installation lock")
+                            time.sleep(min(0.1, remaining))
+                            continue
                         raise RuntimeError(
                             f"another AgentsServer installation is active ({owner_pid})"
                         )
@@ -3200,19 +3304,25 @@ if action == "acquire":
                             directory_descriptor
                         )
                     except FileNotFoundError:
+                        namespace_attempts += 1
                         continue
                     if current_owner != owner_pid or current_identity != owner_identity:
+                        namespace_attempts += 1
                         continue
                     try:
                         os.unlink("pid", dir_fd=directory_descriptor)
                     except FileNotFoundError:
+                        namespace_attempts += 1
                         continue
                     os.fsync(directory_descriptor)
                 finally:
                     os.close(directory_descriptor)
+                namespace_attempts += 1
                 continue
             else:
                 owned = True
+                if wait_for_prepared:
+                    check_wait_root()
                 for _ in range(3):
                     try:
                         fsync_directory(root)
@@ -3232,7 +3342,9 @@ if action == "acquire":
                 raise SystemExit(0)
         raise RuntimeError("AgentsServer install lock ownership kept changing")
     finally:
-        if not owned:
+        if not owned and wait_for_prepared:
+            cleanup_wait_candidate(candidate, candidate_info)
+        elif not owned:
             try:
                 (candidate / "pid").unlink()
             except FileNotFoundError:
@@ -3639,11 +3751,12 @@ validate_staged_release_runtime() (
     "$STAGE_DIR/claude_background_reconciliation.py" \
     "$STAGE_DIR/codex_app_server.py" \
     "$STAGE_DIR/codex_auth.py" \
-    "$STAGE_DIR/codex_provider.py" \
+    "$STAGE_DIR/codex_provider.py" "$STAGE_DIR/codex_response_stream.py" \
     "$STAGE_DIR/provider_connections.py" "$STAGE_DIR/cursor_api_key.py" \
     "$STAGE_DIR/side_questions.py" \
     "$STAGE_DIR/workspace_git.py" \
     "$STAGE_DIR/codex_side_question.py" \
+    "$STAGE_DIR/codex_side_chat_progress.py" \
     "$STAGE_DIR/title_generation.py" \
     "$STAGE_DIR/claude_side_question.py" \
     "$STAGE_DIR/cursor_agent_client.py" \
@@ -3668,7 +3781,7 @@ validate_staged_release_runtime() (
     "$STAGE_DIR/update_runner.py"
   "$STAGE_DIR/.venv/bin/python" -m py_compile "$STAGE_DIR/server_instances.py"
   "$STAGE_DIR/.venv/bin/python" -m compileall -q "$STAGE_DIR/agentsdock_team_hub"
-  PYTHONPATH="$STAGE_DIR" "$STAGE_DIR/.venv/bin/python" -c 'import execution_activation, execution_preparation, update_preparation, update_handoff, update_recovery, execution_update_status, execution_uninstall, execution_recovery, execution_recovery_status, execution_http, execution_durability, execution_control, execution_install, execution_maintenance, execution_manage, execution_ownership, execution_service, execution_transport; import workspace_git, claude_model_catalog, server_instances, local_session_ownership, cursor_history; import codex_auth, codex_provider, provider_connections, cursor_api_key, side_questions, title_generation, codex_side_question, claude_side_question, agentsdock_team_hub, cursor_agent_client, cursor_provider_mcp, opencode_agent_client, cursor_process_guard, secure_peer_delivery, secure_peer_runtime, team_mail_runtime, team_mail_websocket, team_mail_grants, team_hub_host, agentsdock_mail, agentsdock_team, claude_history_repair, claude_history_provenance, claude_goals, claude_background_reconciliation, codex_history_repair, public_chat_shares, public_chat_transcript, public_chat_share_routes, interactive_chat_shares, interactive_chat_share_routes, interactive_chat_share_web, interactive_chat_projection, interactive_chat_runtime, interactive_chat_native, shared_chat_videos, shared_chat_video_stream, interactive_chat_controls, chat_mailbox, provider_commands, provider_usage; from agentsdock_team_hub import secure_peer, secure_peer_hub' >/dev/null
+  PYTHONPATH="$STAGE_DIR" "$STAGE_DIR/.venv/bin/python" -c 'import execution_activation, execution_preparation, update_preparation, update_handoff, update_recovery, execution_update_status, execution_uninstall, execution_recovery, execution_recovery_status, execution_http, execution_durability, execution_control, execution_install, execution_maintenance, execution_manage, execution_ownership, execution_service, execution_transport; import workspace_git, claude_model_catalog, server_instances, local_session_ownership, cursor_history; import codex_auth, codex_provider, codex_response_stream, provider_connections, cursor_api_key, side_questions, title_generation, codex_side_question, codex_side_chat_progress, claude_side_question, agentsdock_team_hub, cursor_agent_client, cursor_provider_mcp, opencode_agent_client, cursor_process_guard, secure_peer_delivery, secure_peer_runtime, team_mail_runtime, team_mail_websocket, team_mail_grants, team_hub_host, agentsdock_mail, agentsdock_team, claude_history_repair, claude_history_provenance, claude_goals, claude_background_reconciliation, codex_history_repair, public_chat_shares, public_chat_transcript, public_chat_share_routes, interactive_chat_shares, interactive_chat_share_routes, interactive_chat_share_web, interactive_chat_projection, interactive_chat_runtime, interactive_chat_native, shared_chat_videos, shared_chat_video_stream, interactive_chat_controls, chat_mailbox, provider_commands, provider_usage; from agentsdock_team_hub import secure_peer, secure_peer_hub' >/dev/null
 )
 
 abort_unclaimed_team_hub_reactivation() {

package/server/side_questions.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import asyncio
 from contextlib import suppress, closing
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 import hashlib
 import json
@@ -57,7 +57,36 @@ class SideQuestionError(Exception):
 
 def capability():
     return {"available": True, "version": 2, "native_context": True, "backends": ["codex", "claude"],
-            "max_question_chars": MAX_QUESTION_CHARS, "sync": True}
+            "max_question_chars": MAX_QUESTION_CHARS, "sync": True, "runtime_settings": True}
+
+
+def validate_runtime_settings(value):
+    """Only explicit per-turn choices; omission preserves the side runtime."""
+    result = {}
+    for key in ("model", "effort"):
+        if key not in value:
+            continue
+        setting = value[key]
+        if not isinstance(setting, str) or len(setting) > 256 or any(ord(c) < 32 for c in setting):
+            raise SideQuestionError(400, "Invalid side chat runtime setting")
+        try:
+            setting.encode("utf-8")
+        except UnicodeEncodeError:
+            raise SideQuestionError(400, "Invalid side chat runtime setting") from None
+        setting = setting.strip()
+        if key == "model" and not setting:
+            raise SideQuestionError(400, "Side chat model must not be empty")
+        if key == "effort" and setting not in {"", "none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"}:
+            raise SideQuestionError(400, "Invalid side chat reasoning effort")
+        result[key] = setting
+    return result
+
+
+def request_digest(question, runtime_settings=None):
+    # Retain old receipts exactly when the optional settings were absent.
+    payload = (json.dumps([question, runtime_settings], sort_keys=True, ensure_ascii=False)
+               if runtime_settings else question)
+    return hashlib.sha256(payload.encode()).hexdigest()
 
 
 def validate_history(value) -> tuple[tuple[str, str], ...]:
@@ -328,6 +357,7 @@ class _Receipt:
     waiters: int = 0
     side_chat_id: str | None = None
     after_request_id: str | None = None
+    runtime_settings: dict = field(default_factory=dict)
 
 
 @dataclass
@@ -345,14 +375,15 @@ NATIVE_IDLE_SECONDS = 30 * 60
 
 
 class SideQuestions:
-    def __init__(self, answer=None, *, native_factory=None, storage_path=None, notify=None, admission_check=None):
+    def __init__(self, answer=None, *, native_factory=None, storage_path=None, notify=None, admission_check=None, runtime_settings_for_session=None):
         self.answer = answer
         self.native_factory = native_factory
         self.admission_check = admission_check
         self.receipts: dict[tuple[str, str, str], _Receipt] = {}
         self.conversations: dict[tuple[str, str, str], _NativeConversation] = {}
         self.cleanup_tasks: set[asyncio.Task] = set()
-        self.synced = (SyncedSideChats(storage_path, native_factory=native_factory, notify=notify, admission_check=admission_check)
+        self.synced = (SyncedSideChats(storage_path, native_factory=native_factory, notify=notify, admission_check=admission_check,
+                                       runtime_settings_for_session=runtime_settings_for_session)
                        if storage_path is not None else None)
 
     def active_session_ids(self):
@@ -395,7 +426,7 @@ class SideQuestions:
                 task.exception()
         task.add_done_callback(finished)
 
-    async def _native_answer(self, owner, session_id, request_id, question, side_chat_id, after_request_id):
+    async def _native_answer(self, owner, session_id, request_id, question, side_chat_id, after_request_id, runtime_settings=None):
         key = (owner, session_id, side_chat_id)
         conversation = self.conversations.get(key)
         if conversation is None:
@@ -416,7 +447,8 @@ class SideQuestions:
                 conversation.handle = await self.native_factory(session_id)
             if conversation.closed:
                 raise SideQuestionError(410, "Side chat ended")
-            result = await conversation.handle.ask(question, history=list(conversation.history))
+            result = await conversation.handle.ask(question, history=list(conversation.history),
+                **({"runtime_settings": runtime_settings} if runtime_settings else {}))
             if conversation.closed:
                 raise SideQuestionError(410, "Side chat ended")
             # Claude /btw replays the last twenty side exchanges natively.
@@ -450,9 +482,10 @@ class SideQuestions:
                 self.receipts.pop(key, None)
 
     def submit(self, owner: str, session_id: str, request_id: str, question: str, *, history: list[dict] | None = None,
-               side_chat_id: str | None = None, after_request_id: str | None = None):
+               side_chat_id: str | None = None, after_request_id: str | None = None, runtime_settings=None):
         if self.admission_check is not None:
             self.admission_check()
+        runtime_settings = validate_runtime_settings(runtime_settings or {})
         frozen_history = validate_history([] if history is None else history)
         self._prune()
         key = (owner, session_id, request_id)
@@ -461,17 +494,19 @@ class SideQuestions:
             if receipt.cancelled:
                 raise SideQuestionError(409, "Side question was cancelled; submit with a new request ID")
             if (receipt.question != question or receipt.history != frozen_history
-                    or receipt.side_chat_id != side_chat_id or receipt.after_request_id != after_request_id):
+                    or receipt.side_chat_id != side_chat_id or receipt.after_request_id != after_request_id
+                    or receipt.runtime_settings != runtime_settings):
                 raise SideQuestionError(409, "Request ID already belongs to a different side question")
             return receipt
         if self.native_factory is not None and (not side_chat_id or frozen_history):
             raise SideQuestionError(409, "Update the app to use native Side chat; copied conversation history is no longer accepted.")
-        receipt = _Receipt(question, history=frozen_history, side_chat_id=side_chat_id, after_request_id=after_request_id)
+        receipt = _Receipt(question, history=frozen_history, side_chat_id=side_chat_id, after_request_id=after_request_id,
+                           runtime_settings=runtime_settings)
         self.receipts[key] = receipt
 
         async def run():
             try:
-                answer = (self._native_answer(owner, session_id, request_id, question, side_chat_id, after_request_id)
+                answer = (self._native_answer(owner, session_id, request_id, question, side_chat_id, after_request_id, runtime_settings)
                           if self.native_factory is not None else
                           self.answer(session_id, question, history=history_messages(frozen_history))
                           if frozen_history else self.answer(session_id, question))
@@ -603,7 +638,7 @@ class SideChatStore:
             if receipt is not None:
                 database.execute("INSERT INTO receipts VALUES(?,?,?,?,?)",
                                  (owner, session, receipt["request_id"], document["side_chat_id"],
-                                  hashlib.sha256(receipt["question"].encode()).hexdigest()))
+                                  request_digest(receipt["question"], receipt.get("runtime_settings"))))
             provider_state = document.get("_provider_state") or {}
             thread_id = (provider_state.get("codex") or {}).get("thread_id")
             if isinstance(thread_id, str) and thread_id:
@@ -658,7 +693,8 @@ class SyncedSideChats:
     after an app disconnect or an unexpected process exit.
     """
 
-    def __init__(self, path, *, native_factory, notify=None, admission_check=None):
+    def __init__(self, path, *, native_factory, notify=None, admission_check=None, runtime_settings_for_session=None):
+        self.runtime_settings_for_session = runtime_settings_for_session
         self.store = SideChatStore(path)
         self.native_factory = native_factory
         self.notify = notify
@@ -700,9 +736,21 @@ class SyncedSideChats:
 
     async def snapshot(self, owner, session):
         async with self._lock((owner, session)):
-            return self.public(self._load((owner, session)))
-
-    async def submit(self, owner, session, request_id, question, side_chat_id, after_request_id=None):
+            document = self._load((owner, session))
+            if "model" not in document and self.runtime_settings_for_session is not None:
+                # Retained history stays readable when provider credentials,
+                # endpoint configuration or model discovery are unavailable.
+                settings = {}
+                with suppress(Exception):
+                    settings = self.runtime_settings_for_session(session)
+                if settings:
+                    document.update(settings)
+                    document["revision"] += 1
+                    self.store.save(owner, session, document)
+            return self.public(document)
+
+    async def submit(self, owner, session, request_id, question, side_chat_id, after_request_id=None, runtime_settings=None):
+        runtime_settings = validate_runtime_settings(runtime_settings or {})
         key = (owner, session)
         async with self._lock(key):
             if self.stopping:
@@ -712,7 +760,7 @@ class SyncedSideChats:
             document = self._load(key)
             previous = self.store.receipt(*key, request_id)
             if previous is not None:
-                if previous != (side_chat_id, hashlib.sha256(question.encode()).hexdigest()) or document["side_chat_id"] != side_chat_id:
+                if previous != (side_chat_id, request_digest(question, runtime_settings)) or document["side_chat_id"] != side_chat_id:
                     raise SideQuestionError(409, "Request ID belongs to a different or cleared side chat")
                 return self.public(document)
             if document["side_chat_id"] != side_chat_id:
@@ -725,14 +773,15 @@ class SyncedSideChats:
             if document["last_request_id"] != after_request_id:
                 raise SideQuestionError(409, "Side chat changed; refresh before sending")
             exchange = {"request_id": request_id, "question": question, "status": "running",
-                        "created_at": side_chat_timestamp(), "updated_at": side_chat_timestamp()}
+                        "created_at": side_chat_timestamp(), "updated_at": side_chat_timestamp(),
+                        **({"runtime_settings": runtime_settings} if runtime_settings else {})}
             document["exchanges"].append(exchange)
             document["revision"] += 1
             self.store.save(*key, document, receipt=exchange)
             timer = self.timers.pop(key, None)
             if timer is not None:
                 timer.cancel()
-            task = asyncio.create_task(self._answer(key, side_chat_id, request_id, question), name="synced-side-question")
+            task = asyncio.create_task(self._answer(key, side_chat_id, request_id, question, runtime_settings), name="synced-side-question")
             self.tasks[key] = task
             def done(completed):
                 if self.tasks.get(key) is completed:
@@ -750,9 +799,33 @@ class SyncedSideChats:
             if document["side_chat_id"] != side_chat_id:
                 raise SideQuestionError(409, "Side chat was cleared")
             document["_provider_state"] = value
+            settings = value.get("runtime_settings") or {}
+            changed = any(document.get(name) != setting for name, setting in settings.items())
+            document.update(settings)
+            if changed:
+                document["revision"] += 1
             self.store.save(*key, document)
+        if changed:
+            await self._changed(document)
+
+    async def _progress(self, key, side_chat_id, request_id, activity):
+        async with self._lock(key):
+            document = self.pending_writes.get(key) or self._load(key)
+            if document["side_chat_id"] != side_chat_id:
+                return
+            exchange = next((item for item in document["exchanges"] if item["request_id"] == request_id), None)
+            if exchange is None or exchange["status"] != "running":
+                return
+            exchange.update(activity=activity, updated_at=side_chat_timestamp())
+            document["revision"] += 1
+            try:
+                self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
+            except (OSError, sqlite3.Error):
+                self.pending_writes[key] = document
+        await self._changed(document)
 
-    async def _answer(self, key, side_chat_id, request_id, question):
+    async def _answer(self, key, side_chat_id, request_id, question, runtime_settings=None):
         handle = None
         failed = False
         try:
@@ -762,11 +835,15 @@ class SyncedSideChats:
             handle = self.handles.get(key)
             if handle is None:
                 handle = await self.native_factory(key[1], persisted_state=document.get("_provider_state"),
-                    persist_state=lambda value: self._provider_state(key, side_chat_id, value), durable=True)
+                    persist_state=lambda value: self._provider_state(key, side_chat_id, value), durable=True,
+                    **({"initial_runtime_settings": {name: document[name] for name in ("model", "effort") if name in document}}
+                       if "model" in document else {}))
                 self.handles[key] = handle
             history = [{"question": item["question"], "response": item["answer"]}
                        for item in document["exchanges"] if item["status"] == "completed"][-20:]
-            result = await handle.ask(question, history=history)
+            result = await handle.ask(question, history=history,
+                on_progress=lambda activity: self._progress(key, side_chat_id, request_id, activity),
+                **({"runtime_settings": runtime_settings} if runtime_settings else {}))
             await self._finish(key, side_chat_id, request_id, "completed", **result)
         except asyncio.CancelledError:
             failed = True
@@ -802,17 +879,19 @@ class SyncedSideChats:
 
     async def _finish(self, key, side_chat_id, request_id, status, **result):
         async with self._lock(key):
-            document = self._load(key)
+            document = self.pending_writes.get(key) or self._load(key)
             if document["side_chat_id"] != side_chat_id:
                 return
             exchange = next((item for item in document["exchanges"] if item["request_id"] == request_id), None)
             if exchange is None or exchange["status"] != "running":
                 return
             exchange.update(status=status, updated_at=side_chat_timestamp(), **result)
+            document.update({key: result[key] for key in ("model", "effort") if key in result})
             document["last_request_id"] = request_id
             document["revision"] += 1
             try:
                 self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
             except (OSError, sqlite3.Error):
                 self.pending_writes[key] = document
         await self._changed(document)
@@ -830,7 +909,9 @@ class SyncedSideChats:
     async def cancel(self, owner, session, request_id):
         key = (owner, session)
         async with self._lock(key):
-            document = self._load(key)
+            # Pending progress may be unsaved while provider work is active.
+            # Storage recovery must not gate the operator's Stop intent.
+            document = self.pending_writes.get(key) or self._load(key)
             exchange = next((item for item in document["exchanges"] if item["request_id"] == request_id), None)
             if exchange is None:
                 # Stop can overtake submission in transit. Preserve an opaque
@@ -839,15 +920,24 @@ class SyncedSideChats:
                     self.store.save(*key, document, receipt={"request_id": request_id, "question": ""})
                 return self.public(document)
             if exchange["status"] != "running":
-                return self.public(document)
+                return self.public(self._load(key))
+            task = self.tasks.get(key)
+            snapshot_progress = getattr(self.handles.get(key), "snapshot_progress", None)
+            if task is not None and callable(snapshot_progress):
+                # Capture only native items received by this exact request
+                # before Stop. Later coalesced callbacks stay fenced below.
+                with suppress(Exception):
+                    activity = snapshot_progress(task)
+                    if activity is not None:
+                        exchange["activity"] = activity
             exchange.update(status="cancelled", updated_at=side_chat_timestamp())
             document["last_request_id"] = request_id
             document["revision"] += 1
             try:
                 self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
             except (OSError, sqlite3.Error):
                 self.pending_writes[key] = document
-            task = self.tasks.get(key)
             if task is not None:
                 task.cancel()
         if task is not None:
@@ -858,15 +948,20 @@ class SyncedSideChats:
     async def clear(self, owner, session, side_chat_id):
         key = (owner, session)
         async with self._lock(key):
-            document = self._load(key)
+            # Preserve the new conversation fence even if progress storage
+            # is unavailable; still retire the old provider immediately.
+            document = self.pending_writes.get(key) or self._load(key)
             if document["side_chat_id"] != side_chat_id:
                 # A repeated Clear is harmless. A stale device cannot clear a
                 # new conversation it has not seen.
-                return self.public(document)
+                return self.public(self._load(key))
             document.update(side_chat_id=uuid.uuid4().hex, exchanges=[], last_request_id=None, _provider_state=None)
+            document.pop("model", None)
+            document.pop("effort", None)
             document["revision"] += 1
             try:
                 self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
             except (OSError, sqlite3.Error):
                 self.pending_writes[key] = document
             task = self.tasks.get(key)
@@ -947,7 +1042,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         except asyncio.TimeoutError:
             raise HTTPException(408, "Side question request was not received") from None
         if (not isinstance(value, dict) or not {"request_id", "question"} <= set(value)
-                or set(value) - {"request_id", "question", "history", "side_chat_id", "after_request_id"}):
+                or set(value) - {"request_id", "question", "history", "side_chat_id", "after_request_id", "model", "effort"}):
             raise HTTPException(400, "Invalid side question fields")
         for field in ("side_chat_id", "after_request_id"):
             if field in value and (not isinstance(value[field], str) or not IDENTIFIER.fullmatch(value[field])):
@@ -977,7 +1072,8 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         receipt = None
         try:
             receipt = runtime.submit(owner, session_id, request_id, question, history=history,
-                                     side_chat_id=value.get("side_chat_id"), after_request_id=value.get("after_request_id"))
+                                     side_chat_id=value.get("side_chat_id"), after_request_id=value.get("after_request_id"),
+                                     runtime_settings=validate_runtime_settings(value))
             receipt.waiters += 1
             watcher = asyncio.create_task(disconnected())
             done, _ = await asyncio.wait({receipt.task, watcher}, return_when=asyncio.FIRST_COMPLETED)
@@ -1047,7 +1143,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         except asyncio.TimeoutError:
             raise HTTPException(408, "Side question request was not received") from None
         if (not isinstance(value, dict) or not {"request_id", "question", "side_chat_id"} <= set(value)
-                or set(value) - {"request_id", "question", "side_chat_id", "after_request_id"}):
+                or set(value) - {"request_id", "question", "side_chat_id", "after_request_id", "model", "effort"}):
             raise HTTPException(400, "Invalid side question fields")
         for field in ("request_id", "side_chat_id", "after_request_id"):
             if field == "after_request_id" and value.get(field) is None:
@@ -1062,7 +1158,8 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         except UnicodeEncodeError:
             raise HTTPException(400, "Question must contain valid Unicode text") from None
         return await synced_response(synced_runtime().submit(owner, session_id, value["request_id"], question,
-            value["side_chat_id"], value.get("after_request_id")), status_code=202)
+            value["side_chat_id"], value.get("after_request_id"),
+            runtime_settings=value), status_code=202)
 
     @router.delete("/api/sessions/{session_id}/side-chat/requests/{request_id}")
     async def cancel_synced(session_id: str, request_id: str, request: Request):