@agentsdock/server 1.0.9 → 1.0.10-beta.4

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
 
@@ -659,16 +678,36 @@ class _AsyncDeliveryIndex:
     starts: dict = field(default_factory=dict)
     ends: dict = field(default_factory=dict)
     receipts: dict = field(default_factory=dict)
+    status_queues: dict = field(default_factory=dict)
+    status_body_keys: set = field(default_factory=set)
     steered: set = field(default_factory=set)
     count: int = 0
 
     def observe(self, event: dict) -> None:
         event_type = event.get("type")
-        if (event_type not in {"turn_started", "turn_finished", "turn_steered", "turn_stopped", "turn_queue_run_now",
+        if (event_type not in {"turn_queued", "turn_started", "turn_finished", "turn_steered", "turn_stopped", "turn_queue_run_now",
                               "chat_conversation_message_received", "chat_conversation_message_started", "chat_conversation_message_delivered"}
             or event.get("imported") is True or event.get("forked") is True
             or event.get("backend") not in (None, "codex")):
             return
+        if event_type == "turn_queued":
+            # The private durable request is exact provider input. Public display
+            # labels and wrapper-looking text are never evidence by themselves.
+            queued_id, body = event.get("queued_id"), event.get("request_prompt")
+            if (event.get("purpose") == "cross_chat_handoff_delivery"
+                and event.get("cross_chat_exchange_status") is True
+                and not _runtime_human_provenance(event)
+                and isinstance(queued_id, str) and 0 < len(queued_id) <= 256
+                and isinstance(body, str) and 0 < len(body) <= NATIVE_PROOF_LINE_BYTES):
+                record = {key: event.get(key) for key in ("seq", "cross_chat_exchange_id",
+                    "cross_chat_exchange_leg_id", "source_session_id", "target_session_id")}
+                record["body_key"] = _text_key(body)
+                self.status_queues.setdefault(queued_id, []).append(record)
+                self.status_body_keys.add(record["body_key"])
+                self.count += 1
+                if self.count > MAX_KEYS:
+                    raise _Unproven()
+            return
         run = (event.get("interrupted_run_id") or event.get("run_id")) if event_type == "turn_queue_run_now" else event.get("run_id")
         if (event_type in {"turn_steered", "turn_stopped"} or event.get("native_steer") is True):
             if isinstance(run, str) and 0 < len(run) <= 256 and not run.startswith("import_"):
@@ -686,7 +725,8 @@ class _AsyncDeliveryIndex:
             "provider_thread_id", "provider_turn_id", "cross_chat_envelope_id", "handoff_id", "message_id",
             "source_session_id", "target_session_id", "source_title", "target_run_id", "conversation_mode",
             "kind", "action", "handoff_action", "handoff_body_chars", "handoff_body_sha256",
-            "message_revision", "message_edited_by_user", "exchange_id", "cross_chat_exchange_id")
+            "message_revision", "message_edited_by_user", "exchange_id", "cross_chat_exchange_id",
+            "cross_chat_exchange_leg_id", "cross_chat_exchange_status", "queued_id")
         record = {key: event.get(key) for key in fields
                   if event.get(key) is None or type(event.get(key)) in (int, bool)
                   or isinstance(event.get(key), str) and len(event[key]) <= 512}
@@ -710,11 +750,36 @@ class _AsyncDeliveryIndex:
             raise _Unproven()
 
     def match(self, session_id: str, provider_id: str, run: str, origin: dict,
-              body: tuple[str, str, int] | None, source_ids: set) -> dict | None:
+              body: tuple[str, str, int] | None, source_ids: set, body_key: str = "") -> dict | None:
         starts, ends = self.starts.get(run, []), self.ends.get(run, [])
-        if body is None or len(starts) != 1 or len(ends) != 1 or run in self.steered:
+        if len(starts) != 1 or len(ends) != 1 or run in self.steered:
             return None
         start, end = starts[0], ends[0]
+        if start.get("cross_chat_exchange_status") is True:
+            queued = self.status_queues.get(start.get("queued_id"), [])
+            if len(queued) != 1:
+                return None
+            receipt = queued[0]
+            identity = ("cross_chat_exchange_id", "cross_chat_exchange_leg_id",
+                        "source_session_id", "target_session_id")
+            if (start.get("malformed") or end.get("malformed") or not start.get("body_key")
+                or any(not isinstance(start.get(key), str) or not start[key]
+                       or receipt.get(key) != start[key] or end.get(key) != start[key] for key in identity)
+                or start.get("target_session_id") != session_id or start.get("source_session_id") == session_id
+                or start.get("backend") != "codex" or end.get("backend") != "codex"
+                or end.get("cross_chat_exchange_status") is not True or end.get("transport") != "app-server"
+                or end.get("provider_thread_id") != provider_id or end.get("provider_turn_id") != origin.get("turn_id")
+                or receipt["body_key"] != body_key or source_ids != {origin.get("event_id")} or not origin.get("event_id")
+                or any(type(record.get("seq")) is not int for record in (receipt, start, end))
+                or not receipt["seq"] < start["seq"] < end["seq"]
+                or not isinstance(start.get("id"), str) or not start["id"]):
+                return None
+            times = [_delivery_timestamp(value) for value in (start.get("ts"), origin.get("timestamp"), end.get("ts"))]
+            if any(value is None for value in times) or not times[0] <= times[1] <= times[2]:
+                return None
+            return _native_event_identity(start)
+        if body is None:
+            return None
         envelope = start.get("cross_chat_envelope_id")
         if (start.get("malformed") or end.get("malformed")
             or not isinstance(envelope, str) or not envelope or start.get("backend") != "codex"
@@ -810,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))
@@ -889,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}, {}
@@ -970,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":
@@ -1027,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"):
@@ -1041,10 +1119,12 @@ 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()))
+                                        delivery_bodies.get(key), delivery_source_ids.get(key[0], set()), body_key)
             if delivery is not None:
                 native_matches = [delivery]
         if not native_matches and kind == "assistant":
@@ -1059,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()
@@ -1137,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
@@ -1149,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 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)
@@ -1168,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 = {}
@@ -1188,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:
@@ -1202,11 +1287,11 @@ 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)
-            and any(item.get("kind") == "user" and isinstance(item.get("text"), str)
-                    and _async_delivery_body(item["text"]) for item in items))
+            and any(item.get("kind") == "user" and isinstance(item.get("text"), str) for item in items))
         previous_seq, owner_count = 0, 0
         for event, _offset, _line in _native_records(events, stamp, budget):
             seq = event.get("seq")
@@ -1228,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:
@@ -1263,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 = {}
@@ -1287,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":
@@ -1305,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/codex_provider.py

@@ -195,6 +195,19 @@ def session_choice(value) -> str:
     return choice
 
 
+RUNTIME_FIELDS = ("codex_provider", "codex_provider_revision", "codex_provider_binding", "model", "effort", "_codex_provider_removed")
+
+
+def requested_session(session: dict) -> dict:
+    """Desired runtime is separate from the owner of an in-flight turn."""
+    pending = session.get("_codex_provider_pending")
+    return {**session, **pending} if isinstance(pending, dict) else dict(session)
+
+
+def runtime_selection(session: dict) -> dict:
+    return {key: session.get(key) for key in RUNTIME_FIELDS}
+
+
 class ProviderStore:
     """Atomic metadata pointer plus private, endpoint-bound credential records."""
     def __init__(self, root: Path):
@@ -329,6 +342,8 @@ class ProviderStore:
     def for_session(self, session: dict, *, include_key=False) -> dict | None:
         if session_choice(session.get("codex_provider")) == "default":
             return None
+        if session.get("_codex_provider_removed"):
+            raise HTTPException(409, "Configure the custom Codex endpoint before using this chat.")
         revision = session.get("codex_provider_revision")
         selected = self.selection(include_key=include_key, revision=revision, include_revision=True)
         if selected is None:
@@ -345,6 +360,30 @@ class ProviderStore:
             selected["model"] = validate_model(model)
         return selected
 
+    def control(self, session: dict, *, available=True, summary=False) -> dict:
+        requested = requested_session(session)
+        pending = isinstance(session.get("_codex_provider_pending"), dict)
+        requested_provider = session_choice(requested.get("codex_provider"))
+        def endpoint(value):
+            if session_choice(value.get("codex_provider")) != "custom" or value.get("_codex_provider_removed"):
+                return None
+            try:
+                selected = self._public_selections.get(value.get("codex_provider_revision")) or self.for_session(value)
+                return selected.get("base_url") if selected else None
+            except HTTPException:
+                return None
+        return {"pending": pending,
+            "pending_reason": session.get("_codex_provider_pending_reason") if pending else None,
+            "requested_provider": requested_provider,
+            "active_provider": session_choice(session.get("codex_provider")),
+            "requested_model": requested.get("model"), "requested_effort": requested.get("effort"),
+            # The next-turn picker must use the requested endpoint's catalog,
+            # while active runtime fields continue describing running work.
+            # Avoid duplicating the active catalog on ordinary session events.
+            "requested_catalog": self.catalog(available=available, session=requested, summary=summary)
+                if pending and requested_provider == "custom" else None,
+            "requested_base_url": endpoint(requested), "active_base_url": endpoint(session)}
+
     def registration(self, *, include_key=False) -> dict | None:
         # A damaged optional endpoint must not prevent normal Codex startup.
         # Custom chat admission and the admin status route still fail closed.
@@ -575,6 +614,17 @@ class ProviderStore:
             if selected:
                 self._atomic(self._binding_name(thread_id), {"binding": binding(selected),
                     "credential_id": selected.get("credential_id")})
+            else:
+                self._atomic(self._binding_name(thread_id), {"binding": None, "credential_id": None})
+
+    def thread_binding(self, thread_id: str) -> dict:
+        """Snapshot rollback metadata without reopening revoked credentials."""
+        with self.lock:
+            return self._read(self._binding_name(thread_id)) or {"binding": None, "credential_id": None}
+
+    def restore_thread_binding(self, thread_id: str, record: dict) -> None:
+        with self.lock:
+            self._atomic(self._binding_name(thread_id), record)
 
     def for_thread(self, thread_id: str, *, include_key=False) -> dict | None:
         with self.lock:
@@ -1076,7 +1126,7 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
                     session = session_lookup(session_id) if session_lookup else None
                     if not session:
                         raise HTTPException(404, "Chat not found.")
-                    selected = await asyncio.to_thread(store.for_session, session, include_key=True)
+                    selected = await asyncio.to_thread(store.for_session, requested_session(session), include_key=True)
                 else:
                     selected = await asyncio.to_thread(store.selection, include_key=True, include_revision=True)
                 if selected is None:
@@ -1141,7 +1191,7 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
             session = session_lookup(session_id) if session_lookup else None
             if not session:
                 raise HTTPException(404, "Chat not found.")
-            selected = await asyncio.to_thread(store.for_session, session, include_key=True)
+            selected = await asyncio.to_thread(store.for_session, requested_session(session), include_key=True)
         else:
             selected = await asyncio.to_thread(store.selection, include_key=True, include_revision=True)
         if selected is None: