"""``/refine`` for a local session whose cached agent is gone (T7). ``/moa`` arms a one-shot model swap that evicts the session's cached agent, and its settle evicts the MoA-built one, so the cached agent is not where a local session's conversation lives. The session's stored transcript is: the review runs over it on a side agent built from the session's frozen launch policy (the route ``/bg`` and ``/btw`` use, ``gateway/session_tui_side.py``), and its summary lands on the session's event stream as ``review.summary``, as a turn-time review does. Messaging sessions keep the cached-agent path unchanged. """ import asyncio import contextlib import uuid from agent.i18n import t def _local_session(runner, source): from gateway.config import Platform from gateway.session_setting_commands import local_authority_live if source is None or getattr(source, 'platform', None) != Platform.LOCAL: return None, None return local_authority_live(runner, source) async def refine_local_session(runner, source, focus): """The ``/refine`` reply for a local session, or None when ``source`` is not one.""" authority, live = _local_session(runner, source) if live is None: return None from gateway.session_contract import SessionRef from gateway.session_local_recovery import transcript_target from gateway.session_policy import policy_for_source policy = policy_for_source(runner, live.source) if policy is None: return None ref = SessionRef(authority.profile_id, source.chat_id) def load(): target = transcript_target(authority, ref) return target, authority.db.get_messages_as_conversation(target, include_ancestors=True) target, history = await asyncio.to_thread(load) if not history: return t('gateway.refine.nothing_yet') from agent.background_review import finish_background_review_run, prepare_background_review_run from gateway.session_tui_side import _side_agent, _side_scope, _spawn # The guard is the session's (its side agent is per call): a /refine while one runs joins it, as # the resident agent's does, and the session's next turn cancels it (``_execute_claimed``). run = prepare_background_review_run(live.review) tail = t('gateway.refine.focus_suffix', focus=focus) if focus else '' if run is None: return t('gateway.refine.started', focus_suffix=tail) task_id = f'refine_{uuid.uuid4().hex[:6]}' holder = [None] loop = asyncio.get_running_loop() def publish(message): current = authority.sessions.get(ref.session_id) if current is not None: current.event_stream.publish(ref.session_id, {'text': str(message)}, event_type='review.summary') def body(): try: review_body() finally: # whatever raised first, the session's guard is released finish_background_review_run(live.review, run) from gateway.session_retirement import retire_after_review with contextlib.suppress(RuntimeError): # the loop already closed loop.call_soon_threadsafe(retire_after_review, authority, ref, live) return '' # the summary (if any) was published above; an empty review.summary draws nothing def review_body(): from agent.background_review import spawn_background_review_thread from agent.turn_finalizer import _clone_background_review_messages with _side_scope(authority, policy, task_id): # The session's own id: the review's usage is recorded against it, and the agent never # runs a turn of its own, so it writes no row. close() would tear down that id's terminal, # browser and memory provider (the session's), so only the agent's own clients are released. # No memory provider of its own either (release_clients would not stop it): the review # reads the transcript, as the background review fork does (skip_memory=True). agent = holder[0] = _side_agent(authority, policy, live, task_id, session_id=target, skip_memory=True) agent._end_session_on_close = False agent.background_review_callback = publish agent._print_fn = lambda *_a, **_k: None try: review, _prompt = spawn_background_review_thread( agent, _clone_background_review_messages(history), review_memory=True, review_skills='skill_manage' in getattr(agent, 'valid_tool_names', set()), focus=focus or None, review_run=run, explicit=True) review() finally: with contextlib.suppress(Exception): agent.release_clients() try: _spawn(authority, ref, task_id, 'review.summary', body, holder=holder) except RuntimeError as exc: # the review thread could not start finish_background_review_run(live.review, run) return t('gateway.refine.start_failed', error=exc) return t('gateway.refine.started', focus_suffix=tail)