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

package/npm/cli.cjs

@@ -66,7 +66,8 @@ function ensureFreshInstall(context) {
   if (context.uid === 0) throw new Error('Run as the user who will own the server, without sudo.')
   if (!['darwin', 'linux'].includes(context.platform)) throw new Error('Server installation requires Linux or Apple silicon macOS.')
   for (const name of ROOT_SELECTORS) if (context.env[name]) throw new Error(`Custom installation selector ${name} is unsupported by the fresh-install CLI. Use the existing server's managed updater.`)
-  const existingInstall = () => new Error('An existing server installation or state was found. Use AgentsDock or agentsdock-server update; no installer was started.')
+  const existingInstall = (message = 'An existing server installation or state was found. Use AgentsDock or agentsdock-server update; no installer was started.') =>
+    Object.assign(new Error(message), { code: 'AGENTSDOCK_EXISTING_INSTALLATION' })
   const safeDirectory = info => info.isDirectory() && !info.isSymbolicLink() && info.uid === context.uid && (info.mode & 0o022) === 0 && (info.mode & 0o500) === 0o500
   const allowEmptyScaffold = (relative, child) => {
     const root = path.join(context.home, relative)
@@ -100,11 +101,14 @@ function ensureFreshInstall(context) {
   }
   if (context.platform === 'darwin') {
     const check = context.spawn('/bin/launchctl', ['print', `gui/${context.uid}/com.agentsdock.server`], { encoding: 'utf8', timeout: 10000 })
-    if (check.status === 0) throw new Error('An AgentsServer service already exists. Use its managed updater.')
+    if (check.status === 0) throw existingInstall('An AgentsServer service already exists. Use its managed updater.')
     if (check.error || !/could not find service|service.*not found/i.test(`${check.stdout || ''} ${check.stderr || ''}`)) throw new Error('Could not verify the user service is absent. No installer was started.')
   } else {
     for (const unit of ['agents-server.service', 'zenithbot-agent.service']) {
       const check = context.spawn('systemctl', ['--user', 'show', unit, '--property=LoadState', '--value'], { encoding: 'utf8', timeout: 10000 })
+      if (!check.error && check.status === 0 && String(check.stdout).trim() && String(check.stdout).trim() !== 'not-found') {
+        throw existingInstall('An existing user service was found. Use its managed updater.')
+      }
       if (check.error || String(check.stdout).trim() !== 'not-found') throw new Error('An existing user service was found or its absence could not be verified. Use its managed updater.')
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsdock/server",
-  "version": "1.0.10-beta.1",
+  "version": "1.0.10-beta.4",
   "description": "AgentsDock's self-hosted Python server and explicit installation CLI",
   "license": "Apache-2.0",
   "repository": {

package/server/VERSION

@@ -1 +1 @@
-1.0.10-beta.1
+1.0.10-beta.4

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 {}),
@@ -73472,7 +73547,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 +73685,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 +77279,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 +80710,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 +80739,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 +80773,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 +82265,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 +84279,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 +84837,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 +85773,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 +86197,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 +86210,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 +87364,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 +88675,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 +88692,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 +88831,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 +96040,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
         ):

package/server/claude_goals.py

@@ -138,13 +138,19 @@ class ClaudeGoalProjection:
     def consume(self, event: Any) -> bool:
         """Fold one native JSONL record; return whether visible goal changed."""
         if not isinstance(event, dict) or (
-            event.get("type") != "attachment"
+            event.get("type") not in {"attachment", "system"}
             or event.get("sessionId") != self.provider_session_id
             or event.get("isSidechain") is not False
         ):
             return False
         attachment = event.get("attachment")
-        if not isinstance(attachment, dict) or attachment.get("type") != "goal_status":
+        content = event.get("content")
+        stopped = (event.get("type") == "system" and event.get("subtype") == "informational"
+                   and event.get("level") == "warning" and isinstance(content, str)
+                   and re.match(r"\AA hook blocked the turn from ending [0-9]+ consecutive times [—-] overriding and ending turn\.", content))
+        if stopped:
+            attachment = {"type": "goal_status", "condition": (self.goal or {}).get("condition"), "met": False}
+        elif not isinstance(attachment, dict) or attachment.get("type") != "goal_status":
             return False
         event_id = event.get("uuid")
         if not isinstance(event_id, str) or len(event_id) != 36:
@@ -175,10 +181,16 @@ class ClaudeGoalProjection:
                 return False
             goal = dict(previous)
             goal["status"] = "cleared" if sentinel else "achieved" if met else "active"
+            if stopped:
+                goal["execution_stop_reason"] = "continuation_limit"
+                goal["execution_stopped_at"] = timestamp
+            else:
+                goal.pop("execution_stop_reason", None)
+                goal.pop("execution_stopped_at", None)
             if sentinel:
                 for field in ("iterations", "duration_ms", "tokens"):
                     goal.pop(field, None)
-            if not sentinel:
+            if not sentinel and not stopped:
                 reason = attachment.get("reason")
                 if isinstance(reason, str) and reason:
                     goal["last_reason"] = reason[:8192]
@@ -233,7 +245,7 @@ class ClaudeGoalProjection:
             if self._discard_line:
                 self._discard_line = False
                 continue
-            if len(line) > MAX_GOAL_RECORD_BYTES or b'"goal_status"' not in line:
+            if len(line) > MAX_GOAL_RECORD_BYTES or not (b'"goal_status"' in line or b"A hook blocked the turn from ending" in line):
                 continue
             try:
                 self.consume(json.loads(line))

package/server/codex_app_server.py

@@ -1088,6 +1088,8 @@ class CodexAppServerClient:
         self._next_id += 1
         request_id = self._next_id
         future: asyncio.Future[Any] = loop.create_future()
+        # Preserve request ownership for per-chat process handoff.
+        future._codex_thread_id = str((params or {}).get("threadId") or (params or {}).get("ancestorThreadId") or "")
         self._pending[request_id] = (
             method,
             future,
@@ -1557,6 +1559,7 @@ class CodexAppServerClient:
                         previous,
                     )
                 )
+            task._codex_thread_id = thread_id
             self._callback_tails[owner] = task
             self._callback_tasks.add(task)
             task.add_done_callback(
@@ -1619,6 +1622,7 @@ class CodexAppServerClient:
             self._handle_server_request(request_id, method, params),
             name=f"codex-app-server-request-{request_id}",
         )
+        task._codex_thread_id = str(params.get("threadId") or "")
         self._server_request_tasks[request_id] = task
         task.add_done_callback(
             lambda done, rid=request_id: self._finish_server_request(rid, done)

package/server/codex_auth.py

@@ -28,6 +28,37 @@ HANDOFF_MESSAGE = (
 )
 _REVISION_KEY = secrets.token_bytes(32)
 _MAX_AUTH_BYTES = 128 * 1024
+HANDOFF_PROBE_FAILURES = frozenset({"thread_list_unavailable", "goal_state_unavailable",
+    "terminal_state_unavailable", "ownership_deadline", "native_unsubscribe_incomplete", "writer_release_failed"})
+
+
+def handoff_detail(reason: str) -> dict:
+    """Content-free admission status, distinct from a native auth rejection."""
+    reasons = {
+        "active_turn": "this chat still has a running turn",
+        "maintenance": "this chat is finishing a provider operation",
+        "approval": "this chat has an unanswered approval or question",
+        "side_chat": "this chat has a running Side chat",
+        "active_goal": "this chat has an active goal",
+        "native_goal_active": "Codex reports an active goal for this chat",
+        "subagents": "this chat has running subagents",
+        "callback": "this chat is finishing a provider notification",
+        "runtime_request": "a provider request for this chat is still finishing",
+        "native_thread_in_use": "Codex still has work using this thread",
+        "background_terminals": "this chat has a running background terminal",
+        "thread_list_unavailable": "Codex could not report which threads it owns",
+        "goal_state_unavailable": "Codex could not report this chat's goal state",
+        "terminal_state_unavailable": "Codex could not report this chat's background terminals",
+        "ownership_deadline": "Codex took too long to report this chat's state",
+        "native_unsubscribe_incomplete": "Codex has not released this thread yet",
+        "writer_release_failed": "Codex could not release the old connection to this thread",
+    }
+    reason = reason if reason in reasons else "runtime_request"
+    action = ("Retry the message to check again." if reason in HANDOFF_PROBE_FAILURES
+              else "Retry after that operation finishes.")
+    return {"code": "codex_login_handoff", "reason": reason, "retryable": True,
+            "message": f"Codex sign-in handoff is waiting: {reasons[reason]}. "
+                       f"Your message has not been sent. {action}"}
 
 
 @dataclass(frozen=True)

package/server/codex_history_repair.py

@@ -202,10 +202,26 @@ def _native_records(path: Path, expected: tuple[int, int, int, int], budget: _Na
 
 def _native_event_identity(event: dict) -> dict:
     """Keep bounded public identity, never retain tool bodies or message text."""
-    return {key: event[key] for key in ("id", "seq", "type", "phase", "item_id")
+    return {key: event[key] for key in ("id", "seq", "type", "phase", "item_id", "provider_thread_id", "provider_turn_id")
             if key in event and (type(event[key]) is int or isinstance(event[key], str) and len(event[key]) <= 256)}
 
 
+def _native_goal_steer_turn(event: dict) -> str | None:
+    """Accepted goal follow-ups already have a user bubble in this chat.
+
+    Keep their exact native turn: one goal run can span many provider turns,
+    including later genuine messages with identical text.
+    """
+    turn = event.get("provider_turn_id")
+    if (event.get("type") == "turn_steered" and event.get("backend") == "codex"
+        and event.get("purpose") == "codex_goal_resume"
+        and event.get("native_goal_steer") is True and event.get("native_steer") is True
+        and event.get("provider_user_authored") is True
+        and isinstance(turn, str) and 0 < len(turn) <= 256):
+        return turn
+    return None
+
+
 def _native_import_batch(event: dict) -> dict:
     result = {key: event.get(key) for key in ("seq", "provider_session_id", "source_path")}
     checkpoint = event.get("_history_sync_checkpoint")
@@ -242,10 +258,13 @@ def _native_owned_turn_ids(event: dict) -> set[str]:
             if isinstance(value := event.get(field), str) and 0 < len(value) <= 256}
 
 
-def _native_assistant_item_owners(assistant_items: dict, completed_runs: set[str]) -> dict:
+def _native_assistant_item_owners(assistant_items: dict, completed_runs: set[str], provider_id: str) -> dict:
     owners: dict = {}
-    for run, item_id, body_key in assistant_items:
-        if run in completed_runs:
+    for (run, item_id, body_key), event in assistant_items.items():
+        # A restart or Stop can omit the completion receipt. An exact public
+        # item already delivered by this provider thread still identifies its
+        # native run; source reconciliation below supplies the matching turn.
+        if run in completed_runs or event.get("provider_thread_id") == provider_id:
             owners.setdefault((item_id, body_key), set()).add(run)
     return owners
 
@@ -856,7 +875,7 @@ def _prove_native_replays(session_id: str, provider_id: str, events: Path, sourc
                         owned = owners.setdefault((thread, turn), set())
                         retained += run not in owned
                         owned.add(run)
-            kind = "user" if event.get("type") == "turn_started" else "assistant" if event.get("type") in ("assistant_text", "reasoning_summary", "turn_finished") else None
+            kind = "user" if event.get("type") == "turn_started" or _native_goal_steer_turn(event) else "assistant" if event.get("type") in ("assistant_text", "reasoning_summary", "turn_finished") else None
             body = event.get("prompt") if kind == "user" else event.get("result_text") if event.get("type") == "turn_finished" else event.get("text")
             if kind and isinstance(body, str) and body and len(body) <= 4 * 1024 * 1024:
                 native.setdefault((run, kind, _text_key(body)), []).append(_native_event_identity(event))
@@ -935,14 +954,14 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
     assistant_native_keys = {}
     compactions, candidate_assistants = {}, set()
     compaction_tracker = CodexCompactionSummaryTracker(thread)
-    delivery_bodies, delivery_source_ids = {}, {}
+    delivery_bodies, delivery_source_ids, full_user_keys = {}, {}, {}
     completed_runs = {run for (owner_thread, _turn), runs in owners.items()
                       if owner_thread == thread for run in runs}
     assistant_item_owners = _native_assistant_item_owners({
         (run, item_id, body_key): event
         for (run, kind, body_key), events in native.items() if kind == "assistant"
         for event in events if (item_id := _public_assistant_item_id(event)) is not None
-    }, completed_runs)
+    }, completed_runs, thread)
     assistant_owner_evidence: dict = {}
     assistant_source_turns: dict = {}
     allowed_header_owners, header_parents = {thread}, {}
@@ -1016,6 +1035,21 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
                 raise _Unproven()
         if (item["kind"], key[2], key[3]) not in candidate_keys:
             continue
+        if item["kind"] == "user" and key[3] is not None:
+            # A display-trimmed input still has its complete source in this
+            # checkpoint-verified record. Compare those bytes to the original
+            # native input, never a shared preview or an unverified hash.
+            full_text = None
+            if record.get("type") == "event_msg" and payload.get("type") == "user_message":
+                full_text = payload.get("message")
+            elif record.get("type") == "response_item" and payload.get("role") == "user":
+                blocks = payload.get("content")
+                if (isinstance(blocks, list) and len(blocks) == 1 and isinstance(blocks[0], dict)
+                    and blocks[0].get("type") == "input_text"):
+                    full_text = blocks[0].get("text")
+            if (isinstance(full_text, str) and full_text
+                and _text_key(" ".join(full_text.split())) == key[3]):
+                full_user_keys[key] = _text_key(full_text)
         if item["kind"] == "user" and (body := _async_delivery_body(item["text"])):
             delivery_bodies[key] = body
         if item["kind"] == "assistant":
@@ -1073,9 +1107,7 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
             if len(proofs) > MAX_TARGETS:
                 raise _Unproven()
             continue
-        if len(source_ids) != 1 or source_hash is not None:
-            # Truncated source hashes need a separately retained native full-body
-            # hash. Until one exists, the bounded preview cannot prove equality.
+        if len(source_ids) != 1 or source_hash is not None and key not in full_user_keys:
             continue
         source_origin = next(iter(source_ids.values()))
         if source_origin.get("kind") in ("subagent_notification", "turn_aborted", "provider_notice"):
@@ -1087,8 +1119,10 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
         if len(owned_runs) != 1:
             continue
         native_run = next(iter(owned_runs))
-        native_matches = native.get((native_run, kind, body_key), [])
-        if not native_matches and kind == "user":
+        native_body_key = full_user_keys.get(key, body_key)
+        native_matches = [event for event in native.get((native_run, kind, native_body_key), [])
+                          if event.get("type") != "turn_steered" or event.get("provider_turn_id") == key[0]]
+        if not native_matches and kind == "user" and source_hash is None:
             delivery = deliveries.match(session_id, thread, native_run, source_origin,
                                         delivery_bodies.get(key), delivery_source_ids.get(key[0], set()), body_key)
             if delivery is not None:
@@ -1105,7 +1139,7 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
         if not native_matches:
             continue
         representative = min(native_matches, key=lambda event: event["seq"])
-        proofs[target] = {**next(iter(source_ids.values())), "native_event_id": representative["id"], "source_text_sha256": body_key}
+        proofs[target] = {**next(iter(source_ids.values())), "native_event_id": representative["id"], "source_text_sha256": native_body_key}
         if len(proofs) > MAX_TARGETS:
             raise _Unproven()
     budget.check()
@@ -1183,10 +1217,10 @@ class CodexNativeHistoryRepairCache(CodexGoalHistoryRepairCache):
                 **({"_agentsdock_imported_prompt_hidden": True} if event["type"] == "turn_started" else {})}
 
 
-def _prove_pending_async_deliveries(session_id: str, provider_id: str, items: list[dict],
+def _prove_pending_native_inputs(session_id: str, provider_id: str, items: list[dict],
                                     source: Path, root: Path, checkpoint: dict, parse_item: Callable,
                                     previous_seq: int, owners: dict, deliveries: _AsyncDeliveryIndex,
-                                    budget: _NativeReadBudget) -> dict:
+                                    budget: _NativeReadBudget, native_inputs: dict | None = None) -> dict:
     """Reuse pinned-prefix proof before broadcast; the synthetic batch is never stored."""
     cursor = checkpoint.get("cursor")
     if (checkpoint.get("version") != 1 or not isinstance(cursor, dict) or cursor.get("version") != 1
@@ -1195,16 +1229,21 @@ def _prove_pending_async_deliveries(session_id: str, provider_id: str, items: li
         raise _Unproven()
     run = "import_pending_native_delivery_proof"
     candidates, indexes = [], {}
+    steer_keys = {key[2] for key, events in (native_inputs or {}).items()
+                  if key[1] == "user" and any(event.get("type") == "turn_steered" for event in events)}
     for index, item in enumerate(items):
         budget.check()
         origin = item.get("provider_origin")
         if (item.get("kind") != "user" or not isinstance(item.get("text"), str)
             or not isinstance(origin, dict) or origin.get("provider") != "codex" or origin.get("kind") != "user"
-            or origin.get("session_id", provider_id) != provider_id or item.get("source_text_sha256") is not None
-            or not (_async_delivery_body(item["text"]) or _text_key(item["text"]) in deliveries.status_body_keys)):
+            or origin.get("session_id", provider_id) != provider_id
+            or not (item.get("source_text_sha256") is not None
+                    or _async_delivery_body(item["text"]) or _text_key(item["text"]) in deliveries.status_body_keys
+                    or _text_key(item["text"]) in steer_keys)):
             continue
         candidate = _replay_target({"seq": previous_seq + index + 2, "id": f"pending:{index}", "run_id": run,
             "type": "turn_started", "backend": "codex", "imported": True, "prompt": item["text"],
+            "source_text_sha256": item.get("source_text_sha256"),
             "ts": origin.get("timestamp"), "provider_user_authored": _runtime_human_provenance(item)})
         if candidate is not None:
             candidates.append(candidate)
@@ -1214,7 +1253,7 @@ def _prove_pending_async_deliveries(session_id: str, provider_id: str, items: li
     if not candidates:
         return {}
     proof = _prove_native_source(provider_id, source, root,
-        {run: (previous_seq + 1, previous_seq + len(items) + 2, checkpoint)}, candidates, {},
+        {run: (previous_seq + 1, previous_seq + len(items) + 2, checkpoint)}, candidates, native_inputs or {},
         {(provider_id, turn): runs for turn, runs in owners.items()}, parse_item, budget,
         session_id=session_id, deliveries=deliveries, require_verified_checkpoint=True)
     result = {}
@@ -1234,10 +1273,10 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
                                       parse_item: Callable[[dict], dict | None] | None = None) -> list[dict]:
     """An existing verified import boundary can omit exact completed native copies.
 
-    Exact native bodies need only the ledger. Legacy async wrappers additionally
-    require the caller's source/checkpoint/parser and one verified source-prefix
-    scan: a delta range alone cannot disambiguate a later same-turn human quote.
-    Missing source context leaves those wrappers visible for later read repair.
+    Exact native bodies need only the ledger. Legacy async wrappers and trimmed
+    user inputs additionally require the caller's source/checkpoint/parser and
+    one verified source-prefix scan. A preview alone never proves equality.
+    Missing source context leaves those inputs visible for later read repair.
     Incomplete proof raises; the caller must defer import and its cursor commit.
     """
     if not items:
@@ -1248,6 +1287,7 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
         budget = _NativeReadBudget(cancelled, deadline)
         stamp = _native_stamp(events)
         owners, native, assistant_items, wake_keys, native_count = {}, {}, {}, set(), 0
+        native_inputs, steered_inputs = {}, {}
         deliveries = _AsyncDeliveryIndex()
         prove_deliveries = (source_path is not None and root is not None
             and isinstance(sync_checkpoint, dict) and callable(parse_item)
@@ -1273,24 +1313,31 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
                     owned = owners.setdefault(turn_id, set())
                     owner_count += run not in owned
                     owned.add(run)
-            kind = "user" if event.get("type") == "turn_started" else "assistant" if event.get("type") in ("assistant_text", "reasoning_summary", "turn_finished") else None
+            steer_turn = _native_goal_steer_turn(event)
+            kind = "user" if event.get("type") == "turn_started" or steer_turn else "assistant" if event.get("type") in ("assistant_text", "reasoning_summary", "turn_finished") else None
             body = event.get("prompt") if kind == "user" else event.get("result_text") if event.get("type") == "turn_finished" else event.get("text")
             wake_hash = _native_mailbox_wake_hash(event) if kind == "user" else None
             if kind and (isinstance(body, str) and body or wake_hash):
-                keys = native.setdefault(run, {})
+                keys = steered_inputs.setdefault((run, steer_turn), {}) if steer_turn else native.setdefault(run, {})
                 key = (kind, wake_hash or _text_key(body))
                 native_count += key not in keys
                 if isinstance(event.get("id"), str) and 0 < len(event["id"]) <= 256:
                     keys.setdefault(key, event["id"])
+                    if prove_deliveries and kind == "user" and isinstance(body, str) and body:
+                        inputs = native_inputs.setdefault((run, kind, key[1]), [])
+                        if not any(prior.get("type") == event.get("type")
+                                   and prior.get("provider_turn_id") == event.get("provider_turn_id") for prior in inputs):
+                            inputs.append(_native_event_identity(event))
+                            native_count += 1
                     if wake_hash:
                         wake_keys.add((run, wake_hash))
                     item_id = _public_assistant_item_id(event)
                     if item_id is not None:
-                        assistant_items[(run, item_id, key[1])] = event["id"]
+                        assistant_items[(run, item_id, key[1])] = _native_event_identity(event)
             if native_count + owner_count + len(assistant_items) + deliveries.count > MAX_KEYS:
                 raise _Unproven()
         assistant_item_owners = _native_assistant_item_owners(
-            assistant_items, {run for runs in owners.values() for run in runs},
+            assistant_items, {run for runs in owners.values() for run in runs}, provider_id,
         )
         assistant_source_turns: dict = {}
         for item in items:
@@ -1308,10 +1355,17 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
         for item_key, turns in assistant_source_turns.items():
             if len(turns) == 1:
                 owners.setdefault(next(iter(turns)), set()).update(assistant_item_owners[item_key])
-        delivery_proofs = _prove_pending_async_deliveries(
+        if prove_deliveries and steered_inputs:
+            # The unmatched import can contain only follow-ups: its assistant
+            # messages were already reconciled. Preserve public item identities
+            # for the source scan to recover earlier turns of a long goal run.
+            for (run, _item_id, body_key), event in assistant_items.items():
+                native_inputs.setdefault((run, "assistant", body_key), []).append(event)
+        delivery_proofs = _prove_pending_native_inputs(
             session_id, provider_id, items, source_path, root, sync_checkpoint, parse_item,
-            previous_seq, owners, deliveries, budget,
-        ) if prove_deliveries and deliveries.starts else {}
+            previous_seq, owners, deliveries, budget, native_inputs,
+        ) if prove_deliveries and (deliveries.starts or steered_inputs or any(
+            item.get("kind") == "user" and item.get("source_text_sha256") is not None for item in items)) else {}
         # A hidden wake has no public prompt body. Require a single exact source
         # item in this verified import range, in addition to native turn ownership.
         wake_source_ids = {}
@@ -1332,9 +1386,15 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
                      and origin.get("session_id", provider_id) == provider_id and len(runs) == 1
                      and item.get("source_text_sha256") is None and isinstance(item.get("text"), str))
             known = owned and (item["kind"], _text_key(item["text"])) in native.get(next(iter(runs)), {})
-            delivery = delivery_proofs.get(index) if owned else None
+            # Steers never use delta-local text equality as proof. An equal
+            # source item can precede this delta's checkpoint in the same
+            # native turn. Only the full verified prefix can establish that
+            # this source occurrence is the already-shown follow-up.
+            # This proof already established exact source bytes, native owner,
+            # original event and checkpoint even when the display is trimmed.
+            delivery = delivery_proofs.get(index)
             known = known or delivery is not None
-            if known and (next(iter(runs)), _text_key(item["text"])) in wake_keys:
+            if known and runs and (next(iter(runs)), _text_key(item["text"])) in wake_keys:
                 known = (bool(origin.get("event_id")) and bool(origin.get("timestamp"))
                          and len(wake_source_ids.get((origin.get("turn_id"), _text_key(item["text"])), set())) == 1)
             if owned and not known and item["kind"] == "assistant":
@@ -1350,7 +1410,7 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
                     "provider_history_repair": "source_proven_native_replay",
                     "provider_origin": {**origin, "session_id": provider_id,
                         "native_event_id": delivery["native_event_id"] if delivery else native[next(iter(runs))][key],
-                        "source_text_sha256": key[1]}})
+                        "source_text_sha256": delivery["source_text_sha256"] if delivery else key[1]}})
         budget.check()
         return result
     except (OSError, ValueError, TypeError, KeyError, RuntimeError) as exc:

package/server/server_instances.py

@@ -17,6 +17,7 @@ import os
 from pathlib import Path
 import plistlib
 import re
+import select
 import shlex
 import shutil
 import socket
@@ -24,7 +25,9 @@ import stat
 import subprocess
 import sys
 import tempfile
+import termios
 import time
+import tty
 from urllib.parse import urlsplit
 
 INSTANCE_PROTOCOL = 1
@@ -611,6 +614,147 @@ def show(instance: Instance, *, network: dict[str, str] | None = None):
     print()
 
 
+def show_status(instance: Instance, *, network: dict[str, str]) -> None:
+    """Read-only per-instance summary; never print configuration or tokens."""
+    item = describe(instance)
+    print(terminal_color(f"Server ({item['name']}):", "34"))
+    print(f"  Status:   {item['status']}")
+    addresses = []
+    if item["port"]:
+        choices = connection_choices(read_config(instance).get("AGENTSDOCK_AGENT_BIND", "0.0.0.0"),
+                                     item["port"], item["addresses"], network)
+        if choices["tailscale"]:
+            addresses.append(f"{choices['tailscale']} (Tailscale / other networks)")
+        for key, label in (("lan", "Same Wi-Fi / LAN"), ("local", "This machine only"),
+                           ("other", "Other / unverified")):
+            addresses.extend(f"{url} ({label})" for url in choices[key])
+    print("  Address:  " + (addresses[0] if addresses else "Not configured"))
+    for address in addresses[1:]:
+        print("            " + address)
+    print(f"  Version:  {item['version'] or 'unknown'}")
+    print(f"  Port:     {item['port'] or 'Not configured'}")
+    print()
+
+
+def read_token_menu_key(fd: int) -> str:
+    key = os.read(fd, 1)
+    if key in (b"", b"\x03", b"\x04"):
+        return "cancel"
+    if key in (b"\r", b"\n"):
+        return "enter"
+    if key != b"\x1b":
+        return "other"
+    sequence = b""
+    while len(sequence) < 16 and select.select([fd], [], [], 0.15)[0]:
+        part = os.read(fd, 1)
+        if not part:
+            return "cancel"
+        sequence += part
+        if sequence in (b"[A", b"OA"):
+            return "up"
+        if sequence in (b"[B", b"OB"):
+            return "down"
+        if sequence[:1] not in (b"[", b"O") or (len(sequence) > 1 and 0x40 <= part[0] <= 0x7e):
+            return "other"
+    return "cancel" if not sequence else "other"
+
+
+def arrow_token_choice(rows: list[str], fd: int, settings: list) -> int | None:
+    """Render a bounded terminal menu and restore input mode before token output."""
+    size = shutil.get_terminal_size(fallback=(80, 24))
+    visible = min(len(rows), max(1, size.lines - 6), 10)
+    width = max(1, size.columns - 1)
+    selected, start = 0, 0
+    hint = "Use ↑/↓ to choose; Enter to select; Esc to cancel."
+
+    def render(redraw=False):
+        if redraw:
+            sys.stdout.write(f"\x1b[{visible + 1}A")
+        for index in range(start, start + visible):
+            row = ("  > " if index == selected else "    ") + rows[index]
+            row = row[:width]
+            if index == selected:
+                row = terminal_color(row, "1;36")
+            sys.stdout.write("\r\x1b[2K" + row + "\n")
+        sys.stdout.write("\r\x1b[2K" + hint[:width] + "\n")
+        sys.stdout.flush()
+
+    try:
+        tty.setcbreak(fd, termios.TCSANOW)
+        sys.stdout.write("\x1b[?25l")
+        render()
+        while True:
+            key = read_token_menu_key(fd)
+            if key == "cancel":
+                return None
+            if key == "enter":
+                return selected
+            if key not in ("up", "down"):
+                continue
+            selected = (selected + (1 if key == "down" else -1)) % len(rows)
+            start = min(start, selected) if selected < start else max(start, selected - visible + 1)
+            render(redraw=True)
+    except KeyboardInterrupt:
+        return None
+    finally:
+        termios.tcsetattr(fd, termios.TCSANOW, settings)
+        sys.stdout.write("\x1b[?25h\n")
+        sys.stdout.flush()
+
+
+def choose_token_instance(registry: Registry) -> Instance | None:
+    """Select by stable instance name; never default or expose unselected tokens."""
+    items = registry.instances()
+    if not items:
+        print("No installations found. Run agentsdock setup to create your first server.")
+        return None
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        raise ValueError("Choose a server in an interactive terminal, or run agentsdock token NAME "
+                         "(for example: agentsdock token default). No token was shown.")
+    print("\nChoose a server to view its access token:\n")
+    rows = []
+    for index, instance in enumerate(items, 1):
+        config = read_config(instance)
+        port = config.get("AGENTSDOCK_AGENT_PORT") or "not configured"
+        rows.append(f"{instance.name:<20} {service_status(instance):<10} Port: {port}")
+    if os.environ.get("TERM", "dumb") not in ("", "dumb"):
+        try:
+            fd = sys.stdin.fileno()
+            settings = termios.tcgetattr(fd)
+        except (OSError, ValueError, termios.error):
+            pass  # Basic terminals retain the explicit numbered/name prompt.
+        else:
+            index = arrow_token_choice(rows, fd, settings)
+            if index is None:
+                print("Cancelled; no token was shown.")
+                return None
+            selected = items[index]
+            if selected.name not in {item.name for item in registry.instances()}:
+                raise ValueError("That server is no longer available. Run agentsdock token again. No token was shown.")
+            return selected
+    for index, row in enumerate(rows, 1):
+        print(f"  {index}. {row}")
+    print()
+    names = {item.name: item for item in items}
+    while True:
+        try:
+            answer = input("Enter a number or server name (Enter to cancel): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            answer = ""
+        if not answer:
+            print("Cancelled; no token was shown.")
+            return None
+        selected = names.get(answer)
+        if re.fullmatch(r"[1-9][0-9]{0,5}", answer) and int(answer) <= len(items):
+            selected = items[int(answer) - 1]
+        if selected is not None:
+            if selected.name not in {item.name for item in registry.instances()}:
+                raise ValueError("That server is no longer available. Run agentsdock token again. No token was shown.")
+            return selected
+        print(f"Please enter a number from 1 to {len(items)} or a listed server name (Enter cancels).")
+
+
 def terminal_color(text: str, code: str) -> str:
     color = sys.stdout.isatty() and os.environ.get("TERM") != "dumb" and "NO_COLOR" not in os.environ
     return f"\033[{code}m{text}\033[0m" if color else text
@@ -747,8 +891,11 @@ def parser() -> argparse.ArgumentParser:
     result = argparse.ArgumentParser(description="Independent AgentsServer instances for the current OS user. Defaults to list.")
     commands = result.add_subparsers(dest="command")
     commands.add_parser("list")
+    commands.add_parser("token", help="Choose an existing server and display only its access token")
     info = commands.add_parser("info")
     info.add_argument("name", type=instance_name)
+    status = commands.add_parser("status", help="Show readable details for all instances or one name")
+    status.add_argument("name", nargs="?", type=instance_name)
     new = commands.add_parser("new")
     new.add_argument("--name", type=instance_name)
     new.add_argument("--port", type=int)
@@ -785,13 +932,30 @@ def main(argv: list[str] | None = None) -> int:
             validate_binding(instance)
             print(instance.shell_bindings())
             return 0
-        if args.command in {None, "list", "info"}:
+        if args.command == "token":
+            selected = choose_token_instance(registry)
+            if selected is None:
+                return 0
+            try:
+                run(["/bin/bash", str(ROOT / "install.sh"), "--instance", selected.name, "--show-token"],
+                    env=clean_environment(selected), cwd=ROOT)
+                return 0
+            except subprocess.CalledProcessError as exc:
+                return exc.returncode if exc.returncode > 0 else 1
+        if args.command in {None, "list", "info", "status"}:
             items = registry.instances()
-            if args.command == "info":
+            if args.command in {"info", "status"} and args.name:
                 items = [item for item in items if item.name == args.name]
                 if not items:
                     raise ValueError("Unknown instance.")
+            if args.command == "info":
                 print(json.dumps(describe(items[0]), indent=2))
+            elif args.command == "status":
+                network = tailscale_status() if items else None
+                for item in items:
+                    show_status(item, network=network)
+                if not items:
+                    print("No installations found. Run agentsdock setup to create your first server.")
             else:
                 network = tailscale_status() if items else None
                 print("NAME                 STATUS     PORT")