@agentsdock/server 1.0.10-beta.1 → 1.0.10-beta.6

package/server/agent_server.py

@@ -10765,6 +10765,7 @@ class SessionStore:
             if "subagent_limit" in patch:
                 validate_session_subagent_limit({**sess, "backend": patch.get("backend") or sess.get("backend")}, patch["subagent_limit"])
             previous_provider_runtime = dict(sess) if {"codex_provider", "provider_connection", "subagent_limit", "model", "effort"}.intersection(patch) or sess.get("_codex_provider_pending") else None
+            previous_title_runtime = title_runtime_key(sess)
             missing_policy = object()
             previous_provider_jobs_access = sess.get(
                 "provider_jobs_access",
@@ -10862,9 +10863,6 @@ class SessionStore:
                         sess.pop("_title_seed", None)
             if patch.get("auto_title_enabled") is not None:
                 sess["auto_title_enabled"] = bool(patch["auto_title_enabled"])
-            if (any(key in patch for key in ("title", "model", "backend", "codex_provider"))
-                    or patch.get("auto_title_enabled") is False or patch.get("archived") is True):
-                cancel_generated_session_title(sid)
             for key, default, allowed in (
                 (
                     "claude_permission_mode",
@@ -10991,6 +10989,13 @@ class SessionStore:
                     sess["_codex_provider_pending"] = desired
                 else:
                     sess.pop("_codex_provider_pending", None)
+            # Ordinary/queued turns re-save their backend and may repeat model
+            # or provider selections. Only an actual runtime change invalidates
+            # the in-flight title; cancelling a no-op consumes its sole attempt.
+            # An explicit title PATCH is still manual ownership, even if equal.
+            if ("title" in patch or title_runtime_key(sess) != previous_title_runtime
+                    or patch.get("auto_title_enabled") is False or patch.get("archived") is True):
+                cancel_generated_session_title(sid)
             sess["updated_at"] = now_iso()
             try:
                 await self.save()
@@ -25588,7 +25593,7 @@ async def _start_next_queued_turn_locked(
         if e.status_code in (409, 503):
             already_notified = bool(item.get("_turn_deferred_notified"))
             item["_turn_deferred_notified"] = True
-            deferred_detail = str(e.detail or "")
+            deferred_detail = str(e.detail.get("message", "") if isinstance(e.detail, dict) else e.detail or "")
             item["_last_deferred_detail"] = deferred_detail
             # Pure wait states (capacity, memory, goals or maintenance in
             # progress) are not admission failures of this row.
@@ -25602,7 +25607,7 @@ async def _start_next_queued_turn_locked(
             if not already_notified:
                 await append_event(session_id, "turn_deferred", {
                     "queued_id": item.get("queued_id"),
-                    "message": f"Queued turn deferred: {e.detail}",
+                    "message": f"Queued turn deferred: {deferred_detail}",
                 })
             schedule_queued_turn_retry(session_id)
             return
@@ -41583,7 +41588,7 @@ def cross_chat_exchange_submission_defer_reason(
     if isinstance(error, asyncio.CancelledError):
         return "AgentsServer stopped while admitting the delivery"
     if isinstance(error, TransientAdmissionWait):
-        return str(error.detail or "").strip() or "target admission deferred"
+        return str(error.detail.get("message", "") if isinstance(error.detail, dict) else error.detail or "").strip() or "target admission deferred"
     if isinstance(error, HTTPException) and error.status_code == 503:
         detail = error.detail
         if isinstance(detail, dict):
@@ -46812,8 +46817,9 @@ def active_generated_title_work_labels() -> list[str]:
 
 def title_runtime_key(sess: dict[str, Any]) -> tuple:
     return (sess.get("backend") or DEFAULT_BACKEND, session_provider_id(sess),
-            sess.get("model"), sess.get("codex_provider"), sess.get("codex_provider_revision"),
-            sess.get("provider_connection"), sess.get("provider_connection_revision"))
+            sess.get("model"), codex_provider.session_choice(sess.get("codex_provider")),
+            sess.get("codex_provider_revision"), sess.get("provider_connection") or "default",
+            sess.get("provider_connection_revision"))
 
 
 def generated_title_eligible(sess: dict[str, Any], *, allow_attempted: bool = False) -> bool:
@@ -54111,8 +54117,17 @@ def codex_manager_has_callers(manager: CodexAppServerManager, session_id: str |
                for task, owner in tuple(getattr(manager, "_agentsdock_callers", {}).items()))
 
 
-def codex_manager_has_callbacks(manager: CodexAppServerManager) -> bool:
-    tasks = [task for task in manager.client._callback_tasks if not task.done()]
+def codex_manager_work_belongs_to_session(work: Any, session_id: str) -> bool:
+    thread_id = getattr(work, "_codex_thread_id", "")
+    owner = codex_session_id_for_thread(thread_id) if thread_id else None
+    # Unknown ownership stays process-wide. Work for a known different chat
+    # must not prevent an idle chat from releasing its own subscription.
+    return owner is None or owner == session_id
+
+
+def codex_manager_has_callbacks(manager: CodexAppServerManager, session_id: str | None = None) -> bool:
+    tasks = [task for task in manager.client._callback_tasks if not task.done()
+             and (session_id is None or codex_manager_work_belongs_to_session(task, session_id))]
     for task in tasks:
         if not getattr(task, "_agentsdock_drain_watched", False):
             task._agentsdock_drain_watched = True
@@ -54165,9 +54180,9 @@ async def refresh_codex_app_server_binary(*, force: bool = False) -> None:
 async def refresh_codex_app_server_login(*, request_handoff: bool = False) -> None:
     """Change normal-Codex admission; never kill a credential-owning process.
 
-    Ordinary lookups use a conservative native file revision. Recheck CLIs is
-    an explicit handoff request, also covering keyring and same-account logins
-    without an OIDC auth_time. This is not a token refresh or login operation.
+    Catalog refresh only observes the native login revision. Only an explicit
+    provider reload requests handoff for opaque credential stores. Neither
+    operation logs in or rotates native credentials.
     """
     global CODEX_APP_SERVER_MANAGER, CODEX_LOGIN_REVISION
     if CODEX_TRANSPORT == CODEX_TRANSPORT_EXEC or CODEX_AUTH_LOCK.locked() or CODEX_MANAGER_CLOSING:
@@ -54191,7 +54206,12 @@ async def refresh_codex_app_server_login(*, request_handoff: bool = False) -> No
                         continue
                     previous = getattr(manager, "_agentsdock_login_revision", None)
                     changed = revision is not None and revision != previous
-                    if changed or request_handoff:
+                    # Recheck CLIs is observational when the native sign-in
+                    # revision is unchanged. Retiring a healthy writer here
+                    # strands its chats behind an unnecessary login handoff.
+                    if revision is not None and revision == previous:
+                        manager._agentsdock_login_superseded = False
+                    if changed or (request_handoff and revision is None):
                         manager._agentsdock_login_superseded = True
                         if not any(manager is item for item in CODEX_RETIRED_APP_SERVER_MANAGERS):
                             CODEX_RETIRED_APP_SERVER_MANAGERS.append(manager)
@@ -54200,22 +54220,59 @@ async def refresh_codex_app_server_login(*, request_handoff: bool = False) -> No
     schedule_codex_manager_drain()
 
 
-def codex_manager_session_busy(manager: CodexAppServerManager, session_id: str, *, ignore_task=None, ignore_maintenance=False) -> bool:
+def codex_manager_session_blocker(manager: CodexAppServerManager, session_id: str, *, ignore_task=None, ignore_maintenance=False) -> str | None:
     session = STORE.sessions.get(session_id) or {}
-    return bool(
-        session_id in BUSY_SESSIONS or ACTIVE.get(session_id) is not None
-        or (not ignore_maintenance and session_id in SERVER_MAINTENANCE_SESSIONS)
-        or codex_manager_has_callers(manager, session_id, ignore_task=ignore_task)
-        or codex_manager_has_callbacks(manager)
-        or any(task is not ignore_task and not task.done()
-            for registry in (SESSION_TURN_TASKS, CODEX_NATIVE_ACTION_TASKS, CODEX_INTERACTION_HANDLER_TASKS)
-            for task in registry.get(session_id, ()))
-        or any(item.get("session_id") == session_id for item in CODEX_PENDING_INTERACTIONS.values())
-        or session_id in SIDE_QUESTIONS.active_session_ids()
-        or (isinstance(session.get("codex_goal"), dict)
-            and session["codex_goal"].get("status") == "active")
-        or codex_session_has_live_subagents(session_id)
-    )
+    if session_id in BUSY_SESSIONS or ACTIVE.get(session_id) is not None:
+        return "active_turn"
+    if not ignore_maintenance and session_id in SERVER_MAINTENANCE_SESSIONS:
+        return "maintenance"
+    if any(item.get("session_id") == session_id for item in CODEX_PENDING_INTERACTIONS.values()):
+        return "approval"
+    if session_id in SIDE_QUESTIONS.active_session_ids():
+        return "side_chat"
+    if (session.get("codex_goal") or {}).get("status") == "active":
+        return "active_goal"
+    if codex_session_has_live_subagents(session_id):
+        return "subagents"
+    if codex_manager_has_callers(manager, session_id, ignore_task=ignore_task):
+        return "runtime_request"
+    if codex_manager_has_callbacks(manager, session_id):
+        return "callback"
+    if any(task is not ignore_task and not task.done()
+           for registry in (SESSION_TURN_TASKS, CODEX_INTERACTION_HANDLER_TASKS)
+           for task in registry.get(session_id, ())):
+        return "runtime_request"
+    if any(sid == session_id and task is not ignore_task and not task.done()
+           for (sid, _), task in CODEX_NATIVE_ACTION_TASKS.items()):
+        return "runtime_request"
+    return None
+
+
+def codex_manager_session_busy(manager: CodexAppServerManager, session_id: str, *, ignore_task=None, ignore_maintenance=False) -> bool:
+    return codex_manager_session_blocker(manager, session_id, ignore_task=ignore_task,
+        ignore_maintenance=ignore_maintenance) is not None
+
+
+def codex_login_handoff_wait(manager: CodexAppServerManager, session_id: str) -> HTTPException:
+    reason = (getattr(manager, "_agentsdock_handoff_reasons", {}).get(session_id)
+              or codex_manager_session_blocker(manager, session_id, ignore_task=asyncio.current_task())
+              or "runtime_request")
+    return TransientAdmissionWait(409, codex_auth.handoff_detail(reason))
+
+
+def watch_codex_login_handoff_blockers(manager: CodexAppServerManager, session_id: str, *, ignore_task=None) -> None:
+    if not getattr(manager, "_agentsdock_login_superseded", False):
+        return
+    work = set(manager.client._callback_tasks) | set(manager.client._server_request_tasks.values())
+    work.update(value[1] for value in manager.client._pending.values())
+    work.update(task for task, owner in tuple(getattr(manager, "_agentsdock_callers", {}).items())
+                if not owner or owner == session_id)
+    for task in work:
+        if task is ignore_task or task.done() or not codex_manager_work_belongs_to_session(task, session_id):
+            continue
+        if not getattr(task, "_agentsdock_login_handoff_watched", False):
+            task._agentsdock_login_handoff_watched = True
+            task.add_done_callback(lambda _: schedule_codex_manager_drain())
 
 
 def watch_codex_provider_handoff_blockers(
@@ -54269,11 +54326,20 @@ async def release_idle_codex_manager_session(manager: CodexAppServerManager, ses
                 # The response Future can finish before its RPC coroutine
                 # removes the registry entry. Treat that settled response as
                 # complete so its wakeup cannot get lost during unwinding.
-                or any(not value[1].done() for value in manager.client._pending.values())
-                or any(not task.done() for task in manager.client._server_request_tasks.values()))
+                or any(not value[1].done() and codex_manager_work_belongs_to_session(value[1], session_id)
+                       for value in manager.client._pending.values())
+                or any(not task.done() and codex_manager_work_belongs_to_session(task, session_id)
+                       for task in manager.client._server_request_tasks.values()))
 
     async def defer(reason: str, *, error_type: str = "") -> bool:
         session = STORE.sessions.get(session_id) or {}
+        reasons = getattr(manager, "_agentsdock_handoff_reasons", None)
+        if reasons is None:
+            reasons = manager._agentsdock_handoff_reasons = {}
+        reasons[session_id] = reason
+        if reason in {"runtime_borrowers", "runtime_borrowers_after_metadata", "runtime_borrowers_after_unsubscribe"}:
+            reasons[session_id] = codex_manager_session_blocker(manager, session_id, ignore_task=ignore_task, ignore_maintenance=True) or "runtime_request"
+            watch_codex_login_handoff_blockers(manager, session_id, ignore_task=ignore_task)
         if isinstance(session.get("_codex_provider_pending"), dict):
             # A failed ownership/goal request can itself emit callbacks.
             # Only verified transient borrowers own a completion retry; an
@@ -54299,6 +54365,7 @@ async def release_idle_codex_manager_session(manager: CodexAppServerManager, ses
     if blocked():
         return await defer("runtime_borrowers")
     deadline = time.monotonic() + 8.0
+    failure_reason = "thread_list_unavailable"
     SERVER_MAINTENANCE_SESSIONS.add(session_id)
     try:
         threads = [thread for thread in tuple(manager.client._loaded_threads)
@@ -54334,6 +54401,7 @@ async def release_idle_codex_manager_session(manager: CodexAppServerManager, ses
             if (thread in CODEX_APP_SERVER_PINNED_THREADS or thread in CODEX_INTERACTIVE_CONTROL_THREADS
                     or manager.active_turn(thread) is not None):
                 return await defer("native_thread_in_use")
+            failure_reason = "goal_state_unavailable"
             try:
                 goal = await asyncio.wait_for(manager.get_thread_goal(thread), timeout=min(3.0, deadline - time.monotonic()))
             except CodexAppServerRequestError as exc:
@@ -54342,6 +54410,7 @@ async def release_idle_codex_manager_session(manager: CodexAppServerManager, ses
                 goal = None
             if isinstance(goal, dict) and goal.get("status") == "active":
                 return await defer("native_goal_active")
+            failure_reason = "terminal_state_unavailable"
             try:
                 terminals = await asyncio.wait_for(manager.list_background_terminals(thread), timeout=min(3.0, deadline - time.monotonic()))
             except CodexAppServerRequestError as exc:
@@ -54354,6 +54423,7 @@ async def release_idle_codex_manager_session(manager: CodexAppServerManager, ses
                 return await defer("background_terminals")
             if blocked(own_maintenance=True):
                 return await defer("runtime_borrowers_after_metadata")
+            failure_reason = "native_unsubscribe_incomplete"
             if manager.is_thread_loaded(thread):
                 evicted = await asyncio.wait_for(evict_codex_app_server_thread(manager, thread, reinsert_on_failure=True),
                     timeout=max(0.0, deadline - time.monotonic()))
@@ -54364,14 +54434,16 @@ async def release_idle_codex_manager_session(manager: CodexAppServerManager, ses
         # Unsubscribe removes the client subscription, but native Codex keeps
         # the native writer alive. Release it before another manager can own
         # this chat; unrelated active chats keep their current process.
+        failure_reason = "writer_release_failed"
         await release_codex_provider_writers(manager, session_id, threads)
+        getattr(manager, "_agentsdock_handoff_reasons", {}).pop(session_id, None)
         if CODEX_SESSION_APP_SERVER_MANAGERS.get(session_id) is manager:
             CODEX_SESSION_APP_SERVER_MANAGERS.pop(session_id, None)
             CODEX_GOAL_SYNC_GENERATIONS.pop(session_id, None)
         return True
     except Exception as exc:
         logger.debug("Codex handoff retained an unverified idle owner", exc_info=True)
-        return await defer("ownership_unverified", error_type=type(exc).__name__)
+        return await defer(failure_reason, error_type=type(exc).__name__)
     finally:
         SERVER_MAINTENANCE_SESSIONS.discard(session_id)
 
@@ -54397,7 +54469,7 @@ async def prepare_codex_login_turn(session: dict[str, Any]) -> None:
     if session_id in BUSY_SESSIONS or ACTIVE.get(session_id) is not None:
         return
     if not await release_idle_codex_manager_session(manager, session_id, ignore_task=asyncio.current_task()):
-        raise TransientAdmissionWait(409, codex_auth.HANDOFF_MESSAGE)
+        raise codex_login_handoff_wait(manager, session_id)
     schedule_codex_manager_drain()
 
 
@@ -54414,6 +54486,11 @@ async def drain_retired_codex_managers() -> None:
             for session_id, owner in tuple(CODEX_SESSION_APP_SERVER_MANAGERS.items()):
                 if owner is not manager or codex_manager_session_busy(manager, session_id):
                     continue
+                # Failed metadata RPCs can emit status callbacks themselves.
+                # Those callbacks must not trigger an endless self-retry.
+                # A user's next send always retries the proof in preflight.
+                if getattr(manager, "_agentsdock_handoff_reasons", {}).get(session_id) in {"thread_list_unavailable", "goal_state_unavailable", "terminal_state_unavailable", "ownership_deadline"}:
+                    continue
                 lock = session_lifecycle_lock(session_id)
                 if lock.locked():
                     continue  # Never invert the session -> manager lock order.
@@ -54556,7 +54633,7 @@ async def codex_app_server_manager(sess: dict[str, Any] | None = None, *, allow_
             if (getattr(manager, "_agentsdock_login_superseded", False) is True and not allow_retired_login
                     and getattr(manager, "_agentsdock_callers", {}).get(asyncio.current_task()) != session_id):
                 schedule_codex_manager_drain()
-                raise TransientAdmissionWait(409, codex_auth.HANDOFF_MESSAGE)
+                raise codex_login_handoff_wait(manager, session_id)
             if session_id:
                 CODEX_SESSION_APP_SERVER_MANAGERS[session_id] = manager
             retain_codex_manager_caller(manager, session_id)
@@ -62620,10 +62697,9 @@ async def run_claude_print(
                     if btype == "text" and block.get("text"):
                         text = clean_assistant_text(block["text"])
                         if text:
-                            await append_event(session_id, "reasoning_summary", {
+                            await append_event(session_id, "assistant_text", {
                                 "run_id": run_id,
                                 "text": text,
-                                "phase": "commentary",
                                 "backend": BACKEND_CLAUDE,
                                 **run_event_metadata(run_id),
                             })
@@ -63063,10 +63139,9 @@ async def project_claude_sdk_message(
                 )
                 if text:
                     text_parts.append(text)
-                    await append_event(session_id, "reasoning_summary", {
+                    await append_event(session_id, "assistant_text", {
                         "run_id": run_id,
                         "text": text,
-                        "phase": "commentary",
                         "backend": BACKEND_CLAUDE,
                         **({"provider_message_id": message_uuid}
                            if (message_uuid := claude_sdk_field(message, "uuid")) else {}),
@@ -67444,8 +67519,8 @@ async def run_opencode_process(
       - The workspace is explicitly passed as ``--dir`` as well as cwd.
       - There is no init event. Every event already carries the sessionID, so
         the session is considered started at the first event of any kind.
-      - The turn ends at a ``step_finish`` whose reason is not ``tool-calls``;
-        there is no separate terminal result event.
+      - An explicit completion ``step_finish`` ends the turn; ``tool-calls``
+        continues it and invalid/unknown finishes fail closed.
       - Usage is reported per step and must be accumulated, not overwritten.
     """
     from opencode_agent_client import (
@@ -68354,10 +68429,24 @@ async def run_opencode_process(
                     opencode_usage,
                     normalized.get("usage") or {},
                 )
-                # A turn is a sequence of steps. "tool-calls" means another
-                # step follows; anything else ends the turn, and there is no
-                # separate terminal result event to wait for.
-                if str(normalized.get("reason") or "") != "tool-calls":
+                # Only explicit completion reasons end a turn. In particular,
+                # HTML-200/empty streams can yield "unknown" while the CLI
+                # immediately requests another step; waiting for exit lets it
+                # loop and hides the invalid response behind a cleanup error.
+                finish_reason = str(normalized.get("reason") or "")
+                if finish_reason not in {"tool-calls", "stop", "length", "content-filter"}:
+                    stream_error = (
+                        "OpenCode did not receive a valid completion from the "
+                        "model API. Check the endpoint URL, selected protocol "
+                        "and streaming support. The run was stopped to prevent "
+                        "repeated requests."
+                    )
+                    await terminate_process_tree(
+                        proc,
+                        grace=OPENCODE_GUARD_TEARDOWN_GRACE_SECONDS,
+                    )
+                    break
+                if finish_reason != "tool-calls":
                     await flush_opencode_reasoning()
                     terminal_event_seen = True
                     try:
@@ -73472,7 +73561,7 @@ def scheduled_job_lifecycle_admission_defer_reason(
     """
 
     if isinstance(error, TransientAdmissionWait):
-        return str(error.detail or "").strip() or "turn admission deferred"
+        return str(error.detail.get("message", "") if isinstance(error.detail, dict) else error.detail or "").strip() or "turn admission deferred"
     if not isinstance(error, HTTPException) or error.status_code != 503:
         return None
     reason = str(error.detail or "").strip()
@@ -73610,22 +73699,14 @@ def managed_server_update_scheduled_job_blocker(
     *,
     manual: bool = False,
 ) -> str | None:
-    """Fence autonomous job admission while an idle update is reserved.
-
-    A pending reservation deliberately stays invisible to ordinary user turns,
-    Force Send, provider controls, and manual Run Now. Automatic job
-    dispatches are durable and retryable, so deferring only that autonomous
-    admission path prevents recurring jobs from starving the updater without
-    reviving the global pending fence that locked operators out on
-    2026-09-04.
+    """Apply the same update admission policy to scheduled and manual work.
+
+    Waiting for idle must not manufacture idle by suspending recurring jobs.
+    Only an actual replacement/restart (or an explicitly confirmed force
+    update) fences new work, just as it does for ordinary user turns.
     """
 
-    blocker = managed_server_update_blocker()
-    if blocker:
-        return blocker
-    if not manual and managed_server_update_is_pending():
-        return MANAGED_SERVER_UPDATE_PENDING_DETAIL
-    return None
+    return managed_server_update_admission_blocker()
 
 
 def live_unsafe_http_mutation_ids_locked() -> list[str]:
@@ -77212,13 +77293,12 @@ async def lifespan(app: FastAPI):
             startup_update_status = read_server_update_status()
     active_update_schedule_id = (
         str(startup_update_status.get("schedule_id") or "").strip()
-        if managed_server_update_is_pending(startup_update_status)
+        if managed_server_force_update_is_pending(startup_update_status)
         else None
     )
-    # A completed/failed update, an offline cancellation, or replacement by a
-    # new reservation may leave exact automatic occurrences parked in the
-    # durable job registry. Rearm untouched revisions except those owned by
-    # the one reservation that is still live.
+    # Older releases parked automatic jobs while merely waiting for idle.
+    # Restore those unchanged occurrences even if that reservation still exists.
+    # Preserve only an explicitly confirmed force update's admission fence.
     await JOBS.resume_update_parked(
         active_schedule_id=active_update_schedule_id,
     )
@@ -80644,14 +80724,21 @@ async def codex_provider_mcp(request: Request) -> Response:
         client_meta = turn_meta
     run_id = str(client_meta.get("agentsdock_run_id") or "")
     proof = str(client_meta.get("agentsdock_run_proof") or "")
+    # Codex's own goal turns need not inherit turn/start client metadata.
+    # Their authenticated native thread/turn identity still has an exact
+    # server-owned supervisor. Resolve that owner, never a caller's chat ID
+    # or a previously completed run. Partially supplied proofs stay invalid.
+    native_goal_metadata = not run_id and not proof
     core_call_id = str(meta.get("callId") or "")
     if (
         not thread_id
         or len(thread_id) > 256
         or not turn_id
         or len(turn_id) > 256
-        or re.fullmatch(r"run_[A-Za-z0-9_-]{1,128}", run_id) is None
-        or re.fullmatch(r"[0-9a-f]{64}", proof) is None
+        or (not native_goal_metadata and (
+            re.fullmatch(r"run_[A-Za-z0-9_-]{1,128}", run_id) is None
+            or re.fullmatch(r"[0-9a-f]{64}", proof) is None
+        ))
         or not core_call_id
     ):
         return codex_provider_mcp_jsonrpc_error(request_id, -32602, "Incomplete turn metadata")
@@ -80666,11 +80753,18 @@ async def codex_provider_mcp(request: Request) -> Response:
                 active.get("backend") == BACKEND_CODEX
                 and active.get("transport") == CODEX_TRANSPORT_APP_SERVER
                 and str(active.get("provider_thread_id") or "") == thread_id
-                and str(active.get("run_id") or "") == run_id
+                and (
+                    codex_native_mailbox_owner_matches(
+                        session_id, str(active.get("run_id") or ""), thread_id, turn_id,
+                    ) if native_goal_metadata
+                    else str(active.get("run_id") or "") == run_id
+                )
                 and session_id in BUSY_SESSIONS
             )
         ]
         if len(owners) == 1:
+            if native_goal_metadata:
+                run_id = str(ACTIVE[owners[0]].get("run_id") or "")
             standalone_active_owner = bool(
                 (ACTIVE.get(owners[0]) or {}).get(
                     "standalone_provider_context"
@@ -80693,7 +80787,7 @@ async def codex_provider_mcp(request: Request) -> Response:
     ):
         return codex_provider_mcp_jsonrpc_error(request_id, -32602, "Ambiguous thread owner")
     expected_proof = codex_provider_mcp_run_proof(session_id, thread_id, run_id)
-    if not hmac.compare_digest(proof, expected_proof):
+    if not native_goal_metadata and not hmac.compare_digest(proof, expected_proof):
         return codex_provider_mcp_jsonrpc_error(request_id, -32602, "Invalid turn proof")
     try:
         text, is_error = await execute_provider_tool_once(
@@ -82185,15 +82279,16 @@ async def release_codex_provider_writers(manager: CodexAppServerManager, session
         try:
             await manager.request("thread/unarchive", {"threadId": thread_id})
         except CodexAppServerRequestError:
-            if thread_id == parent_id:
-                raise
+            # A lost restore response can leave the parent marker after the
+            # native rollout is already restored. Recover it idempotently too.
             # Older versions archived the parent, then tried to archive each
             # already-archived child. Their finally block restored the child
             # but left its marker. Require native relationship, terminal turn
             # and existing unarchived rollout proof before clearing it.
-            descendants = await manager.list_descendant_threads(parent_id)
-            if not any(isinstance(child, dict) and child.get("id") == thread_id for child in descendants):
-                raise
+            if thread_id != parent_id:
+                descendants = await manager.list_descendant_threads(parent_id)
+                if not any(isinstance(child, dict) and child.get("id") == thread_id for child in descendants):
+                    raise
             child = await manager.read_thread(thread_id)
             turns = await manager.list_turns(thread_id, limit=1, items_view="summary", sort_direction="desc")
             path = Path(str(child.get("path") or ""))
@@ -84198,7 +84293,7 @@ async def server_update_status(
         # second update attempt before reconnecting.
         public_status = public_server_update_status(status)
         await TERMINAL_ATTACHMENTS.reopen_if_update_inactive(public_status)
-        if managed_server_update_is_pending(status):
+        if managed_server_force_update_is_pending(status):
             await JOBS.resume_update_parked(
                 active_schedule_id=str(status.get("schedule_id") or "").strip(),
             )
@@ -84756,7 +84851,14 @@ async def _start_server_update(
                     active_session_ids = (
                         server_update_active_session_ids_locked()
                     )
-                    queued_turn_count = update_blocking_queued_turn_count_locked()
+                    # An idle update waits behind queued work too; persistence
+                    # across restart is not permission to jump ahead of it.
+                    queued_turn_count = (
+                        sum(len(queue) for queue in QUEUED_TURNS.values())
+                        + len(RUN_NOW_TURNS)
+                        if body.when_idle and not managed_server_force_update_is_pending(status)
+                        else update_blocking_queued_turn_count_locked()
+                    )
                     mutation_count = unsafe_http_mutation_count_locked()
                     duplicate_provider_labels = {
                         *(f"active chat {session_id}" for session_id in BUSY_SESSIONS),
@@ -85685,7 +85787,7 @@ async def host_diagnostics(limit: int = 40) -> dict[str, Any]:
 async def runtime_catalog(refresh: bool = False) -> dict[str, Any]:
     if refresh:
         await refresh_codex_app_server_binary(force=True)
-        await refresh_codex_app_server_login(request_handoff=True)
+        await refresh_codex_app_server_login()
     return await asyncio.to_thread(discover_runtime_catalog, force_runtime_probe=refresh)
 
 
@@ -86109,7 +86211,9 @@ async def get_session_subagents(
     session = STORE.sessions[session_id]
     if str(session.get("backend") or "") == BACKEND_CODEX and session_provider_id(session):
         try:
-            manager = await codex_app_server_manager(session)
+            # Inspect the process which still owns the children during login
+            # handoff. This read must not be rejected as a new model turn.
+            manager = await codex_app_server_manager(session, allow_retired_login=True)
             await reconcile_codex_subagents(session_id, manager)
         except Exception as exc:
             logger.warning(
@@ -86120,6 +86224,29 @@ async def get_session_subagents(
     return await asyncio.to_thread(build_subagent_snapshot, session_id, limit)
 
 
+def find_timeline_event_anchor(session_id: str, event_id: str) -> dict[str, Any] | None:
+    """Resolve a persisted pin by identity, independent of FTS text/index lag."""
+    for event in iter_session_events(session_id):
+        if event.get("id") != event_id:
+            continue
+        if str(event.get("session_id") or session_id) != session_id:
+            return None
+        seq = event.get("seq")
+        if type(seq) is not int or seq <= 0:
+            return None
+        return {"session_id": session_id, "event_id": event_id, "seq": seq,
+                "ts": event.get("ts", ""), "role": "system", "snippet": ""}
+    return None
+
+
+@app.get("/api/sessions/{session_id}/timeline-event/{event_id}")
+async def get_timeline_event_anchor(session_id: str, event_id: str) -> dict[str, Any]:
+    if session_id not in STORE.sessions:
+        raise HTTPException(status_code=404, detail="session not found")
+    anchor = await asyncio.to_thread(find_timeline_event_anchor, session_id, event_id)
+    return {"event": anchor}
+
+
 @app.get("/api/sessions/{session_id}/search")
 async def search_session_timeline(
     session_id: str,
@@ -87251,6 +87378,8 @@ async def reload_session_provider(session_id: str) -> dict[str, Any]:
                                 ),
                             )
                         await release_codex_provider_writers(manager, session_id, [provider_id])
+                if codex_provider.session_choice(session.get("codex_provider")) != "custom":
+                    await refresh_codex_app_server_login(request_handoff=True)
                 runtime = await codex_runtime_snapshot(session_id)
 
             latest_session = STORE.sessions.get(session_id) or session
@@ -88560,7 +88689,7 @@ async def _put_codex_goal_locked(
             blocker = await turn_start_blocker(ignore_session_id=session_id)
             if blocker:
                 raise HTTPException(status_code=503, detail=f"agent launch deferred: {blocker}")
-            operation_id = f"codexgoal_{uuid.uuid4().hex[:16]}"
+            operation_id = f"run_goal_{uuid.uuid4().hex[:16]}"
             subscription = manager.subscribe_thread(thread_id)
             provider_model, provider_effort, provider_service_tier = codex_runtime_settings(stored_session)
             async with ACTIVE_LOCK:
@@ -88577,6 +88706,21 @@ async def _put_codex_goal_locked(
                 if current_turn is not None:
                     current_turn["run_id"] = operation_id
                     current_turn["purpose"] = "codex_goal_resume"
+            # goal/set starts native work without passing through turn/start.
+            # Issue this new logical run's helper authority before native work
+            # can call Publish/Jobs/Mail. Reuse only existing durable routes;
+            # resuming a goal must not mint grants from its text or history.
+            resume_routes = provider_cross_chat_route_snapshot_for_authority(
+                provider_cross_chat_routes(stored_session), [], source_session_id=session_id,
+            )
+            authority_path = await issue_cross_chat_capability(
+                session_id, operation_id, [],
+                actions={"publish", "jobs", "emergency", "agent_cross_chat_routes"},
+                provider_route_snapshot=resume_routes,
+                async_route_v1=True,
+            )
+            if authority_path is None:
+                raise ProviderToolError("Could not prepare the resumed goal's tools")
             await append_event(session_id, "turn_started", {
                 "run_id": operation_id,
                 "backend": BACKEND_CODEX,
@@ -88701,6 +88845,8 @@ async def _put_codex_goal_locked(
     finally:
         if not consumer_owns_reservation:
             try:
+                if operation_id:
+                    await revoke_cross_chat_capability(operation_id)
                 if goal_activation_attempted:
                     await stop_codex_goal_resume(
                         session_id, manager, thread_id, reservation_id,
@@ -95908,7 +96054,12 @@ async def active_artifact_publication_run(
             or not isinstance(active, dict)
             or not run_id
             or str(active.get("run_id") or "").strip() != run_id
-            or active.get("codex_native_operation") is True
+            or (active.get("codex_native_operation") is True
+                and not codex_native_mailbox_owner_matches(
+                    session_id, run_id,
+                    str(active.get("provider_thread_id") or ""),
+                    str(active.get("provider_turn_id") or ""),
+                ))
             or active.get("stop_requested") is True
             or run_id in STOPPED_RUNS
         ):