code-puppy 0.0.655__tar.gz → 0.0.657__tar.gz

{code_puppy-0.0.655 → code_puppy-0.0.657}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.655
+Version: 0.0.657
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/command_line/config_apply.py

@@ -17,6 +17,7 @@ from typing import Optional
 MODEL_SETTINGS_ONLY_KEYS = frozenset(
     {
         "openai_reasoning_effort",
+        "openai_reasoning_summary",
         "openai_verbosity",
     }
 )

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/command_line/config_commands.py

@@ -38,9 +38,8 @@ def handle_show_command(command: str) -> bool:
         get_compaction_strategy,
         get_compaction_threshold,
         get_default_agent,
+        get_effective_model_settings,
         get_effective_temperature,
-        get_openai_reasoning_effort,
-        get_openai_verbosity,
         get_owner_name,
         get_protected_token_count,
         get_puppy_name,
@@ -63,6 +62,7 @@ def handle_show_command(command: str) -> bool:
     compaction_strategy = get_compaction_strategy()
     global_temperature = get_temperature()
     effective_temperature = get_effective_temperature(model)
+    model_settings = get_effective_model_settings(model)
 
     # Get current agent info
     current_agent = get_current_agent()
@@ -81,8 +81,8 @@ def handle_show_command(command: str) -> bool:
 [bold]compaction_threshold:[/bold]     [cyan]{compaction_threshold:.1%}[/cyan] context usage triggers compaction
 [bold]compaction_strategy:[/bold]   [cyan]{compaction_strategy}[/cyan] (summarization or truncation)
 [bold]resume_message_count:[/bold] [cyan]{get_resume_message_count()}[/cyan] messages shown on /resume
-[bold]reasoning_effort:[/bold]      [cyan]{get_openai_reasoning_effort()}[/cyan]
-[bold]verbosity:[/bold]             [cyan]{get_openai_verbosity()}[/cyan]
+[bold]reasoning_effort:[/bold]      [cyan]{model_settings.get("reasoning_effort", "(model default)")}[/cyan]
+[bold]verbosity:[/bold]             [cyan]{model_settings.get("verbosity", "(model default)")}[/cyan]
 [bold]temperature:[/bold]           [cyan]{effective_temperature if effective_temperature is not None else "(model default)"}[/cyan]{" (per-model)" if effective_temperature != global_temperature and effective_temperature is not None else ""}
 [bold]cancel_agent_key:[/bold]      [cyan]{get_cancel_agent_display_name()}[/cyan] (options: ctrl+c, ctrl+k, ctrl+q)
 

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/command_line/model_settings_menu.py

@@ -23,16 +23,10 @@ from code_puppy.command_line.pagination import (
 from code_puppy.config import (
     get_all_model_settings,
     get_global_model_name,
-    get_openai_reasoning_effort,
-    get_openai_reasoning_summary,
-    get_openai_verbosity,
     get_value,
     model_supports_setting,
     reset_value,
     set_model_setting,
-    set_openai_reasoning_effort,
-    set_openai_reasoning_summary,
-    set_openai_verbosity,
     set_value,
 )
 from code_puppy.messaging import emit_info
@@ -276,20 +270,13 @@ def _write_per_model_retry(model_name: str, menu_key: str, value) -> None:
 
 
 def _get_model_display_settings(model_name: str) -> Dict:
-    """Get model settings merged with global OpenAI controls for display."""
+    """Get configured model settings plus model-specific display defaults."""
     settings = get_all_model_settings(model_name)
 
-    if model_supports_setting(model_name, "reasoning_effort"):
-        settings["reasoning_effort"] = get_openai_reasoning_effort()
     if model_supports_setting(model_name, "reasoning_context"):
         settings.setdefault("reasoning_context", "all_turns")
     if model_supports_setting(model_name, "reasoning_mode"):
         settings.setdefault("reasoning_mode", "standard")
-    if model_supports_setting(model_name, "summary"):
-        settings["summary"] = get_openai_reasoning_summary()
-    if model_supports_setting(model_name, "verbosity"):
-        settings["verbosity"] = get_openai_verbosity()
-
     # Per-model retry overrides live in their own namespace, so inject their
     # current values here (only when actually set -- unset shows the default).
     for menu_key in _RETRY_MENU_KEYS:
@@ -692,14 +679,6 @@ class ModelSettingsMenu:
             lines.append(("class:tui.label", f"  {setting_def['name']}"))
             lines.append(("", "\n"))
 
-            # Show if this is a global setting
-            if setting_key in ("reasoning_effort", "verbosity"):
-                lines.append(
-                    (
-                        "class:tui.warning",
-                        "  ⚠ Global setting (applies to all GPT-5 models)",
-                    )
-                )
             lines.append(("", "\n\n"))
 
             # Description
@@ -864,17 +843,7 @@ class ModelSettingsMenu:
 
         setting_key = self.supported_settings[self.setting_index]
 
-        # Handle global OpenAI settings specially
-        if setting_key == "reasoning_effort":
-            if self.edit_value is not None:
-                set_openai_reasoning_effort(self.edit_value)
-        elif setting_key == "summary":
-            if self.edit_value is not None:
-                set_openai_reasoning_summary(self.edit_value)
-        elif setting_key == "verbosity":
-            if self.edit_value is not None:
-                set_openai_verbosity(self.edit_value)
-        elif setting_key in _RETRY_MENU_KEYS:
+        if setting_key in _RETRY_MENU_KEYS:
             # Per-model retry override -> dedicated retry_model_ namespace.
             _write_per_model_retry(self.selected_model, setting_key, self.edit_value)
         else:
@@ -907,17 +876,7 @@ class ModelSettingsMenu:
             # Reset edit value to default
             self.edit_value = _get_setting_default(setting_key, self.selected_model)
         else:
-            # Handle global OpenAI settings - reset to their defaults
-            if setting_key == "reasoning_effort":
-                set_openai_reasoning_effort("medium")  # Default
-                self.current_settings[setting_key] = "medium"
-            elif setting_key == "summary":
-                set_openai_reasoning_summary("auto")  # Default
-                self.current_settings[setting_key] = "auto"
-            elif setting_key == "verbosity":
-                set_openai_verbosity("medium")  # Default
-                self.current_settings[setting_key] = "medium"
-            elif setting_key in _RETRY_MENU_KEYS:
+            if setting_key in _RETRY_MENU_KEYS:
                 # Clear the per-model retry override -> falls back to global.
                 _write_per_model_retry(self.selected_model, setting_key, None)
                 if setting_key in self.current_settings:

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/command_line/set_menu_catalog.py

@@ -43,7 +43,6 @@ from code_puppy.config import (
     get_mcp_disabled,
     get_mcp_unbound_warning_silenced,
     get_message_limit,
-    get_openai_reasoning_summary,
     get_output_level,
     get_owner_name,
     get_pack_agents_enabled,
@@ -265,21 +264,6 @@ _COMPACTION = SettingsCategory(
 )
 
 
-_OPENAI = SettingsCategory(
-    name="OpenAI",
-    settings=(
-        Setting(
-            key="openai_reasoning_summary",
-            display_name="Reasoning Summary",
-            description="Style of reasoning summary shown to the user.",
-            type_hint="choice",
-            valid_values=("auto", "concise", "detailed"),
-            effective_getter=get_openai_reasoning_summary,
-        ),
-    ),
-)
-
-
 _FEATURES = SettingsCategory(
     name="Features",
     settings=(
@@ -629,7 +613,6 @@ SETTINGS_CATEGORIES: Tuple[SettingsCategory, ...] = (
     _SESSION,
     _COMPACTION,
     _OUTPUT,
-    _OPENAI,
     _FEATURES,
     _MCP,
     _GOAL,

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/config.py

@@ -5,7 +5,7 @@ import json
 import logging
 import os
 import pathlib
-from typing import Optional
+from typing import Any, Optional
 
 from code_puppy.session_storage import save_session
 
@@ -393,9 +393,6 @@ def get_config_keys():
         "summarization_model",
         "message_limit",
         "allow_recursion",
-        "openai_reasoning_effort",
-        "openai_reasoning_summary",
-        "openai_verbosity",
         "auto_save_session",
         "max_saved_sessions",
         "http2",
@@ -855,78 +852,6 @@ def set_puppy_token(token: str):
     set_config_value("puppy_token", token)
 
 
-def get_openai_reasoning_effort() -> str:
-    """Return the configured OpenAI reasoning effort."""
-    allowed_values = {"minimal", "low", "medium", "high", "xhigh", "ultra"}
-    configured = (get_value("openai_reasoning_effort") or "medium").strip().lower()
-    if configured not in allowed_values:
-        return "medium"
-    return configured
-
-
-def set_openai_reasoning_effort(value: str) -> None:
-    """Persist the OpenAI reasoning effort ensuring it remains within allowed values."""
-    allowed_values = {"minimal", "low", "medium", "high", "xhigh", "ultra"}
-    normalized = (value or "").strip().lower()
-    if normalized not in allowed_values:
-        raise ValueError(
-            f"Invalid reasoning effort '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
-        )
-    set_config_value("openai_reasoning_effort", normalized)
-
-
-def get_openai_reasoning_summary() -> str:
-    """Return the configured OpenAI reasoning summary mode.
-
-    Supported values:
-    - auto: let the provider decide the best summary style
-    - concise: shorter reasoning summaries
-    - detailed: fuller reasoning summaries
-    """
-    allowed_values = {"auto", "concise", "detailed"}
-    configured = (get_value("openai_reasoning_summary") or "detailed").strip().lower()
-    if configured not in allowed_values:
-        return "auto"
-    return configured
-
-
-def set_openai_reasoning_summary(value: str) -> None:
-    """Persist the OpenAI reasoning summary mode ensuring it remains valid."""
-    allowed_values = {"auto", "concise", "detailed"}
-    normalized = (value or "").strip().lower()
-    if normalized not in allowed_values:
-        raise ValueError(
-            f"Invalid reasoning summary '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
-        )
-    set_config_value("openai_reasoning_summary", normalized)
-
-
-def get_openai_verbosity() -> str:
-    """Return the configured OpenAI verbosity (low, medium, high).
-
-    Controls how concise vs. verbose the model's responses are:
-    - low: more concise responses
-    - medium: balanced (default)
-    - high: more verbose responses
-    """
-    allowed_values = {"low", "medium", "high"}
-    configured = (get_value("openai_verbosity") or "medium").strip().lower()
-    if configured not in allowed_values:
-        return "medium"
-    return configured
-
-
-def set_openai_verbosity(value: str) -> None:
-    """Persist the OpenAI verbosity ensuring it remains within allowed values."""
-    allowed_values = {"low", "medium", "high"}
-    normalized = (value or "").strip().lower()
-    if normalized not in allowed_values:
-        raise ValueError(
-            f"Invalid verbosity '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
-        )
-    set_config_value("openai_verbosity", normalized)
-
-
 def get_temperature() -> Optional[float]:
     """Return the configured model temperature (0.0 to 2.0).
 
@@ -1001,13 +926,13 @@ def get_model_setting(
         return default
 
 
-def set_model_setting(model_name: str, setting: str, value: Optional[float]) -> None:
+def set_model_setting(model_name: str, setting: str, value: Any | None) -> None:
     """Set a specific setting for a model.
 
     Args:
         model_name: The model name (e.g., 'gpt-5', 'zai-glm-5.1-api')
-        setting: The setting name (e.g., 'temperature', 'seed')
-        value: The value to set, or None to clear
+        setting: The setting name (e.g., 'temperature', 'reasoning_effort')
+        value: The numeric, string, or boolean value to set, or None to clear
     """
     sanitized_name = _sanitize_model_name_for_key(model_name)
     key = f"model_settings_{sanitized_name}_{setting}"

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/model_factory.py

@@ -171,9 +171,6 @@ def make_model_settings(
     """
     from code_puppy.config import (
         get_effective_model_settings,
-        get_openai_reasoning_effort,
-        get_openai_reasoning_summary,
-        get_openai_verbosity,
         model_supports_setting,
     )
 
@@ -293,7 +290,9 @@ def make_model_settings(
         model_settings = OpenAIChatModelSettings(**model_settings_dict)
 
     elif "gpt-5" in model_name:
-        model_settings_dict["openai_reasoning_effort"] = get_openai_reasoning_effort()
+        model_settings_dict["openai_reasoning_effort"] = effective_settings.get(
+            "reasoning_effort", "medium"
+        )
 
         uses_responses_api = (
             model_type == "chatgpt_oauth"
@@ -306,11 +305,13 @@ def make_model_settings(
         )
 
         if uses_responses_api:
-            model_settings_dict["openai_reasoning_summary"] = (
-                get_openai_reasoning_summary()
+            model_settings_dict["openai_reasoning_summary"] = effective_settings.get(
+                "summary", "auto"
             )
             if "codex" not in model_name:
-                model_settings_dict["openai_text_verbosity"] = get_openai_verbosity()
+                model_settings_dict["openai_text_verbosity"] = effective_settings.get(
+                    "verbosity", "medium"
+                )
 
             underlying_name = str(model_config.get("name", "")).lower()
             is_gpt_5_6 = "gpt-5.6" in model_name.lower() or "gpt-5.6" in underlying_name
@@ -336,8 +337,9 @@ def make_model_settings(
             # Chat Completions models don't support configurable reasoning summaries.
             # Keep the old verbosity injection path for non-Responses GPT-5 models.
             if "codex" not in model_name:
-                verbosity = get_openai_verbosity()
-                model_settings_dict["extra_body"] = {"verbosity": verbosity}
+                model_settings_dict["extra_body"] = {
+                    "verbosity": effective_settings.get("verbosity", "medium")
+                }
             model_settings = OpenAIChatModelSettings(**model_settings_dict)
     elif _is_anthropic_model(model_name, model_config):
         # Handle Anthropic extended thinking settings

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/plugins/subagent_panel/state.py

@@ -147,25 +147,44 @@ def snapshot() -> List[Dict[str, Any]]:
     PARENTS are never idle-pruned either: a parent that has invoked children and
     is merely AWAITING them emits no stream events of its own, so its last_seen
     goes stale -- but it is busy, not idle. Pruning it would orphan its whole
-    subtree, making the children re-render as depth-0 roots. So only childless,
-    not-done, genuinely-stale leaves are eligible. End-of-turn state.clear() is
-    the real cleanup for anything that errors/cancels without flushing.
+    subtree, making the children re-render as depth-0 roots.
+
+    ROOT rows (parent=None) are never idle-pruned either. A root is the visible
+    anchor of a live user-initiated ``invoke_agent`` call; silently deleting it
+    while its work is still in flight (e.g. a slow tool call that emits no
+    stream events for many minutes) would strand any completed sibling in state
+    with no flush trigger, and hide from the user that a real invocation is
+    still running. Roots exit via one of three legitimate paths only:
+    completion (``_handle_frozen`` -> ``mark_done`` -> ``_maybe_flush_group``),
+    cancel (``state.clear()`` from ``_on_agent_run_cancel``), or end-of-turn
+    (``state.clear()`` from ``_on_agent_run_end``).
+
+    So only childless, not-done, genuinely-stale ORPHAN LEAVES are eligible --
+    a non-root row whose parent is no longer in the tree AND has been silent
+    longer than IDLE_PRUNE_S. End-of-turn ``state.clear()`` remains the real
+    cleanup for anything that errors/cancels without flushing.
     """
     now = time.time()
     with _LOCK:
         ids = set(_AGENTS)
         # session_ids still referenced as someone's parent == busy (awaiting kids).
         busy_parents = {e.get("parent") for e in _AGENTS.values() if e.get("parent")}
-        # Only prune entries DISCONNECTED from the live tree: not a parent of
-        # anything AND whose own parent is gone (or is 'main', i.e. a root).
-        # Anything still wired into a tree (busy parents + their descendants)
-        # is kept until flush/turn-end, so a quiet-but-running node (e.g. a leaf
-        # mid `sleep`) never vanishes and never orphans its siblings.
+        # Prune entries that are ALL of:
+        #   - not done
+        #   - not a parent of anything (else pruning orphans their subtree)
+        #   - NOT a root (parent is not None) -- roots have explicit lifecycle
+        #     handling; silent idle-eviction of a live root is never correct
+        #     (see docstring). Without this guard, a childless root awaiting a
+        #     slow tool would be misclassified as a disconnected orphan because
+        #     ``None not in ids`` trivially holds.
+        #   - whose own parent is gone from the tree (a true orphan)
+        #   - has been silent longer than IDLE_PRUNE_S
         stale = [
             s
             for s, e in _AGENTS.items()
             if not e.get("done")
             and s not in busy_parents
+            and e.get("parent") is not None
             and e.get("parent") not in ids
             and now - e["last_seen"] > IDLE_PRUNE_S
         ]

{code_puppy-0.0.655 → code_puppy-0.0.657}/code_puppy/tools/browser/browser_manager.py

@@ -6,6 +6,7 @@ Supports multiple simultaneous instances with unique profile directories.
 import asyncio
 import atexit
 import contextvars
+import math
 import os
 from pathlib import Path
 from typing import Callable, Dict, Optional
@@ -47,6 +48,42 @@ def _load_plugin_browser_types() -> None:
 # Store active manager instances by session ID
 _active_managers: dict[str, "BrowserManager"] = {}
 
+
+# --------------------------------------------------------------------------- #
+# Cleanup timeouts
+#
+# Playwright teardown awaits (``context.close``, ``browser.close``,
+# ``playwright.stop``, ``storage_state``) have no internal timeout and can wedge
+# indefinitely when: a page holds an unhandled ``beforeunload`` dialog, a service
+# worker never releases its WebLock, the browser subprocess crashed but did not
+# exit, or the CDP WebSocket went stale (e.g. laptop slept mid-run). Each step
+# below is wrapped in ``asyncio.wait_for`` with a per-step budget so
+# ``_cleanup()`` always returns in bounded time regardless of Playwright state.
+#
+# Overrides are env-var driven so users can bump the budgets on slow machines
+# without a code change. Values are seconds (float, must be finite and > 0 --
+# ``inf``/``nan`` are rejected and fall back to the default).
+# --------------------------------------------------------------------------- #
+def _env_float(name: str, default: float) -> float:
+    """Parse a finite positive float from ``os.environ``; fall back on any parse error."""
+    raw = os.environ.get(name)
+    if not raw:
+        return default
+    try:
+        value = float(raw)
+    except ValueError:
+        return default
+    if not math.isfinite(value) or value <= 0:
+        return default
+    return value
+
+
+_STATE_TIMEOUT_S = _env_float("BROWSER_CLEANUP_STATE_TIMEOUT_S", 10.0)
+_CONTEXT_TIMEOUT_S = _env_float("BROWSER_CLEANUP_CONTEXT_TIMEOUT_S", 10.0)
+_BROWSER_TIMEOUT_S = _env_float("BROWSER_CLEANUP_BROWSER_TIMEOUT_S", 5.0)
+_PW_TIMEOUT_S = _env_float("BROWSER_CLEANUP_PW_TIMEOUT_S", 5.0)
+
+
 # Context variable for browser session - properly inherits through async tasks
 # This allows parallel agent invocations to each have their own browser instance
 _browser_session_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
@@ -184,6 +221,10 @@ class BrowserManager:
         emit_info(f"Using persistent profile: {self.profile_dir}")
 
         pw = await async_playwright().start()
+        # Track the driver instance so ``_cleanup`` can ``.stop()`` it (and,
+        # if it hangs, SIGKILL the driver subprocess). Without this reference
+        # the node driver leaks until Python GC eventually reaps it.
+        self._playwright = pw
         # Use persistent context directory for Chromium to preserve browser state
         context = await pw.chromium.launch_persistent_context(
             user_data_dir=str(self.profile_dir), headless=self.headless
@@ -230,43 +271,148 @@ class BrowserManager:
     async def _cleanup(self, silent: bool = False) -> None:
         """Clean up browser resources and save persistent state.
 
+        Every underlying await is bounded by ``asyncio.wait_for`` -- Playwright
+        teardown can otherwise wedge indefinitely on unresponsive service
+        workers, unhandled ``beforeunload`` prompts, or stale CDP WebSockets.
+        If ``playwright.stop()`` times out we escalate to SIGKILL on the node
+        driver subprocess, which transitively reaps the browser process (its
+        child) so we never leak processes even when CDP is completely wedged.
+
         Args:
-            silent: If True, suppress all errors (used during shutdown).
+            silent: If True, suppress ALL user-facing warnings/info emits (used
+                during shutdown/atexit). Timeouts and errors still occur, they
+                just don't spam the console.
         """
+        _emit_warning = (lambda _msg: None) if silent else emit_warning
+        _emit_success = (lambda _msg: None) if silent else emit_success
+
         try:
-            # Save browser state before closing (cookies, localStorage, etc.)
+            # Save browser state before closing (cookies, localStorage, etc.).
             if self._context:
+                storage_state_path = self.profile_dir / "storage_state.json"
                 try:
-                    storage_state_path = self.profile_dir / "storage_state.json"
-                    await self._context.storage_state(path=str(storage_state_path))
-                    if not silent:
-                        emit_success(f"Browser state saved to {storage_state_path}")
+                    await asyncio.wait_for(
+                        self._context.storage_state(path=str(storage_state_path)),
+                        timeout=_STATE_TIMEOUT_S,
+                    )
+                    _emit_success(f"Browser state saved to {storage_state_path}")
+                except asyncio.TimeoutError:
+                    _emit_warning(
+                        f"Timed out ({_STATE_TIMEOUT_S:g}s) saving browser state; "
+                        "proceeding with teardown"
+                    )
                 except Exception as e:
-                    if not silent:
-                        emit_warning(f"Could not save storage state: {e}")
+                    _emit_warning(f"Could not save storage state: {e}")
+
+            # Auto-dismiss any beforeunload dialog Playwright might raise during
+            # context.close(). Without this, a page that registered a
+            # ``beforeunload`` handler causes context.close() to await a
+            # dialog handler that was never installed -> hang.
+            if self._context:
+                self._install_dialog_dismisser(silent=silent)
 
+            # Close the browser context.
+            if self._context:
                 try:
-                    await self._context.close()
+                    await asyncio.wait_for(
+                        self._context.close(), timeout=_CONTEXT_TIMEOUT_S
+                    )
+                except asyncio.TimeoutError:
+                    _emit_warning(
+                        f"Timed out ({_CONTEXT_TIMEOUT_S:g}s) closing browser context; "
+                        "deferring to later driver cleanup"
+                    )
                 except Exception:
-                    pass  # Ignore errors during context close
+                    pass  # Ignore other errors during context close
                 self._context = None
 
+            # Close the browser. If it wedges (unresponsive CDP), we can only
+            # emit a warning here -- current Python Playwright does NOT expose
+            # a subprocess handle on ``Browser``. The browser process is a
+            # child of the node driver, so ``_force_kill_playwright_process``
+            # below transitively reaps it via SIGKILL to the parent driver.
             if self._browser:
                 try:
-                    await self._browser.close()
+                    await asyncio.wait_for(
+                        self._browser.close(), timeout=_BROWSER_TIMEOUT_S
+                    )
+                except asyncio.TimeoutError:
+                    _emit_warning(
+                        f"Timed out ({_BROWSER_TIMEOUT_S:g}s) closing browser; "
+                        "deferring to driver-process kill below"
+                    )
                 except Exception:
-                    pass  # Ignore errors during browser close
+                    pass  # Ignore other errors during browser close
                 self._browser = None
 
+            # Stop the playwright driver subprocess.
+            if getattr(self, "_playwright", None):
+                try:
+                    await asyncio.wait_for(
+                        self._playwright.stop(), timeout=_PW_TIMEOUT_S
+                    )
+                except asyncio.TimeoutError:
+                    _emit_warning(
+                        f"Timed out ({_PW_TIMEOUT_S:g}s) stopping playwright driver; "
+                        "killing subprocess"
+                    )
+                    self._force_kill_playwright_process(silent=silent)
+                except Exception:
+                    pass
+                self._playwright = None
+
             self._initialized = False
 
             # Remove from active managers
             if self.session_id in _active_managers:
                 del _active_managers[self.session_id]
 
+        except Exception as e:
+            _emit_warning(f"Warning during cleanup: {e}")
+
+    def _install_dialog_dismisser(self, silent: bool = False) -> None:
+        """Attach an auto-dismiss dialog handler to every open page.
+
+        Playwright blocks on unhandled ``beforeunload`` dialogs during
+        ``context.close()``. Best-effort: iterate pages, ignore per-page
+        failures (a closed page raises when you touch it).
+        """
+        if not self._context:
+            return
+        try:
+            pages = self._context.pages
+        except Exception:
+            return
+        for page in pages:
+            try:
+                page.on("dialog", lambda d: asyncio.ensure_future(d.dismiss()))
+            except Exception as e:
+                if not silent:
+                    emit_warning(f"Could not install dialog handler: {e}")
+
+    def _force_kill_playwright_process(self, silent: bool = False) -> None:
+        """Force-kill the Playwright node driver subprocess.
+
+        The browser process is a child of this driver, so a SIGKILL here
+        transitively reaps the whole browser tree -- our only reliable escape
+        hatch when CDP has gone unresponsive.
+
+        Attribute path: ``_playwright._impl_obj._connection._transport._proc``.
+        This is a private API but has been stable across Playwright releases
+        (verified against 1.61.0). If any hop in the chain moves, we no-op
+        rather than raise (best-effort).
+        """
+        impl = getattr(self._playwright, "_impl_obj", None)
+        connection = getattr(impl, "_connection", None)
+        transport = getattr(connection, "_transport", None)
+        proc = getattr(transport, "_proc", None)
+        if proc is None:
+            return
+        try:
+            proc.kill()
         except Exception as e:
             if not silent:
-                emit_warning(f"Warning during cleanup: {e}")
+                emit_warning(f"Could not kill playwright driver process: {e}")
 
     async def close(self) -> None:
         """Close the browser and clean up resources."""

{code_puppy-0.0.655 → code_puppy-0.0.657}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.655"
+version = "0.0.657"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"