kolega-code 0.43.0__tar.gz → 0.45.0__tar.gz

{kolega_code-0.43.0 → kolega_code-0.45.0}/CHANGELOG.md

@@ -6,6 +6,99 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.45.0 - 2026-10-22
+
+### Added
+
+- **First-party MiniMax support.** Select `minimax` with `MINIMAX_API_KEY`
+  or a key saved in Settings. Includes MiniMax M3.1 Flash (the default), M3,
+  and the M2 family, with streaming, tool calling, usage reporting, image
+  input on M3 models, and adjustable adaptive thinking on M3.1 Flash.
+- **Mistral model refresh.** `kolega-code models refresh --provider mistral`
+  caches Mistral's live, account-visible model list so models published after a
+  release resolve without upgrading. The endpoint is authenticated, so the
+  command uses `MISTRAL_API_KEY` or a key saved in Settings. A refresh only adds
+  models Kolega does not already know and never overrides a bundled spec.
+
+### Changed
+
+- Reduced session-recording overhead during long turns by avoiding redundant
+  journal reads while the process exclusively owns the session.
+- Updated the documentation site's image-processing dependency, sharp, to 0.35.5.
+
+### Fixed
+
+- **Completed turns no longer leave the TUI stuck as busy on Python 3.12+.**
+  Ordinary turns, background-agent continuations, and scheduled loops now
+  release their timer and active-turn state correctly.
+- **Stop no longer remains indefinitely on "Stopping…".** A second Stop or
+  five-second grace period restores the UI while unfinished cleanup remains
+  isolated. New turns and session, model, or settings changes wait for that
+  cleanup; late output cannot overwrite the current UI.
+- **Silent model requests are bounded.** Separate first-response and idle
+  deadlines, bounded retries, and bounded stream cleanup prevent long,
+  unexplained waits. Compact connection-status notices keep the next action
+  visible even in narrow terminals; detailed errors remain in diagnostics.
+- Slow session writes no longer indefinitely hide finished plans or prevent
+  turn finalization. Writes continue in the background with warnings and
+  diagnostics, and older delayed saves cannot overwrite newer state.
+- Worktree switches committed before cancellation are completed or recovered
+  safely before queued work resumes.
+- Quit now uses bounded waits and a final process-exit watchdog for stuck
+  cleanup or worker threads. The watchdog is disarmed when shutdown returns
+  normally.
+- **Mistral catalog drift.** Large 4's context window is 1,048,576 tokens (was
+  524,288), Mistral Large 3 (`mistral-large-2512`) and its `latest` alias are now
+  catalogued, and `mistral-code-latest` resolves to Codestral. Large 4 is no
+  longer labelled a preview.
+- **ACP model picker honours exported credentials.** Editor sessions now list
+  providers whose API key comes from the environment, matching the CLI, instead
+  of only providers saved through onboarding.
+
+### Security
+
+- Updated aiohttp to 3.14.5 for three parser/timeout advisories, with its
+  required yarl update to 1.25.1.
+- Updated Pillow to 13.0.0 in the application and standalone eval bundle for
+  eight security advisories.
+- Updated certifi to 2026.10.19, removing compromised emSign roots.
+
+## 0.44.0 - 2026-10-19
+
+### Added
+
+- **Background sub-agents.** The agent can delegate with
+  `dispatch_agent(..., background=True)` and keep working while the child runs;
+  foreground dispatch remains the default. Jobs belong to the session in the
+  TUI, `ask`, `--loop`, goal runs, editor (ACP) sessions, and gateway chats.
+  Completion reports arrive automatically and normally start a continuation
+  instead of becoming extra prompts. The new `agent_job` tool lists, inspects,
+  or cancels jobs, with reports retained after completion, failure, or
+  cancellation. Persisted outcomes can be recovered when a session resumes, and
+  reported background usage is attributed to the session. Jobs survive turns,
+  not process exit; cancelling a main turn does not discard child results.
+- The TUI shows a persistent background-agent indicator above the composer,
+  distinguishing running, queued, undelivered, and failed work, and lists
+  retained jobs in the `Ctrl+G` sub-agent inspector. Delivered reports appear as
+  collapsed rows that expand on click or `Enter`, including after a session is
+  restored.
+- Added native Google Gemini 4 Argon (`gemini-4-argon`) and xAI Grok 4.7
+  (`grok-4.7`) support, including model selectors, image input, streaming, tool
+  calling, and named reasoning efforts. Argon uses a shared 1,048,576-token
+  input/thinking/output window; Grok 4.7 uses 500,000 tokens and supports `xhigh`
+  effort. Existing provider defaults remain unchanged.
+
+### Fixed
+
+- Late transcript updates during screen teardown no longer raise while the
+  conversation is being pruned, so exiting or switching sessions can no longer
+  fail on a stale render.
+
+### Security
+
+- Updated mcp to 1.30.0, closing CVE-2026-59951 (GHSA-84m7-p3x7-pcfv), a
+  streamable-HTTP session exhaustion issue in the MCP client.
+
 ## 0.43.0 - 2026-10-13
 
 ### Added

{kolega_code-0.43.0 → kolega_code-0.45.0}/CONTRIBUTING.md

@@ -120,6 +120,18 @@ You can pass additional pytest arguments through the wrapper:
 ./run_tests.sh tests/test_git_env.py -ra
 ```
 
+## Comments
+
+Comments are rare here. Write one only where the code cannot say it: a non-obvious
+constraint, a failure mode, or a probed vendor behaviour.
+
+- Don't restate a self-explanatory constant or boolean in prose above it.
+- Don't write a docstring that rewords the signature, or one longer than the body it
+  documents.
+- Don't transcribe research (probe logs, vendor quirks) into a source-file banner —
+  that belongs in `docs/`, `CHANGELOG.md`, or the test that pins the behaviour.
+- Explain a subtle decision once, at the place it is made, not at every call site.
+
 ## Updating bundled skills
 
 Kolega Code vendors a reviewed, tagged snapshot from

{kolega_code-0.43.0 → kolega_code-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.43.0
+Version: 0.45.0
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/
@@ -45,14 +45,14 @@ Requires-Dist: langfuse==3.14.5
 Requires-Dist: lxml-html-clean==0.4.5
 Requires-Dist: markdownify==1.2.3
 Requires-Dist: markitdown[docx,pdf,pptx,xls,xlsx]==0.1.6
-Requires-Dist: mcp==1.28.1
+Requires-Dist: mcp==1.30.0
 Requires-Dist: nest-asyncio==1.6.0
 Requires-Dist: onnxruntime==1.19.2; sys_platform == 'darwin' and platform_machine == 'x86_64' and python_version < '3.13'
 Requires-Dist: onnxruntime==1.27.0; python_version >= '3.14' and sys_platform != 'win32'
 Requires-Dist: openai==2.46.0
 Requires-Dist: packaging==25.0
 Requires-Dist: pathspec==1.1.1
-Requires-Dist: pillow==12.3.0
+Requires-Dist: pillow==13.0.0
 Requires-Dist: playwright==1.59.0
 Requires-Dist: psutil==7.2.2
 Requires-Dist: pydantic==2.13.4
@@ -271,6 +271,7 @@ Supported model providers:
 - DashScope / Qwen
 - OpenRouter (gateway to 250+ tool-capable models)
 - Moonshot / Kimi
+- MiniMax
 - DeepSeek
 - Z.AI / GLM Coding Plan
 - Kimi Coding Plan
@@ -314,20 +315,27 @@ kolega-code . --provider mistral --model mistral-medium-3-5
 ```
 
 The picker defaults to Mistral Medium 3.5 and includes Mistral Small 4
-(`mistral-small-2603`), Mistral Large 4 **preview** (`mistral-large-4`),
-Ministral 3 (3B/8B/14B), Codestral, and eligible native aliases. Large 4 access
-depends on the account/subscription; a catalog entry does not guarantee access.
-Aliases, especially `latest`, can change their target and capabilities.
+(`mistral-small-2603`), Mistral Large 4 (`mistral-large-4`), Mistral Large 3
+(`mistral-large-2512`), Ministral 3 (3B/8B/14B), Codestral, and eligible native
+aliases. Windows and capabilities mirror Mistral's authenticated model list; a
+catalog entry does not guarantee access, because subscription tiers and
+organization policies still apply. Aliases, especially `latest`, can change
+their target and capabilities.
 
 Medium 3.5, Small 4, Large 4, and Ministral 3 support image input; Codestral is
-text-only. Medium/Small/Large expose `none` (default) or `high` thinking, with
-same-provider reasoning replayed in Mistral's native format. Token counting is
+text-only. Medium 3.5, Small 4 and Large 4 expose `none` (default) or `high`
+thinking, with same-provider reasoning replayed in Mistral's native format;
+Large 3, Ministral 3 and Codestral expose no thinking control. Token counting is
 a conservative local estimate with a safety margin, not an exact Mistral
 tokenizer. The catalog's 32,768-token output reservation is Kolega's budgeting
 policy, not a verified native maximum-output ceiling. Kolega Code runs the local
 function-tool loop; Mistral-hosted server tools are not enabled. Native Mistral
 keys and model IDs are separate from gateway credentials and routes.
 
+Mistral publishes models between releases; `kolega-code models refresh --provider mistral`
+caches the live list locally. It adds only models Kolega does not already ship
+and never overrides a bundled spec.
+
 ## Requirements
 
 - **Python 3.11+**

{kolega_code-0.43.0 → kolega_code-0.45.0}/README.md

@@ -180,6 +180,7 @@ Supported model providers:
 - DashScope / Qwen
 - OpenRouter (gateway to 250+ tool-capable models)
 - Moonshot / Kimi
+- MiniMax
 - DeepSeek
 - Z.AI / GLM Coding Plan
 - Kimi Coding Plan
@@ -223,20 +224,27 @@ kolega-code . --provider mistral --model mistral-medium-3-5
 ```
 
 The picker defaults to Mistral Medium 3.5 and includes Mistral Small 4
-(`mistral-small-2603`), Mistral Large 4 **preview** (`mistral-large-4`),
-Ministral 3 (3B/8B/14B), Codestral, and eligible native aliases. Large 4 access
-depends on the account/subscription; a catalog entry does not guarantee access.
-Aliases, especially `latest`, can change their target and capabilities.
+(`mistral-small-2603`), Mistral Large 4 (`mistral-large-4`), Mistral Large 3
+(`mistral-large-2512`), Ministral 3 (3B/8B/14B), Codestral, and eligible native
+aliases. Windows and capabilities mirror Mistral's authenticated model list; a
+catalog entry does not guarantee access, because subscription tiers and
+organization policies still apply. Aliases, especially `latest`, can change
+their target and capabilities.
 
 Medium 3.5, Small 4, Large 4, and Ministral 3 support image input; Codestral is
-text-only. Medium/Small/Large expose `none` (default) or `high` thinking, with
-same-provider reasoning replayed in Mistral's native format. Token counting is
+text-only. Medium 3.5, Small 4 and Large 4 expose `none` (default) or `high`
+thinking, with same-provider reasoning replayed in Mistral's native format;
+Large 3, Ministral 3 and Codestral expose no thinking control. Token counting is
 a conservative local estimate with a safety margin, not an exact Mistral
 tokenizer. The catalog's 32,768-token output reservation is Kolega's budgeting
 policy, not a verified native maximum-output ceiling. Kolega Code runs the local
 function-tool loop; Mistral-hosted server tools are not enabled. Native Mistral
 keys and model IDs are separate from gateway credentials and routes.
 
+Mistral publishes models between releases; `kolega-code models refresh --provider mistral`
+caches the live list locally. It adds only models Kolega does not already ship
+and never overrides a bundled spec.
+
 ## Requirements
 
 - **Python 3.11+**

{kolega_code-0.43.0 → kolega_code-0.45.0}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.43.0"
+__version__ = "0.45.0"

{kolega_code-0.43.0 → kolega_code-0.45.0}/kolega_code/acp/agent_factory.py

@@ -18,6 +18,7 @@ the process keeps serving.
 from __future__ import annotations
 
 import logging
+import os
 from pathlib import Path
 from typing import Any, Awaitable, Callable, cast
 
@@ -38,7 +39,7 @@ from kolega_code.agent.prompt_provider import AgentMode
 from kolega_code.agent.prompts import BUILD_QUESTION_PROMPT, PLANNING_QUESTION_PROMPT
 from kolega_code.agent.tool_definitions import tool_description_asset
 from kolega_code.agent.volatile_context import VolatileSection
-from kolega_code.cli.config import CliConfigOverrides, build_agent_config, config_summary
+from kolega_code.cli.config import API_KEY_ENV, CliConfigOverrides, build_agent_config, config_summary
 from kolega_code.cli.connection import CliConnectionManager
 from kolega_code.cli.provider_registry import PROVIDER_LABELS, ui_model_options
 from kolega_code.cli.session_event_store import FileArtifactStore, FileSessionEventStore
@@ -139,6 +140,15 @@ class AgentFactory:
             return
         self.persist(session)
         try:
+            jobs = getattr(session.agent, "background_jobs", None)
+            if jobs is not None:
+                jobs.set_callbacks(on_ready=None, on_delivered=None)
+                await jobs.close()
+                await jobs.deliver(session.agent)
+            self.persist(session)
+            for old in session.retired_agents:
+                await old.cleanup()
+            session.retired_agents.clear()
             await session.agent.cleanup()
         except Exception:  # noqa: BLE001 — closing must not mask the primary outcome
             logger.exception("acp session close: agent cleanup failed (session=%s)", session_id)
@@ -238,12 +248,24 @@ class AgentFactory:
             settings_store=self._settings_store,
         )
 
-    def _model_option(self, session: AcpSession) -> SessionConfigOptionSelect:
+    def _configured_providers(self) -> list[str]:
+        """Providers the editor can offer: saved keys plus exported credentials.
+
+        ACP spawns as a child of the editor, which inherits the shell
+        environment. The CLI already treats an exported ``*_API_KEY`` as
+        sufficient, so an env-only provider must not be invisible here just
+        because it was never saved through onboarding.
+        """
         assert self._settings is not None
+        providers = {provider for provider, key in self._settings.api_keys.items() if key}
+        providers.update(
+            provider.value for provider, env_name in API_KEY_ENV.items() if (os.environ.get(env_name) or "").strip()
+        )
+        return sorted(providers)
+
+    def _model_option(self, session: AcpSession) -> SessionConfigOptionSelect:
         groups: list[SessionConfigSelectGroup] = []
-        for provider, key in sorted(self._settings.api_keys.items()):
-            if not key:
-                continue
+        for provider in self._configured_providers():
             options = [
                 SessionConfigSelectOption(value=f"{provider}/{model}", name=label)
                 for label, model in ui_model_options(provider)
@@ -315,10 +337,24 @@ class AgentFactory:
             permission_mode=old.permission_mode,
             question_state=session.question_state,
         )
+        # New generations must keep publishing into the session-lifetime event
+        # consumer, including children still using the previous generation.
+        if manager is not session.manager:
+            raise RuntimeError("ACP rebuild must preserve the session connection manager")
         session.agent = agent
-        session.manager = manager
+        jobs = getattr(old, "background_jobs", None)
+        if jobs is not None and agent is not old:
+            agent.background_jobs = jobs
+            agent.background_needs_turn = getattr(old, "background_needs_turn", False)
+            old.background_jobs = None
+        if jobs is not None and jobs.active_count and agent is not old:
+            # Children borrow this generation's terminal/browser/extensions.
+            # Keep it alive until the supervisor has joined them.
+            session.retired_agents.append(old)
+            return
         try:
-            await old.cleanup()
+            if agent is not old:
+                await old.cleanup()
         except Exception:  # noqa: BLE001
             logger.exception("acp model switch: old agent cleanup failed (session=%s)", session.session_id)
 
@@ -369,7 +405,8 @@ class AgentFactory:
     ) -> tuple[CoderAgent, CliConnectionManager]:
         journal = self._store.journal(record.session_id)
         recorder = self._store.recorder(record.session_id)
-        manager = CliConnectionManager()
+        existing = self._acp_sessions.get(record.session_id)
+        manager = existing.manager if existing is not None else CliConnectionManager()
         recording = RecordingConnectionManager(
             manager,
             FileSessionEventStore(journal),

{kolega_code-0.43.0 → kolega_code-0.45.0}/kolega_code/acp/bridge.py

@@ -111,6 +111,12 @@ class AcpBridge:
         #: label the dispatching card's title.
         self._dispatch_labels: dict[str, str] = {}
 
+    def begin_turn(self, agent: Any, diff_provider: AcpDiffProvider) -> None:
+        """Reset turn-only projections, retaining session-lifetime tool maps."""
+        self._agent = agent
+        self._diffs = diff_provider
+        self._turn_response_parts.clear()
+
     async def send(self, session_id: str, update: Any) -> None:
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug(

{kolega_code-0.43.0 → kolega_code-0.45.0}/kolega_code/acp/server.py

@@ -188,6 +188,7 @@ class AcpAgent(Agent):
             return await self._load_sub_session(session_id)
         if session_id in self._sessions:
             existing = self._sessions[session_id]
+            self._start_session_tasks(existing)
             return LoadSessionResponse(config_options=self._factory.config_options_for(existing))
         try:
             session = await self._factory.load_session(
@@ -204,6 +205,7 @@ class AcpAgent(Agent):
         await self._emit_initial_usage(session)
         await self._send_available_commands(session)
         await self._replay_transcript(session)
+        self._start_session_tasks(session)
         return LoadSessionResponse(config_options=self._factory.config_options_for(session))
 
     async def _load_sub_session(self, session_id: str) -> LoadSessionResponse:
@@ -254,11 +256,33 @@ class AcpAgent(Agent):
 
     async def close_session(self, session_id: str, **kwargs: Any) -> None:
         logger.info("acp session/close (session=%s)", session_id)
-        self._sessions.pop(session_id, None)
+        session = self._sessions.pop(session_id, None)
+        if session is not None:
+            session.closed = True
+            session.auto_continue_paused = True
+            if session.turn_task is not None:
+                session.turn_task.cancel()
+                await asyncio.gather(session.turn_task, return_exceptions=True)
+            if session.background_task is not None:
+                session.background_task.cancel()
+                await asyncio.gather(session.background_task, return_exceptions=True)
         self._brokers.pop(session_id, None)
-        await self._factory.close_session(session_id)
+        if session is not None:
+            async with session.execution_lock:
+                await self._factory.close_session(session_id)
+        else:
+            await self._factory.close_session(session_id)
+        if session is not None and session.event_task is not None:
+            session.event_task.cancel()
+            await asyncio.gather(session.event_task, return_exceptions=True)
+            await self._drain_residual(session, session.bridge)
         return None
 
+    async def shutdown(self) -> None:
+        """Join session work before the ACP transport and shared services close."""
+        for session_id in list(self._sessions):
+            await self.close_session(session_id)
+
     # -- turns ------------------------------------------------------------
 
     async def prompt(self, session_id: str, prompt: list[_PromptBlock], **kwargs: Any) -> PromptResponse:
@@ -270,13 +294,19 @@ class AcpAgent(Agent):
         text = self._extract_text(prompt)
         if not text:
             raise RequestError.invalid_request({"message": "prompt contains no text"})
-        stop_reason = await self._run_turn(session, text)
-        self._factory.persist(session)
+        self._start_session_tasks(session)
+        async with session.execution_lock:
+            session.auto_continue_paused = False
+            stop_reason = await self._run_turn(session, text)
+            self._factory.persist(session)
         return PromptResponse(stop_reason=stop_reason)
 
     async def cancel(self, session_id: str, **kwargs: Any) -> None:
         session = self._sessions.get(session_id)
-        if session is None or session.turn_task is None:
+        if session is None:
+            return
+        session.auto_continue_paused = True
+        if session.turn_task is None:
             logger.debug("acp session/cancel: nothing to cancel (session=%s)", session_id)
             return
         logger.info("acp session/cancel (session=%s)", session_id)
@@ -314,7 +344,8 @@ class AcpAgent(Agent):
             raise RequestError.invalid_params({"message": f"unknown mode {mode_id!r}; available: build, plan"})
         if not session.idle():
             raise RequestError.invalid_request({"message": "modes apply between turns only"})
-        await self._factory.set_interaction_mode(session, mode_id)
+        async with session.execution_lock:
+            await self._factory.set_interaction_mode(session, mode_id)
         logger.info("acp session mode -> %s (session=%s)", mode_id, session_id)
         await self._emit_current_mode(session)
         return SetSessionModeResponse()
@@ -342,14 +373,16 @@ class AcpAgent(Agent):
                 raise RequestError.invalid_params({"message": "model option expects 'provider/model'"})
             provider, model = value.split("/", 1)
             try:
-                await self._factory.apply_model(session, provider, model)
+                async with session.execution_lock:
+                    await self._factory.apply_model(session, provider, model)
             except _HANDLED_CONFIG_ERRORS as exc:
                 raise AgentFactory.protocol_error(exc) from exc
             logger.info("acp session config: model -> %s/%s (session=%s)", provider, model, session_id)
         elif config_id == CONFIG_MODE:
             if value not in INTERACTION_MODES:
                 raise RequestError.invalid_params({"message": f"unknown mode {value!r}; available: build, plan"})
-            await self._factory.set_interaction_mode(session, str(value))
+            async with session.execution_lock:
+                await self._factory.set_interaction_mode(session, str(value))
             logger.info("acp session config: mode -> %s (session=%s)", value, session_id)
             await self._emit_current_mode(session)
         else:
@@ -438,6 +471,7 @@ class AcpAgent(Agent):
             return
         await self._emit_initial_usage(session)
         await self._send_available_commands(session)
+        self._start_session_tasks(session)
 
     async def _send_available_commands(self, session: AcpSession) -> None:
         """Advertise the agent's slash commands for the client's command UI.
@@ -525,29 +559,107 @@ class AcpAgent(Agent):
 
     # -- turn machinery ----------------------------------------------------
 
-    async def _run_turn(self, session: AcpSession, text: str) -> StopReason:
+    def _start_session_tasks(self, session: AcpSession) -> None:
+        if session.closed:
+            return
+        if session.event_task is None:
+            session.bridge = AcpBridge(
+                self._conn, diff_provider=AcpDiffProvider.for_session(session), agent=session.agent
+            )
+            session.event_task = asyncio.create_task(
+                self._pump_events(session, session.bridge), name=f"acp-events-{session.session_id}"
+            )
+        # Explicit session activity rearms retained presentation work, including
+        # after a transport failure. The worker must not retry itself on failure.
+        if session.completions:
+            session.background_wake.set()
+        if session.background_task is not None and not session.background_task.done():
+            return
+        get_jobs = getattr(session.agent, "get_background_jobs", None)
+        if callable(get_jobs):
+            jobs: Any = get_jobs()
+
+            def delivered(completion: dict[str, Any]) -> None:
+                session.completions.append(completion)
+                session.background_wake.set()
+
+            jobs.set_callbacks(on_ready=session.background_wake.set, on_delivered=delivered)
+            session.background_task = asyncio.create_task(
+                self._background_worker(session, jobs), name=f"acp-background-{session.session_id}"
+            )
+
+    async def _background_worker(self, session: AcpSession, jobs: Any) -> None:
+        await jobs.recover()
+        if jobs.pending_count:
+            session.background_wake.set()
+        while not session.closed:
+            await session.background_wake.wait()
+            session.background_wake.clear()
+            async with session.execution_lock:
+                if session.closed:
+                    return
+                try:
+                    await jobs.deliver(session.agent)
+                    # Delivery callbacks also wake the worker for reports
+                    # inserted by the running agent. Consume those wakeups now,
+                    # not after sending: a failed send must wait for new activity,
+                    # while readiness arriving during presentation must survive.
+                    session.background_wake.clear()
+                    if jobs.pending_count:
+                        session.background_wake.set()
+                    completions = bool(session.completions)
+                    try:
+                        while session.completions:
+                            completion = session.completions[0]
+                            await session.bridge.send(
+                                session.session_id, update_agent_thought_text(str(completion["text"]))
+                            )
+                            # History insertion is already durable. Acknowledge
+                            # presentation separately, only after this send
+                            # succeeds; failure/cancellation retains the suffix.
+                            session.completions.pop(0)
+                    except Exception:
+                        logger.exception("acp background presentation failed (session=%s)", session.session_id)
+                        continue
+                    if (
+                        completions
+                        and not session.auto_continue_paused
+                        and getattr(session.agent, "background_needs_turn", True)
+                    ):
+                        await self._run_turn(session, None)
+                    self._factory.persist(session)
+                    if jobs is not getattr(session.agent, "background_jobs", None):
+                        return  # a context reset installed another epoch's owner
+                    if not jobs.active_count:
+                        for old in session.retired_agents:
+                            await old.cleanup()
+                        session.retired_agents.clear()
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    # A failed automatic turn must not spin or silently kill
+                    # the prompt owner. Explicit input can resume it.
+                    session.auto_continue_paused = True
+                    logger.exception("acp background delivery failed (session=%s)", session.session_id)
+
+    async def _run_turn(self, session: AcpSession, text: str | None) -> StopReason:
         """Drive one agent turn, mapping its output to ACP updates.
 
-        Returns the ACP stop reason. The event pump runs until the turn task
-        completes, then any residual queued events are drained so late tool
-        results still render.
+        The event pump belongs to the session, not this request. It keeps
+        rendering child activity after a prompt's response has been returned.
         """
-        session.drain_events()
-        bridge = AcpBridge(self._conn, diff_provider=AcpDiffProvider.for_session(session), agent=session.agent)
+        self._start_session_tasks(session)
+        bridge = session.bridge
+        bridge.begin_turn(session.agent, AcpDiffProvider.for_session(session))
         session.turn_task = asyncio.create_task(self._drive_turn(session, bridge, text))
-        pump = asyncio.create_task(self._pump_events(session, bridge))
+        reason: StopReason = "cancelled"
         try:
-            return await session.turn_task
+            reason = await session.turn_task
+            return reason
         finally:
-            pump.cancel()
-            try:
-                await pump
-            except asyncio.CancelledError:
-                pass
-            await self._drain_residual(session, bridge)
             session.turn_task = None
             await bridge.emit_usage(session.session_id)
-            plan = self._consume_plan(session, bridge)
+            plan = self._consume_plan(session, bridge) if reason != "cancelled" and not session.closed else None
             if plan:
                 session.record.latest_plan_markdown = plan
                 session.record.plan_pending = True
@@ -606,6 +718,20 @@ class AcpAgent(Agent):
             session.record.plan_pending = False
             session.record.plan_reofferable = False
             if option_id == "implement_plan_clear":
+                jobs = getattr(session.agent, "background_jobs", None)
+                if jobs is not None:
+                    # The reset starts another epoch. Settle old-context work
+                    # before clearing its history and creating a new owner.
+                    jobs.set_callbacks(on_ready=None, on_delivered=None)
+                    await jobs.close()
+                    await jobs.deliver(session.agent)
+                    session.agent.background_jobs = None
+                    if session.background_task is not None and session.background_task is not asyncio.current_task():
+                        session.background_task.cancel()
+                        await asyncio.gather(session.background_task, return_exceptions=True)
+                    session.background_task = None
+                    session.completions.clear()
+                    session.background_wake.clear()
                 self._clear_agent_context(session)
             await self._factory.set_interaction_mode(session, MODE_BUILD)
             await self._emit_current_mode(session)
@@ -630,9 +756,14 @@ class AcpAgent(Agent):
         session.record.history = []
         session.record.compaction = {}
 
-    async def _drive_turn(self, session: AcpSession, bridge: AcpBridge, text: str) -> str:
+    async def _drive_turn(self, session: AcpSession, bridge: AcpBridge, text: str | None) -> StopReason:
         try:
-            async for chunk in session.agent.process_message_stream(text):
+            stream = (
+                session.agent.process_message_stream(text)
+                if text is not None
+                else session.agent.continue_from_history_stream()
+            )
+            async for chunk in stream:
                 await bridge.emit_chunk(session.session_id, chunk)
             return "end_turn"
         except asyncio.CancelledError:

{kolega_code-0.43.0 → kolega_code-0.45.0}/kolega_code/acp/session.py

@@ -33,14 +33,15 @@ class AcpSession:
     question_state: dict[str, Any] = field(default_factory=dict)
     #: In-flight turn task; None when the session is idle. Set and cleared by the server.
     turn_task: asyncio.Task | None = field(default=None, repr=False)
+    execution_lock: asyncio.Lock = field(default_factory=asyncio.Lock, repr=False)
+    event_task: asyncio.Task[None] | None = field(default=None, repr=False)
+    background_task: asyncio.Task[None] | None = field(default=None, repr=False)
+    bridge: Any = field(default=None, repr=False)
+    background_wake: asyncio.Event = field(default_factory=asyncio.Event, repr=False)
+    completions: list[dict[str, Any]] = field(default_factory=list)
+    auto_continue_paused: bool = False
+    closed: bool = False
+    retired_agents: list[Any] = field(default_factory=list, repr=False)
 
     def idle(self) -> bool:
-        return self.turn_task is None or self.turn_task.done()
-
-    def drain_events(self) -> None:
-        """Drop any events left over from a previous turn (stale mapping inputs)."""
-        while not self.manager.events.empty():
-            try:
-                self.manager.events.get_nowait()
-            except asyncio.QueueEmpty:
-                break
+        return not self.execution_lock.locked() and (self.turn_task is None or self.turn_task.done())

{kolega_code-0.43.0 → kolega_code-0.45.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.43.0"
+__version__ = "0.45.0"