Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
fix(agent): preserve queued turn semantics and completion
chengyongru7208fb663fea
diff --git a/nanobot/agent/automation_turns.py b/nanobot/agent/automation_turns.pyindex 072223b7e..5a1b69601 100644--- a/nanobot/agent/automation_turns.py+++ b/nanobot/agent/automation_turns.py@@ -58,6 +58,10 @@ class AutomationTurnCoordinator:self._waiters: dict[str, asyncio.Future[OutboundMessage | None]] = {}self._pending_messages_by_turn_id: dict[str, InboundMessage] = {}+ def owns_turn(self, msg: InboundMessage) -> bool:+ """Whether this message requires an independent automation completion."""+ return bool(self._turn_id(msg))+async def submit(self, msg: InboundMessage) -> OutboundMessage | None:"""Submit an automation turn and wait for its session response."""turn_id = self._turn_id(msg)diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.pyindex bc20fff50..0c4243170 100644--- a/nanobot/agent/loop.py+++ b/nanobot/agent/loop.py@@ -73,7 +73,7 @@ from nanobot.security.workspace_access import ()from nanobot.session import turn_continuationfrom nanobot.session.automation_turns import automation_history_overrides-from nanobot.session.goal_state import goal_state_runtime_lines+from nanobot.session.goal_state import goal_state_runtime_lines, sustained_goal_activefrom nanobot.session.history_visibility import HIDDEN_HISTORY_METAfrom nanobot.session.keys import UNIFIED_SESSION_KEY, remember_last_channelfrom nanobot.session.manager import SESSION_CACHE_MAX_SIZE, Session, SessionManager@@ -406,13 +406,13 @@ class AgentLoop:self._deferred_automation_turns: dict[str, list[InboundMessage]] = {}self._cron_turns = CronTurnCoordinator(publish_inbound=self.bus.publish_inbound,- dispatch=self._dispatch,+ dispatch=partial(self._dispatch, wait_for_worker=False),is_running=lambda: self._running,deferred_queues=self._deferred_automation_turns,)self._local_trigger_turns = LocalTriggerTurnCoordinator(publish_inbound=self.bus.publish_inbound,- dispatch=self._dispatch,+ dispatch=partial(self._dispatch, wait_for_worker=False),is_running=lambda: self._running,deferred_queues=self._deferred_automation_turns,)@@ -870,11 +870,17 @@ class AgentLoop:Returns the total number of cancelled tasks, subagents, and exec sessions."""+ pending = self._pending_queues.get(key)tasks = tuple(self._active_tasks.pop(key, set()))cancelled = sum(1 for t in tasks if not t.done() and t.cancel())for t in tasks:with suppress(asyncio.CancelledError, Exception):await t+ if tasks and pending is not None and self._pending_queues.get(key) is pending:+ # A task cancelled before its first step never enters the worker's+ # cleanup handler. Only reclaim that worker's original inbox.+ self._pending_queues.pop(key, None)+ await self._cancel_pending_messages(key, pending, asyncio.CancelledError())sub_cancelled = await self.subagents.cancel_by_session(key)exec_cancelled = await self._exec_session_manager.terminate_by_owner(key)return cancelled + sub_cancelled + exec_cancelled@@ -899,6 +905,16 @@ class AgentLoop:return UNIFIED_SESSION_KEYreturn msg.session_key+ def _can_inject_message(self, msg: InboundMessage) -> bool:+ """Keep independent turns and controls out of user-input batches."""+ if turn_continuation.internal_continuation_inbound(msg.metadata) or any(+ coordinator.owns_turn(msg) for _, coordinator in self._automation_turn_coordinators+ ):+ return False+ return msg.channel == "system" or not self.commands.is_dispatchable_command(+ msg.content.strip()+ )+def _idle_events(self,session_key: str,@@ -1064,7 +1080,25 @@ class AgentLoop:row[PENDING_FOLLOWUP_ID_KEY] = followup_idreturn row- return [await _to_user_message(pending_msg) for pending_msg in pending_messages]+ consumed = 0+ try:+ converted: list[dict[str, Any]] = []+ for pending_msg in pending_messages:+ # Independent turns are FIFO barriers. Their worker path+ # owns completion, command dispatch, and control metadata.+ if not self._can_inject_message(pending_msg):+ break+ converted.append(await _to_user_message(pending_msg))+ consumed = len(converted)+ return converted+ finally:+ # Commit only a successfully converted prefix. On failure or+ # cancellation, return the whole snapshot ahead of later arrivals.+ unconsumed = pending_messages[consumed:]+ if unconsumed:+ later = [pending_queue.get_nowait() for _ in range(pending_queue.qsize())]+ for pending_msg in [*unconsumed, *later]:+ pending_queue.put_nowait(pending_msg)terminal_wait_deadline: float | None = None@@ -1373,6 +1407,8 @@ class AgentLoop:msg: InboundMessage,) -> InboundMessage:"""Persist a recoverable WebUI follow-up before adding it to the inbox."""+ if not self._can_inject_message(msg):+ return msgsession = self.sessions.get_or_create(session_key)followup_id = record_pending_followup(session, msg)if followup_id is None:@@ -1387,8 +1423,8 @@ class AgentLoop:self.sessions.save(session)return pending_msg- async def _dispatch(self, msg: InboundMessage) -> None:- """Submit one direct caller message through the per-session FIFO."""+ async def _dispatch(self, msg: InboundMessage, *, wait_for_worker: bool = True) -> None:+ """Enqueue a message, optionally awaiting a newly created session worker."""session_key = self._effective_session_key(msg)if session_key != msg.session_key:msg = dataclasses.replace(msg, session_key_override=session_key)@@ -1401,7 +1437,13 @@ class AgentLoop:new_pending: asyncio.Queue[InboundMessage] = asyncio.Queue()new_pending.put_nowait(msg)self._pending_queues[session_key] = new_pending- await self._run_session_queue(session_key, new_pending)+ if wait_for_worker:+ await self._run_session_queue(session_key, new_pending)+ else:+ # Automation callers await their own completion, not every later+ # turn handled by this worker. Session cancellation still owns it.+ task = asyncio.create_task(self._run_session_queue(session_key, new_pending))+ self._track_active_task(session_key, task)async def _run_session_queue(self,@@ -1424,6 +1466,9 @@ class AgentLoop:"Session worker failed one message for {}; continuing FIFO",session_key,)+ except asyncio.CancelledError as exc:+ await self._cancel_pending_messages(session_key, pending, exc)+ raisefinally:owns_queue = self._pending_queues.get(session_key) is pendingif owns_queue:@@ -1431,6 +1476,24 @@ class AgentLoop:if owns_queue and self._running and session_key not in self._discarding_sessions:await self._publish_next_deferred_automation_turn(session_key)+ async def _cancel_pending_messages(+ self,+ session_key: str,+ pending: asyncio.Queue[InboundMessage],+ error: asyncio.CancelledError,+ ) -> None:+ """Complete queued independent turns after their session worker stops."""+ while not pending.empty():+ msg = pending.get_nowait()+ for _, coordinator in self._automation_turn_coordinators:+ coordinator.complete(msg, error=error)+ if (+ msg.channel != "system"+ and normalize_command_text(msg.content).lower() == "/compact"+ ):+ delivery = self.turn_delivery_factory.unrouted(msg, session_key)+ await delivery.complete(None, publish_completion=True)+async def _dispatch_one(self,msg: InboundMessage,@@ -1460,6 +1523,12 @@ class AgentLoop:completion_published = Falsetry:async with lock, gate:+ # A preceding user turn may have completed or blocked the goal+ # while its older continuation was still waiting in the inbox.+ if turn_continuation.internal_continuation_inbound(msg.metadata) and not (+ sustained_goal_active(self.sessions.get_or_create(session_key).metadata)+ ):+ returntry:delivery = self.turn_delivery_factory.create(msg,diff --git a/nanobot/agent/runner.py b/nanobot/agent/runner.pyindex 8c958d940..757e9f0d9 100644--- a/nanobot/agent/runner.py+++ b/nanobot/agent/runner.py@@ -370,6 +370,7 @@ class AgentRunner:# Segments from one uninterrupted length-recovery chain. Tool work or# injected user input starts a new logical answer and clears the chain.length_recovery_parts: list[str] = []+ pending_length_segment: tuple[AgentHookContext, str] | None = Nonehad_injections = Falseinjection_cycles = 0pending_stream_content: str | None = None@@ -397,6 +398,20 @@ class AgentRunner:events=spec.events,)+ async def end_length_segment(*, interrupted: bool) -> None:+ nonlocal pending_length_segment+ if pending_length_segment is None:+ return+ segment_context, segment_content = pending_length_segment+ pending_length_segment = None+ if interrupted:+ length_recovery_parts.clear()+ else:+ messages.append(build_length_recovery_message(segment_content))+ if hook.wants_streaming():+ segment_context.stream_continues_current_message = not interrupted+ await hook.on_stream_end(segment_context, resuming=True)+for iteration in range(spec.max_iterations):# The session inbox cuts a finite snapshot before every model call.# This includes follow-ups that arrived before the first request and@@ -410,6 +425,7 @@ class AgentRunner:)if drained_before_request:had_injections = True+ await end_length_segment(interrupted=drained_before_request)context = AgentHookContext(iteration=iteration,messages=messages,@@ -610,9 +626,6 @@ class AgentRunner:len(length_recovery_parts),_MAX_LENGTH_RECOVERIES,)- if hook.wants_streaming():- context.stream_continues_current_message = True- await hook.on_stream_end(context, resuming=True)messages.append(conversation_state.project_response_message(build_assistant_message(clean,@@ -621,7 +634,9 @@ class AgentRunner:),response,))- messages.append(build_length_recovery_message(clean or ""))+ # The next input snapshot decides whether to continue this+ # answer or close its stream before answering a new question.+ pending_length_segment = (context, clean or "")await hook.after_iteration(context)continue@@ -782,6 +797,7 @@ class AgentRunner:)if drained_after_max_iterations:had_injections = True+ await end_length_segment(interrupted=drained_after_max_iterations)terminal_content, usage = await self._try_finalize_after_max_iterations(spec,hook,@@ -790,6 +806,8 @@ class AgentRunner:request_state=request_state,round_usages=round_usages,)+ else:+ await end_length_segment(interrupted=False)if terminal_content is None:terminal_content = self._max_iterations_fallback(spec)if length_recovery_parts:diff --git a/tests/agent/test_loop_progress.py b/tests/agent/test_loop_progress.pyindex a9fb28b6b..7a1a7d5c7 100644--- a/tests/agent/test_loop_progress.py+++ b/tests/agent/test_loop_progress.py@@ -579,6 +579,55 @@ class TestToolEventProgress:assert [event.merge_next for event in endings] == [True, False]assert {event.stream_id for event in [*deltas, *endings]} == {deltas[0].stream_id}+ @pytest.mark.asyncio+ @pytest.mark.parametrize("max_iterations", [1, 3])+ async def test_followup_after_truncation_starts_a_new_stream(+ self, tmp_path: Path, max_iterations: int,+ ) -> None:+ loop = _make_loop(tmp_path)+ loop.max_iterations = max_iterations+ loop.tools.get_definitions = MagicMock(return_value=[])+ _attach_webui_runtime_events(loop, loop.bus)+ calls = 0++ async def chat(*, on_content_delta=None, **kwargs):+ nonlocal calls+ calls += 1+ if calls == 1:+ await on_content_delta("old partial")+ await loop._dispatch(InboundMessage(+ channel="websocket", sender_id="u", chat_id="test", content="new question",+ ))+ return LLMResponse(content="old partial", finish_reason="length")+ if on_content_delta is not None:+ await on_content_delta("new answer")+ return LLMResponse(content="new answer", finish_reason="stop")++ loop.provider.chat_stream_with_retry = chat+ try:+ await loop._dispatch(InboundMessage(+ channel="websocket", sender_id="u", chat_id="test", content="old question",+ metadata={"_wants_stream": True},+ ))+ outbound = [loop.bus.outbound.get_nowait() for _ in range(loop.bus.outbound_size)]+ deltas = [+ message.event for message in outbound if isinstance(message.event, StreamDeltaEvent)+ ]+ endings = [+ message.event for message in outbound if isinstance(message.event, StreamEndEvent)+ ]+ assert [event.content for event in deltas] == ["old partial", "new answer"]+ assert deltas[0].stream_id != deltas[1].stream_id+ assert [(event.resuming, event.merge_next) for event in endings] == [+ (True, False), (False, False),+ ]+ assert [+ message.content for message in outbound+ if isinstance(message.event, StreamedResponseEvent)+ ] == ["new answer"]+ finally:+ await loop.aclose()+@pytest.mark.asyncioasync def test_length_recovery_streams_non_delta_terminal_segment(self,diff --git a/tests/agent/test_runner_injections.py b/tests/agent/test_runner_injections.pyindex 7eb9db772..cf9bb1ad5 100644--- a/tests/agent/test_runner_injections.py+++ b/tests/agent/test_runner_injections.py@@ -530,6 +530,55 @@ async def test_injected_followup_starts_new_length_recovery_chain():assert call_count == 6[email protected]("max_iterations", [1, 3])+async def test_followup_interrupts_truncated_answer_before_next_request(max_iterations):+ from nanobot.agent.hook import AgentHook, AgentHookContext+ from nanobot.agent.runner import AgentRunner++ provider = MagicMock()+ tools = MagicMock()+ tools.get_definitions.return_value = []+ queue = asyncio.Queue()+ requests = []+ endings = []++ class StreamingHook(AgentHook):+ def wants_streaming(self) -> bool:+ return True++ async def on_stream_end(self, context: AgentHookContext, *, resuming: bool) -> None:+ endings.append((resuming, context.stream_continues_current_message))++ async def chat_stream_with_retry(*, messages, on_content_delta=None, **kwargs):+ requests.append([dict(message) for message in messages])+ if len(requests) == 1:+ queue.put_nowait({"role": "user", "content": "Never mind. What is 2+2?"})+ if on_content_delta is not None:+ await on_content_delta("Unfinished old answer: ")+ return LLMResponse(content="Unfinished old answer: ", finish_reason="length")+ return LLMResponse(content="4", finish_reason="stop")++ provider.chat_stream_with_retry = chat_stream_with_retry+ result = await AgentRunner().run(make_run_spec(+ provider,+ initial_messages=[{"role": "user", "content": "old question"}],+ tools=tools,+ model="test-model",+ max_iterations=max_iterations,+ max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,+ hook=StreamingHook(),+ injection_callback=_make_injection_callback(queue),+ ))++ assert result.final_content == "4"+ assert len(requests) == 2+ assert endings[0] == (True, False)+ second_request = "\n".join(str(message.get("content", "")) for message in requests[1])+ assert "Never mind. What is 2+2?" in second_request+ assert "Continue the same response from its exact endpoint" not in second_request++@pytest.mark.asyncioasync def test_checkpoint2_preserves_final_response_in_history_before_followup():"""A follow-up injected after a final answer must still see that answer in history."""@@ -1579,6 +1628,111 @@ async def test_pending_queue_snapshot_excludes_messages_arriving_during_conversiassert "next snapshot" in second_request[email protected]("cancel_conversion", [False, True])+async def test_pending_snapshot_rolls_back_before_later_arrivals(tmp_path, cancel_conversion):+ from nanobot.agent.loop import AgentLoop+ from nanobot.bus.events import InboundMessage+ from nanobot.bus.queue import MessageBus++ provider = MagicMock()+ provider.get_default_model.return_value = "test-model"+ provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="answer"))+ loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")+ loop.tools.get_definitions = MagicMock(return_value=[])+ pending = asyncio.Queue()+ contents = ["before", "bad", "after"]+ for content in contents:+ pending.put_nowait(InboundMessage(+ channel="cli", sender_id="u", chat_id="c", content=content,+ ))+ failed = False++ async def context_provider(request):+ nonlocal failed+ if request.original_user_text == "bad" and not failed:+ failed = True+ pending.put_nowait(InboundMessage(+ channel="cli", sender_id="u", chat_id="c", content="later arrival",+ ))+ if cancel_conversion:+ raise asyncio.CancelledError+ raise RuntimeError("context lookup temporarily unavailable")+ return None++ loop.register_runtime_context_provider(context_provider)+ runtime = loop.llm_runtime()+ try:+ run = loop._run_agent_loop(+ TranscriptInput(history=[{"role": "user", "content": "root"}], current_message=None),+ runtime=runtime,+ request_context=RequestContext(channel="cli", chat_id="c", runtime=runtime),+ pending_queue=pending,+ )+ if cancel_conversion:+ with pytest.raises(asyncio.CancelledError):+ await run+ assert [pending.get_nowait().content for _ in range(pending.qsize())] == [+ *contents, "later arrival",+ ]+ else:+ result = await run+ user_content = [+ message["content"] for message in result.messages if message["role"] == "user"+ ]+ assert user_content == ["root", *contents, "later arrival"]+ assert pending.empty()+ finally:+ await loop.aclose()+++async def test_persistent_conversion_error_does_not_drop_later_session_inputs(tmp_path):+ from nanobot.agent.loop import AgentLoop+ from nanobot.bus.events import InboundMessage+ from nanobot.bus.queue import MessageBus+ from nanobot.bus.runtime_events import TurnCompleted++ provider = MagicMock()+ provider.get_default_model.return_value = "test-model"+ loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")+ loop.tools.get_definitions = MagicMock(return_value=[])+ completions = []+ loop.bus.subscribe(completions.append, TurnCompleted)+ calls = 0++ async def chat(**kwargs):+ nonlocal calls+ calls += 1+ if calls == 1:+ for content in ["before", "bad", "after"]:+ await loop._dispatch(InboundMessage(+ channel="cli", sender_id="u", chat_id="c", content=content,+ ))+ return LLMResponse(content="answer", finish_reason="stop")++ async def context_provider(request):+ if request.original_user_text == "bad":+ raise RuntimeError("context unavailable")+ return None++ provider.chat_stream_with_retry = chat+ loop.register_runtime_context_provider(context_provider)+ try:+ await loop._dispatch(InboundMessage(+ channel="cli", sender_id="u", chat_id="c", content="root",+ ))+ loop.sessions.invalidate("cli:c")+ history = loop.sessions.get_or_create("cli:c").messages+ assert [message["content"] for message in history if message["role"] == "user"] == [+ "root", "before", "after",+ ]+ assert sum(event.outcome == "failed" for event in completions) == 1+ assert "cli:c" not in loop._pending_queues+ finally:+ await loop.aclose()++@pytest.mark.asyncioasync def test_session_inbox_is_installed_before_worker_start(tmp_path):"""A preloaded burst has one FIFO path before the worker can be scheduled."""diff --git a/tests/agent/test_session_inbox_controls.py b/tests/agent/test_session_inbox_controls.pynew file mode 100644index 000000000..9d75fcbe9--- /dev/null+++ b/tests/agent/test_session_inbox_controls.py@@ -0,0 +1,221 @@+"""Independent turns and internal controls retain their session inbox semantics."""++import asyncio+from unittest.mock import AsyncMock, MagicMock++import pytest++from nanobot.agent.automation_turns import AutomationTurnError+from nanobot.agent.loop import AgentLoop+from nanobot.agent.tools.context import current_request_context+from nanobot.bus.events import InboundMessage+from nanobot.bus.queue import MessageBus+from nanobot.cron.session_turns import CRON_DEFER_UNTIL_IDLE_META, CRON_TRIGGER_META+from nanobot.providers.base import GenerationSettings, LLMResponse, ToolCallRequest+from nanobot.runtime_context import public_history_messages+from nanobot.session.automation_turns import AUTOMATION_HISTORY_META+from nanobot.session.goal_state import GOAL_STATE_KEY+from nanobot.session.recovery import PENDING_FOLLOWUPS_KEY+from nanobot.triggers.local_session_turns import LOCAL_TRIGGER_META+++async def loop(tmp_path):+ provider = MagicMock()+ provider.get_default_model.return_value = "test-model"+ provider.generation = GenerationSettings(max_tokens=100)+ provider.can_resume_conversation_state.return_value = False+ provider.estimate_prompt_tokens.return_value = (100, "test")+ agent = AgentLoop(+ bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model",+ )+ agent.tools.get_definitions = MagicMock(return_value=[])+ try:+ yield agent+ finally:+ await agent.aclose()+++def _automation_message(kind: str, name: str) -> InboundMessage:+ metadata = (+ {+ CRON_TRIGGER_META: {"job_id": name, "run_id": name, "persist_content": name},+ CRON_DEFER_UNTIL_IDLE_META: True,+ }+ if kind == "cron"+ else {+ LOCAL_TRIGGER_META: {+ "trigger_id": name, "delivery_id": name, "persist_content": name,+ },+ }+ )+ return InboundMessage(+ channel="websocket", sender_id=kind, chat_id="test", content=name, metadata=metadata,+ )++[email protected]("first_kind", ["cron", "local_trigger"])[email protected]("second_fails", [False, True])+async def test_startup_automation_turns_complete_independently(loop, first_kind, second_fails):+ started, release = asyncio.Event(), asyncio.Event()+ release_second = asyncio.Event()+ senders = []++ async def chat(**kwargs):+ senders.append(current_request_context().sender_id)+ if len(senders) == 1:+ started.set()+ await release.wait()+ return LLMResponse(content="first response")+ await release_second.wait()+ if second_fails:+ raise RuntimeError("second task failed")+ return LLMResponse(content="second response")++ loop.provider.chat_stream_with_retry = chat+ second_kind = "local_trigger" if first_kind == "cron" else "cron"+ submit = {"cron": loop.submit_cron_turn, "local_trigger": loop.submit_local_trigger_turn}+ first = asyncio.create_task(submit[first_kind](_automation_message(first_kind, "first")))+ tasks = [first]+ try:+ await asyncio.wait_for(started.wait(), timeout=3)+ second = asyncio.create_task(submit[second_kind](_automation_message(second_kind, "second")))+ tasks.append(second)+ await asyncio.sleep(0)+ assert not second.done()+ release.set()+ first_response = await asyncio.wait_for(first, timeout=3)+ assert first_response.content == "first response"+ assert not second.done()+ release_second.set()+ if second_fails:+ with pytest.raises(AutomationTurnError, match="second task failed"):+ await asyncio.wait_for(second, timeout=3)+ else:+ second_response = await asyncio.wait_for(second, timeout=3)+ assert second_response.content == "second response"+ assert senders == [first_kind, second_kind]+ assert loop.pending_cron_job_ids_for_session("websocket:test") == set()+ assert loop.pending_local_trigger_ids_for_session("websocket:test") == set()+ loop.sessions.invalidate("websocket:test")+ session = loop.sessions.get_or_create("websocket:test")+ user_rows = [message for message in session.messages if message["role"] == "user"]+ assert [message[AUTOMATION_HISTORY_META]["kind"] for message in user_rows] == [+ first_kind, second_kind,+ ]+ assert PENDING_FOLLOWUPS_KEY not in session.metadata+ finally:+ release.set()+ release_second.set()+ for task in tasks:+ if not task.done():+ task.cancel()+ await asyncio.gather(*tasks, return_exceptions=True)+++async def test_cancelled_session_completes_queued_automation_waiters(loop):+ started = asyncio.Event()++ async def chat(**kwargs):+ started.set()+ await asyncio.Event().wait()++ loop.provider.chat_stream_with_retry = chat+ worker = asyncio.create_task(loop._dispatch(InboundMessage(+ channel="websocket", sender_id="u", chat_id="test", content="user request",+ )))+ tasks = [worker]+ try:+ await asyncio.wait_for(started.wait(), timeout=3)+ cron = asyncio.create_task(loop.submit_cron_turn(_automation_message("cron", "cron")))+ trigger = asyncio.create_task(loop.submit_local_trigger_turn(+ _automation_message("local_trigger", "trigger"),+ ))+ tasks.extend([cron, trigger])+ await asyncio.sleep(0)+ assert loop._pending_queues["websocket:test"].qsize() == 2+ worker.cancel()+ with pytest.raises(asyncio.CancelledError):+ await worker+ for task in (cron, trigger):+ with pytest.raises(AutomationTurnError, match="CancelledError"):+ await asyncio.wait_for(task, timeout=3)+ assert "websocket:test" not in loop._pending_queues+ assert loop.pending_cron_job_ids_for_session("websocket:test") == set()+ assert loop.pending_local_trigger_ids_for_session("websocket:test") == set()+ session = loop.sessions.get_or_create("websocket:test")+ assert PENDING_FOLLOWUPS_KEY not in session.metadata+ finally:+ for task in tasks:+ if not task.done():+ task.cancel()+ await asyncio.gather(*tasks, return_exceptions=True)+++async def test_stop_before_startup_worker_runs_completes_automation(loop):+ loop.provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="unused"))+ submit = asyncio.create_task(loop.submit_cron_turn(_automation_message("cron", "queued")))+ try:+ await asyncio.sleep(0)+ assert "websocket:test" in loop._pending_queues+ await loop._cancel_active_tasks("websocket:test")+ with pytest.raises(AutomationTurnError, match="CancelledError"):+ await asyncio.wait_for(submit, timeout=3)+ loop.provider.chat_stream_with_retry.assert_not_awaited()+ assert "websocket:test" not in loop._pending_queues+ assert loop.pending_cron_job_ids_for_session("websocket:test") == set()+ finally:+ if not submit.done():+ submit.cancel()+ await asyncio.gather(submit, return_exceptions=True)++[email protected]("complete_on_followup", [False, True])+async def test_goal_continuation_after_followup_keeps_control_identity(loop, complete_on_followup):+ loop.max_iterations = 1+ loop.tools.prepare_call = MagicMock(return_value=(None, {}, None))+ loop.tools.execute = AsyncMock(return_value="ok")+ session = loop.sessions.get_or_create("cli:test")+ session.metadata[GOAL_STATE_KEY] = {"status": "active", "objective": "Finish the long goal"}+ loop.sessions.save(session)+ requests = []++ async def chat(*, messages, **kwargs):+ requests.append([dict(message) for message in messages])+ if len(requests) == 1:+ await loop.bus.publish_inbound(InboundMessage(+ channel="cli", sender_id="u", chat_id="test", content="Inspect file B first",+ ))+ async with asyncio.timeout(3):+ while loop._pending_queues["cli:test"].empty():+ await asyncio.sleep(0)+ elif complete_on_followup or len(requests) == 3:+ session.metadata[GOAL_STATE_KEY]["status"] = "complete"+ return LLMResponse(content="done")+ return LLMResponse(+ content="working", finish_reason="tool_calls",+ tool_calls=[ToolCallRequest(id=f"call-{len(requests)}", name="noop", arguments={})],+ )++ loop.provider.chat_stream_with_retry = chat+ run_task = asyncio.create_task(loop.run())+ try:+ await loop.bus.publish_inbound(InboundMessage(+ channel="cli", sender_id="u", chat_id="test", content="Start the goal",+ ))+ async with asyncio.timeout(5):+ while not requests or "cli:test" in loop._pending_queues:+ await asyncio.sleep(0.01)+ assert len(requests) == (2 if complete_on_followup else 3)+ continuation_text = "Continue the active sustained goal after the previous turn"+ assert continuation_text not in str(requests[1])+ if not complete_on_followup:+ assert continuation_text in str(requests[2])+ loop.sessions.invalidate("cli:test")+ history = public_history_messages(loop.sessions.get_or_create("cli:test").messages)+ assert [message["content"] for message in history if message["role"] == "user"] == [+ "Start the goal", "Inspect file B first",+ ]+ finally:+ loop.stop()+ await asyncio.wait_for(run_task, timeout=3)diff --git a/tests/command/test_compact_command.py b/tests/command/test_compact_command.pyindex 67734a3b4..75673580e 100644--- a/tests/command/test_compact_command.py+++ b/tests/command/test_compact_command.py@@ -221,6 +221,94 @@ async def test_stop_completes_a_compact_command_waiting_for_the_session_lock(looassert completions[0].context.metadata["webui_turn_id"] == "queued-compact"+async def test_compact_is_a_fifo_barrier_during_an_active_turn(loop) -> None:+ key = "cli:test"+ started = asyncio.Event()+ release = asyncio.Event()+ requests = []+ compacted_history = []+ compact = loop.consolidator.compact_idle_session++ async def capture_compaction(*args, **kwargs):+ compacted_history.extend(+ dict(message) for message in loop.sessions.get_or_create(key).messages+ )+ return await compact(*args, **kwargs)++ loop.consolidator.compact_idle_session = capture_compaction++ async def chat(*, messages, **kwargs):+ requests.append([dict(message) for message in messages])+ if len(requests) == 1:+ started.set()+ await release.wait()+ return LLMResponse(content="answer", finish_reason="stop")++ loop.provider.chat_stream_with_retry = chat+ task = asyncio.create_task(loop._dispatch(InboundMessage(+ channel="cli", sender_id="u", chat_id="test", content="initial question",+ )))+ try:+ await asyncio.wait_for(started.wait(), timeout=5)+ await loop._dispatch(InboundMessage(+ channel="cli", sender_id="u", chat_id="test", content="before compaction",+ ))+ command = InboundMessage(channel="cli", sender_id="u", chat_id="test", content="/compact")+ await loop._dispatch_command_inline(command, key, command.content, loop.commands.dispatch)+ await loop._dispatch(InboundMessage(+ channel="cli", sender_id="u", chat_id="test", content="after compaction",+ ))+ release.set()+ await asyncio.wait_for(task, timeout=5)+ finally:+ release.set()+ if not task.done():+ task.cancel()+ await asyncio.gather(task, return_exceptions=True)++ assert [message["content"] for message in compacted_history if message["role"] == "user"] == [+ "initial question", "before compaction",+ ]+ assert all("/compact" != message.get("content") for request in requests for message in request)+ assert "after compaction" in str(requests[-1])+ events = [loop.bus.outbound.get_nowait().event for _ in range(loop.bus.outbound_size)]+ assert [event.phase for event in events if isinstance(event, ContextCompactionEvent)] == [+ "started", "succeeded",+ ]+++async def test_stop_completes_compact_queued_behind_an_active_turn(loop) -> None:+ key = "websocket:test"+ started = asyncio.Event()++ async def chat(**kwargs):+ started.set()+ await asyncio.Event().wait()++ loop.provider.chat_stream_with_retry = chat+ completions = []+ loop.bus.subscribe(completions.append, TurnCompleted)+ task = asyncio.create_task(loop._dispatch(InboundMessage(+ channel="websocket", sender_id="u", chat_id="test", content="question",+ )))+ loop._track_active_task(key, task)+ await asyncio.wait_for(started.wait(), timeout=5)+ command = InboundMessage(+ channel="websocket", sender_id="u", chat_id="test", content="/compact",+ metadata={"webui_turn_id": "queued-compact"},+ )+ await loop._dispatch_command_inline(command, key, command.content, loop.commands.dispatch)+ await cmd_stop(CommandContext(msg=command, session=None, key=key, raw="/stop", loop=loop))++ assert task.cancelled()+ assert sum(+ event.context.metadata.get("webui_turn_id") == "queued-compact" for event in completions+ ) == 1+ assert key not in loop._pending_queues++@pytest.mark.asyncioasync def test_stop_finishes_inflight_compaction_as_cancelled(loop) -> None:key = "websocket:test"