kon-coding-agent 0.3.5__tar.gz → 0.3.6__tar.gz

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/CHANGELOG.md

@@ -6,6 +6,28 @@ All notable changes to this project will be documented in this file.
 
 - No changes yet.
 
+## 0.3.6 - 2026-04-23
+
+### Added
+
+- Configurable terminal bell notifications on response completion.
+- Render LaTeX math as Unicode in markdown output - @toojays.
+- Style approval popup with button-like controls and panel background.
+- Permission popup title card and improved UI formatting.
+
+### Changed
+
+- Improved UI for approval popup.
+- Reduce LaTeX preprocessing overhead.
+- Improved Codex SSE error extraction and retry on transient errors.
+
+### Fixed
+
+- Rewrite web_fetch to bypass bot-detection, preserve indentation, and harden against SSRF - @Meltedd (#28, #29).
+- Remove unused turn streaming state.
+- Remove unused tool imports.
+- Remove empty blocks.
+
 ## 0.3.5 - 2026-04-18
 
 ### Added

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/PKG-INFO

@@ -1,19 +1,21 @@
 Metadata-Version: 2.4
 Name: kon-coding-agent
-Version: 0.3.5
+Version: 0.3.6
 Summary: Minimal coding agent
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: aiofiles>=25.1.0
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: anthropic>=0.79.0
+Requires-Dist: curl-cffi>=0.15.0
 Requires-Dist: ddgs>=9.0.0
+Requires-Dist: html-to-markdown>=3.1.0
 Requires-Dist: openai>=2.21.0
 Requires-Dist: pillow>=12.1.1
 Requires-Dist: pydantic>=2.12.5
+Requires-Dist: readability-lxml>=0.8.4
 Requires-Dist: rich>=14.3.2
 Requires-Dist: textual>=8.0.0
-Requires-Dist: trafilatura>=2.0.0
 Description-Content-Type: text/markdown
 
 <h1 align="center">Kon</h1>
@@ -475,12 +477,6 @@ If `fd` or `rg` are missing, Kon can download them automatically.
 
 ---
 
-## Documentation
-
-- [Local models](docs/local-models.md) - Running Kon with local OpenAI-compatible models, plus tested setups and example commands.
-
----
-
 ## Acknowledgements
 
 - Kon takes significant inspiration from [pi coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent), especially around philosophy and UI direction.

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/README.md

@@ -457,12 +457,6 @@ If `fd` or `rg` are missing, Kon can download them automatically.
 
 ---
 
-## Documentation
-
-- [Local models](docs/local-models.md) - Running Kon with local OpenAI-compatible models, plus tested setups and example commands.
-
----
-
 ## Acknowledgements
 
 - Kon takes significant inspiration from [pi coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent), especially around philosophy and UI direction.

kon_coding_agent-0.3.6/docs/code-health-scan.md

@@ -0,0 +1,144 @@
+# Code Health Scan: Additional Notable Issues
+
+This note captures only the additional issues found in a fresh repo scan that are **not** the same as the already-known architectural concerns in `docs/architecture-review.md`.
+
+The baseline conclusion from the earlier review still stands:
+
+- the core runtime is strong
+- the TUI still owns too much runtime/session orchestration
+- the large controller/runtime-manager refactor is deferred for now
+
+This document is intentionally narrower. It records only the standout issue and the smaller cleanup opportunities found in the current repo state after the recent cleanup pass.
+
+## Overall verdict
+
+Aside from the already-documented UI/runtime orchestration boundary issue, the repo looks to be in decent shape overall.
+
+Notable signals:
+
+- test suite passed cleanly
+- pyright passed cleanly
+- only a few lint issues remained
+
+So this is **not** a case where the repo appears to have multiple additional architectural problems lurking elsewhere. The main new thing worth tracking is a state-consistency problem around provider/model transitions, plus a few smaller cleanup items.
+
+## Major issue
+
+### Provider/model transition paths are not transactional
+
+The main additional issue is that some provider/model/session transition flows update app state before it is certain that the replacement provider/runtime state can be constructed successfully.
+
+Relevant files:
+
+- `src/kon/ui/commands.py`
+- `src/kon/ui/session_ui.py`
+
+### Where it shows up
+
+#### `src/kon/ui/commands.py::_select_model`
+
+This path updates:
+
+- `self._model`
+- `self._model_provider`
+
+before provider recreation is guaranteed to succeed.
+
+If `_create_provider(...)` fails, the UI reports the error, but some selected-model state may already have been changed while the active provider/agent runtime is still using the old provider instance.
+
+#### `src/kon/ui/session_ui.py::_load_session`
+
+This path loads session metadata and updates model/provider-related state while also trying to reconcile the active provider.
+
+If provider recreation fails during session load, the code reports the error, but can still leave partially updated state behind:
+
+- loaded session state may now be active
+- selected model/provider values may reflect the resumed session
+- the provider instance may still be the old one or only partially reconfigured
+
+### Why this matters
+
+This is not a large-architecture problem, but it is a real correctness risk.
+
+It can produce subtle mismatches between:
+
+- selected model/provider UI state
+- active provider config
+- agent runtime state
+- resumed session metadata
+
+Those failures are harder to reason about than a simple hard error because the app can continue running in a partially updated state.
+
+### Suggested direction
+
+Without doing the large architecture refactor, the safer short-term fix would be to make these transitions more atomic:
+
+1. compute the target model/provider/session state first
+2. build or validate the replacement provider first
+3. only commit the new state to `self._model`, `self._model_provider`, `self._provider`, `self._session`, and `self._agent` after success
+4. otherwise leave the old runtime state untouched
+
+Even a small helper that stages the new state before assignment would reduce the sync-risk significantly.
+
+## Small cleanup opportunities
+
+### 1. `CompactionEntry.first_kept_entry_id` is currently misleading
+
+Relevant file:
+
+- `src/kon/session.py`
+
+`CompactionEntry` stores `first_kept_entry_id`, and comments imply that the compacted view depends on it.
+
+However, `Session.messages` currently reconstructs the compacted view by:
+
+- finding the last compaction entry
+- inserting the synthetic summary pair
+- including message entries after the compaction entry itself
+
+It does **not** currently use `first_kept_entry_id` to decide what to retain.
+
+This is not a functional bug in current usage because existing callers/tests append compaction entries in a way that still makes the behavior correct. But the data model and implementation intent are slightly out of sync, which makes the field more confusing than helpful right now.
+
+Small fix options:
+
+- actually use `first_kept_entry_id` in `Session.messages`, or
+- simplify the field/comment contract if the compaction-entry position is the real source of truth
+
+### 2. System-prompt fallback logic is still duplicated across UI mixins
+
+Relevant files:
+
+- `src/kon/ui/commands.py`
+- `src/kon/ui/session_ui.py`
+
+Both files define the same `_resolve_system_prompt(...)` helper:
+
+- use persisted `session.system_prompt` when available
+- otherwise rebuild with `build_system_prompt(...)`
+
+This is a small issue, not a major design problem, but it means the recent centralization is still only partial. If the fallback behavior changes again, both copies will need to stay in sync.
+
+Small fix option:
+
+- move the helper to one shared non-duplicated location used by both mixins/app paths
+
+### 3. Lint cleanup remains in a few tool modules
+
+Relevant files:
+
+- `src/kon/tools/find.py`
+- `src/kon/tools/grep.py`
+- `src/kon/tools/web_fetch.py`
+
+Current lint output shows unused imports of `truncate_text` in these files.
+
+This is only a hygiene issue, but it is a useful signal that a full lint pass likely did not happen after some recent edits.
+
+## Final assessment
+
+The repo looks fine overall.
+
+Aside from the already-known concerns in `docs/architecture-review.md`, the only additional issue that really stands out is the non-transactional provider/model/session transition behavior.
+
+The other findings are small cleanup opportunities rather than signs of deeper architectural trouble.

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/pyproject.toml

@@ -14,7 +14,7 @@ default = true
 
 [project]
 name = "kon-coding-agent"
-version = "0.3.5"
+version = "0.3.6"
 description = "Minimal coding agent"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -22,13 +22,15 @@ dependencies = [
     "aiofiles>=25.1.0",
     "aiohttp>=3.13.3",
     "anthropic>=0.79.0",
+    "curl-cffi>=0.15.0",
+    "ddgs>=9.0.0",
+    "html-to-markdown>=3.1.0",
     "openai>=2.21.0",
     "pillow>=12.1.1",
     "pydantic>=2.12.5",
+    "readability-lxml>=0.8.4",
     "rich>=14.3.2",
     "textual>=8.0.0",
-    "ddgs>=9.0.0",
-    "trafilatura>=2.0.0",
 ]
 
 [dependency-groups]
@@ -60,6 +62,10 @@ select = [
     "RUF", # ruff-specific rules
 ]
 
+[tool.ruff.lint.per-file-ignores]
+"src/kon/ui/latex.py" = ["RUF001"]
+"tests/ui/test_latex.py" = ["RUF001"]
+
 [tool.ruff.lint.isort]
 split-on-trailing-comma = false
 

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/config.py

@@ -98,6 +98,10 @@ class ToolsConfig(BaseModel):
     extra: list[str] = []
 
 
+class NotificationsConfig(BaseModel):
+    enabled: bool = False
+
+
 class ConfigSchema(BaseModel):
     meta: MetaConfig
     llm: LLMConfig
@@ -106,6 +110,7 @@ class ConfigSchema(BaseModel):
     agent: AgentConfig
     tools: ToolsConfig = ToolsConfig()
     permissions: PermissionsConfig
+    notifications: NotificationsConfig = NotificationsConfig()
 
 
 # =================================================================================================
@@ -194,6 +199,10 @@ class Config:
     def tools(self) -> ToolsConfig:
         return self._parsed.tools
 
+    @property
+    def notifications(self) -> NotificationsConfig:
+        return self._parsed.notifications
+
     @property
     def binaries(self) -> _BinariesConfig:
         return _BinariesConfig(AVAILABLE_BINARIES)

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/defaults/config.toml

@@ -73,3 +73,8 @@ collapse_thinking = true
 # "prompt" asks before edits/writes and other mutating actions.
 # "auto" allows tool calls without approval prompts.
 mode = "prompt" # "prompt" or "auto"
+
+[notifications]
+# Ring the terminal bell when kon finishes a task or waits for tool approval.
+# Disabled by default.
+enabled = false

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/llm/providers/openai_codex_responses.py

@@ -279,11 +279,26 @@ class OpenAICodexResponsesProvider(BaseProvider):
                             yield StreamDone(stop_reason=stop_reason)
                             return
 
-                    elif event_type in {"response.failed", "error"}:
+                    elif event_type == "error":
+                        code = event.get("code")
                         message = event.get("message")
-                        if not isinstance(message, str):
-                            message = "Codex response failed"
-                        yield StreamError(error=message)
+                        if isinstance(message, str) and message:
+                            yield StreamError(error=f"Codex error: {message}")
+                        elif isinstance(code, str) and code:
+                            yield StreamError(error=f"Codex error: {code}")
+                        else:
+                            yield StreamError(error=f"Codex error: {json.dumps(event)}")
+                        return
+
+                    elif event_type == "response.failed":
+                        response_obj = event.get("response")
+                        msg = None
+                        if isinstance(response_obj, dict):
+                            err = response_obj.get("error")
+                            if isinstance(err, dict):
+                                msg = err.get("message")
+                        err_msg = msg if isinstance(msg, str) and msg else "Codex response failed"
+                        yield StreamError(error=err_msg)
                         return
             finally:
                 await session.close()
@@ -321,7 +336,8 @@ class OpenAICodexResponsesProvider(BaseProvider):
         return StopReason.STOP
 
     def should_retry_for_error(self, error: Exception) -> bool:
-        return False
+        msg = str(error).lower()
+        return any(kw in msg for kw in ("429", "rate_limit", "server_error", "502", "503", "504"))
 
 
 def is_openai_logged_in() -> bool:

kon_coding_agent-0.3.6/src/kon/notify.py

@@ -0,0 +1,30 @@
+import os
+import time
+
+_BELL_DEBOUNCE_S = 0.5
+_last_bell_time: float = 0.0
+
+
+def _raw_write(data: bytes) -> None:
+    try:
+        fd = os.open("/dev/tty", os.O_WRONLY | os.O_NOCTTY)
+        try:
+            os.write(fd, data)
+        finally:
+            os.close(fd)
+    except OSError:
+        os.write(2, data)
+
+
+def _bell() -> None:
+    global _last_bell_time
+    now = time.monotonic()
+    if now - _last_bell_time < _BELL_DEBOUNCE_S:
+        return
+    _last_bell_time = now
+    _raw_write(b"\a")
+
+
+def notify(title: str, message: str) -> None:
+    del title, message
+    _bell()

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/tools/find.py

@@ -10,7 +10,6 @@ from ._tool_utils import (
     communicate_or_cancel,
     shorten_path,
     truncate_lines_by_bytes,
-    truncate_text,
 )
 from .base import BaseTool
 
@@ -44,8 +43,7 @@ class FindTool(BaseTool):
         parts = [f'"{pattern}"']
         if params.path:
             parts.append(f"in {shorten_path(params.path)}")
-        message = " ".join(parts)
-        return truncate_text(message)
+        return " ".join(parts)
 
     async def execute(
         self, params: FindParams, cancel_event: asyncio.Event | None = None

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/tools/grep.py

@@ -11,7 +11,6 @@ from ._tool_utils import (
     communicate_or_cancel,
     shorten_path,
     truncate_lines_by_bytes,
-    truncate_text,
 )
 from .base import BaseTool
 
@@ -49,8 +48,7 @@ class GrepTool(BaseTool):
             parts.append(f"in {shorten_path(params.path)}")
         if params.include:
             parts.append(f"({params.include})")
-        message = " ".join(parts)
-        return truncate_text(message)
+        return " ".join(parts)
 
     async def execute(
         self, params: GrepParams, cancel_event: asyncio.Event | None = None

kon_coding_agent-0.3.6/src/kon/tools/web_fetch.py

@@ -0,0 +1,160 @@
+import asyncio
+import ipaddress
+from urllib.parse import urlparse
+
+from curl_cffi import AsyncSession, CurlOpt
+from html_to_markdown import ConversionOptions, convert
+from lxml import html as lxml_html
+from pydantic import BaseModel, Field
+from readability import Document
+
+from ..core.types import ToolResult
+from ._tool_utils import ToolCancelledError, await_task_or_cancel
+from .base import BaseTool
+
+MAX_CHARS = 80_000
+MAX_CHARS_PER_LINE = 2000
+MAX_RESPONSE_BYTES = 20_000_000
+REQUEST_TIMEOUT = 15
+
+# Only checked on failure paths, so false positives can't suppress real content.
+_CHALLENGE_SIGNATURES = (
+    "please wait for verification",  # Reddit 200 JS challenge
+    "prove your humanity",  # Reddit 200 reCAPTCHA gate
+    "whoa there, pardner",  # Reddit 403 ratelimit page
+    "just a moment...",  # Cloudflare
+    "checking your browser",  # Cloudflare (legacy)
+    "attention required",  # Cloudflare block page
+)
+
+# Inline SVG data URIs would otherwise become base64 noise.
+_CONVERT_OPTIONS = ConversionOptions(skip_images=True)
+
+# concat(';', ...) anchors to a property boundary to block url() false positives.
+_HIDDEN_XPATH = (
+    "//script | //style | //noscript | //template"
+    " | //*[@hidden or @aria-hidden='true']"
+    " | //*[contains(concat(';', translate(@style, ' \t\n', '')), ';display:none')]"
+    " | //*[contains(concat(';', translate(@style, ' \t\n', '')), ';visibility:hidden')]"
+)
+
+
+def _looks_like_challenge(html: str) -> bool:
+    head = html[:4096].lower()
+    return any(sig in head for sig in _CHALLENGE_SIGNATURES)
+
+
+def _is_link_local(ip: str) -> bool:
+    try:
+        return ipaddress.ip_address(ip).is_link_local
+    except ValueError:
+        return True  # fail closed
+
+
+def _extract_markdown(html: str) -> str | None:
+    if not html:
+        return None
+    try:
+        tree = lxml_html.fromstring(html)
+        for node in tree.xpath(_HIDDEN_XPATH):
+            if (parent := node.getparent()) is not None:
+                parent.remove(node)
+        doc_input = tree
+    except Exception:
+        doc_input = html  # fall back to readability's own lenient parser
+    summary_html = Document(doc_input).summary()
+    if not summary_html or len(summary_html) < 50:
+        return None
+    return convert(summary_html, _CONVERT_OPTIONS).content or None
+
+
+class WebFetchParams(BaseModel):
+    url: str = Field(description="URL of the web page to fetch and extract content from")
+
+
+class WebFetchTool(BaseTool):
+    name = "web_fetch"
+    tool_icon = "%"
+    mutating = False
+    params = WebFetchParams
+    description = (
+        "Fetch a web page and extract its main content as clean markdown. "
+        "Strips navigation, ads, and boilerplate. "
+        "Use web_search first to find relevant URLs (if not provided by the user)."
+    )
+
+    def format_call(self, params: WebFetchParams) -> str:
+        return params.url
+
+    async def execute(
+        self, params: WebFetchParams, cancel_event: asyncio.Event | None = None
+    ) -> ToolResult:
+        scheme = urlparse(params.url).scheme
+        if scheme not in ("http", "https"):
+            msg = f"Refused: unsupported scheme {scheme!r}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        try:
+            async with AsyncSession(
+                impersonate="chrome131",
+                allow_redirects="safe",
+                curl_options={CurlOpt.MAXFILESIZE_LARGE: MAX_RESPONSE_BYTES},
+            ) as session:
+                fetch_task = asyncio.create_task(session.get(params.url, timeout=REQUEST_TIMEOUT))
+                response = await await_task_or_cancel(fetch_task, cancel_event)
+        except ToolCancelledError:
+            return ToolResult(success=False, result="Fetch aborted")
+        except Exception as e:
+            msg = f"Fetch failed: {e}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if _is_link_local(response.primary_ip):
+            msg = f"Refused: link-local address ({response.primary_ip or 'unknown'})"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        # Catches decompression bombs (MAXFILESIZE_LARGE only bounds wire bytes).
+        if len(response.content) > MAX_RESPONSE_BYTES:
+            msg = f"Response too large (>{MAX_RESPONSE_BYTES:,} bytes decoded)"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if not (200 <= response.status_code < 300):
+            status = f"HTTP {response.status_code}"
+            msg = (
+                f"Site appears to block automated fetchers ({status})"
+                if _looks_like_challenge(response.text)
+                else status
+            )
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        html = response.text
+
+        try:
+            extract_task = asyncio.create_task(asyncio.to_thread(_extract_markdown, html))
+            content = await await_task_or_cancel(extract_task, cancel_event)
+        except ToolCancelledError:
+            return ToolResult(success=False, result="Extraction aborted")
+        except Exception as e:
+            msg = f"Extraction failed: {e}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if not content:
+            msg = (
+                "Site appears to block automated fetchers"
+                if _looks_like_challenge(html)
+                else "Couldn't extract content"
+            )
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        content = "\n".join(line[:MAX_CHARS_PER_LINE] for line in content.split("\n"))
+
+        char_count = len(content)
+        truncated = char_count > MAX_CHARS
+        if truncated:
+            cut = content.rfind("\n", 0, MAX_CHARS)
+            content = content[: cut if cut > 0 else MAX_CHARS] + "\n\n[content truncated]"
+
+        ui_summary = f"[dim]({char_count:,} chars)[/dim]"
+        if truncated:
+            ui_summary += " [yellow](truncated)[/yellow]"
+
+        return ToolResult(success=True, result=content, ui_summary=ui_summary)

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/turn.py

@@ -312,7 +312,6 @@ async def run_single_turn(
     current_state: StreamState | None = None
     stop_reason: StopReason = StopReason.STOP
     interrupted = False
-    has_meaningful_output = False
 
     def _finalize_current_state(include_empty: bool = True) -> list[StreamEvent]:
         nonlocal current_state, current_tool_call, think_buffer, think_signature, text_buffer
@@ -437,14 +436,16 @@ async def run_single_turn(
 
                 current_state = StreamState.THINK
                 think_buffer.append(t)
-                has_meaningful_output = True
                 if sig:
                     think_signature = sig
 
                 yield ThinkingDeltaEvent(delta=t)
 
             case TextPart(text=t):
-                if not has_meaningful_output and not t.strip():
+                # Skip whitespace-only text that would start a new (empty)
+                # content block — prevents phantom gaps between thinking
+                # and tool-call blocks.
+                if not t.strip() and current_state != StreamState.TEXT:
                     continue
 
                 if current_state and current_state != StreamState.TEXT:
@@ -456,14 +457,11 @@ async def run_single_turn(
 
                 current_state = StreamState.TEXT
                 text_buffer.append(t)
-                if t.strip():
-                    has_meaningful_output = True
 
                 yield TextDeltaEvent(delta=t)
 
             case ToolCallStart(id=id, name=name, arguments=initial_arguments):
                 tool_call_count += 1
-                has_meaningful_output = True
                 if current_state and current_state != StreamState.TOOL_CALL:
                     for finalize_event in _finalize_current_state():
                         yield finalize_event

{kon_coding_agent-0.3.5 → kon_coding_agent-0.3.6}/src/kon/ui/app.py

@@ -61,6 +61,7 @@ from ..llm import (
 )
 from ..llm.base import AuthMode
 from ..loop import Agent
+from ..notify import notify
 from ..permissions import ApprovalResponse
 from ..session import Session
 from ..tools import DEFAULT_TOOLS, EXTRA_TOOLS, get_tool, get_tools
@@ -94,13 +95,14 @@ _CHANGELOG_URL = "https://github.com/0xku/kon/blob/main/CHANGELOG.md"
 try:
     VERSION = version(_PYPI_PACKAGE_NAME)
 except PackageNotFoundError:
-    VERSION = "0.3.5"
+    VERSION = "0.3.6"
 
 _COPILOT_API_TYPES: frozenset[ApiType] = frozenset(
     {ApiType.GITHUB_COPILOT, ApiType.GITHUB_COPILOT_RESPONSES, ApiType.ANTHROPIC_COPILOT}
 )
 
 _OPENAI_OAUTH_API_TYPES: frozenset[ApiType] = frozenset({ApiType.OPENAI_CODEX_RESPONSES})
+_NOTIFY_EVENTS = (AgentEndEvent, ToolApprovalEvent)
 
 _API_TYPE_BY_PROVIDER: dict[type[BaseProvider], ApiType] = {
     v: k for k, v in API_TYPE_TO_PROVIDER_CLASS.items()
@@ -846,6 +848,15 @@ class Kon(CommandsMixin, SessionUIMixin, App[None]):
         normal_items = [(display, False) for display, _ in self._pending_queue]
         queue_display.update_items(steer_items + normal_items)
 
+    def _should_notify_for_event(self, event: object) -> bool:
+        if not config.notifications.enabled:
+            return False
+        if not isinstance(event, _NOTIFY_EVENTS):
+            return False
+        return not (
+            isinstance(event, AgentEndEvent) and event.stop_reason == StopReason.INTERRUPTED
+        )
+
     async def _run_agent(self, prompt: str) -> None:
         chat = self.query_one("#chat-log", ChatLog)
         status = self.query_one("#status-line", StatusLine)
@@ -890,6 +901,9 @@ class Kon(CommandsMixin, SessionUIMixin, App[None]):
                 async for event in self._agent.run(
                     current_prompt, cancel_event=self._cancel_event, steer_event=self._steer_event
                 ):
+                    if self._should_notify_for_event(event):
+                        notify("kon", "Task complete")
+
                     match event:
                         case AgentStartEvent():
                             pass