code-puppy 0.0.784__tar.gz → 0.0.786__tar.gz

{code_puppy-0.0.784 → code_puppy-0.0.786}/.gitignore

@@ -51,3 +51,7 @@ code_puppy/bundled_skills/
 
 # Local git worktrees
 .worktrees/
+
+# Cancel-wedge repro harness output (scripts/repro_cancel_wedge.py)
+wedge_artifacts/
+wedge_soak.log

{code_puppy-0.0.784 → code_puppy-0.0.786}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.784
+Version: 0.0.786
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -16,11 +16,12 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.15,>=3.11
 Requires-Dist: agent-client-protocol<0.12,>=0.11.0
-Requires-Dist: anthropic<1,>=0.108.0
+Requires-Dist: anthropic<2,>=1.0.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: azure-identity>=1.15.0
 Requires-Dist: boto3>=1.43.9
-Requires-Dist: code-puppy-core-plugins>=0.0.26
+Requires-Dist: code-puppy-core-plugins>=0.0.27
+Requires-Dist: httpx2>=2.7
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
 Requires-Dist: keyring>=24.0.0
@@ -31,7 +32,7 @@ Requires-Dist: packaging>=24.0
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: playwright>=1.40.0; sys_platform != 'android'
 Requires-Dist: pydantic-ai-harness==0.23.0
-Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai]==2.31.0
+Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai]==2.35.0
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pyfiglet>=0.8.post1
 Requires-Dist: python-dotenv>=1.0.0

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/agents/_run_signals.py

@@ -9,12 +9,51 @@ daemon thread.
 from __future__ import annotations
 
 import asyncio
+import time
 from typing import Any, Callable, Optional
 
 from code_puppy.command_line.attachments import resolve_steer_content
 from code_puppy.messaging import emit_info, emit_warning
 from code_puppy.tools.agent_tools import _active_subagent_tasks
 
+# =============================================================================
+# Run-detach seam — the escape hatch for zombie cancellations
+# =============================================================================
+#
+# A cancelled run with sub-agents/MCP servers can get stuck unwinding (anyio
+# cancel-scope teardown, plugin cancel hooks, ...). The REPL awaits the run
+# task, the persistent prompt stays visually alive, and every quit gesture is
+# gated on ``is_run_active()`` — so a stuck unwind freezes the whole app.
+# The seam below lets repeated cancel gestures escalate to "abandon the run":
+# ``run_prompt_with_attachments`` installs an event and races it against the
+# agent task, so setting it unblocks the REPL even if the task never finishes.
+
+#: A second cancel gesture this many seconds after the first one on a run
+#: that STILL hasn't finished unwinding escalates to a detach.
+CANCEL_ESCALATE_AFTER_S = 3.0
+
+_detach_event: Optional[asyncio.Event] = None
+
+
+def install_detach_event(event: asyncio.Event) -> None:
+    """Register the top-level run's detach event (cli_runner owns it)."""
+    global _detach_event
+    _detach_event = event
+
+
+def clear_detach_event() -> None:
+    """Drop the seam once the run's await has resolved (normal or detached)."""
+    global _detach_event
+    _detach_event = None
+
+
+def request_run_detach() -> bool:
+    """Fire the detach event. Loop-thread only. Returns True if one was armed."""
+    if _detach_event is None:
+        return False
+    _detach_event.set()
+    return True
+
 
 def sigint_should_cancel() -> bool:
     """Buffer-first Ctrl+C gate for the run's SIGINT handler.
@@ -61,6 +100,12 @@ def make_schedule_cancel(
     terminal) while letting the cancel actually proceed.
     """
 
+    # Closure state: monotonic time of the first cancel request, so a later
+    # gesture on a still-stuck unwind can escalate to a detach (list, not a
+    # bare float, to stay writable from the nested function without nonlocal
+    # gymnastics on multiple call sites).
+    first_cancel_at: list = []
+
     def schedule_agent_cancel(force: bool = False) -> None:
         from code_puppy.tools.command_runner import (
             _RUNNING_PROCESSES,
@@ -70,6 +115,21 @@ def make_schedule_cancel(
 
         if agent_task.done():
             return
+        # Escalation: the user already cancelled, waited, and is cancelling
+        # again — the unwind is stuck. Abandon the run so the REPL (and
+        # every quit gesture it gates) comes back. The zombie task is left
+        # to finish — or not — in the background.
+        now = time.monotonic()
+        if first_cancel_at and now - first_cancel_at[0] >= CANCEL_ESCALATE_AFTER_S:
+            _tear_down_live_panels()
+            emit_warning(
+                "\nRun is stuck cancelling — abandoning it and returning "
+                "to the prompt..."
+            )
+            loop.call_soon_threadsafe(request_run_detach)
+            return
+        if not first_cancel_at:
+            first_cancel_at.append(now)
         if _RUNNING_PROCESSES and not force:
             # Ordering matters (see _shell_sigint_handler): banner BEFORE the
             # kill — the sweep blocks this thread ~2s per process, so the
@@ -236,11 +296,15 @@ def drain_pause_state_on_cancel() -> None:
         )
 
 
-all__ = [
+__all__ = [
+    "CANCEL_ESCALATE_AFTER_S",
+    "clear_detach_event",
     "drain_pause_state_on_cancel",
     "inject_interrupted_subagent_notes",
+    "install_detach_event",
     "make_schedule_cancel",
     "prepare_queued_steer_injection",
+    "request_run_detach",
     "reset_pause_state_at_run_start",
     "sigint_should_cancel",
 ]

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/claude_cache_client.py

@@ -5,6 +5,11 @@ Prompt caching is configured through pydantic-ai's native
 markers; it only owns transport concerns that cannot be expressed there:
 OAuth refresh/retry, Claude Code tool-name prefixing, request headers, URL
 parameters, and the Opus summarized-thinking compatibility transform.
+
+Built on ``httpx2`` (not ``httpx``): every consumer of this client hands it
+to ``anthropic.AsyncAnthropic``, and the Anthropic SDK moved to httpx2 in
+its 1.0 release (pydantic-ai >= 2.35 followed). The rest of Code Puppy
+(OpenAI providers, http_utils) still rides classic httpx.
 """
 
 from __future__ import annotations
@@ -17,7 +22,7 @@ import time
 from typing import Any, Callable, MutableMapping
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
-import httpx
+import httpx2
 
 logger = logging.getLogger(__name__)
 
@@ -61,7 +66,7 @@ def _enforce_thinking_display_summary(payload):
     return True
 
 
-class ClaudeCacheAsyncClient(httpx.AsyncClient):
+class ClaudeCacheAsyncClient(httpx2.AsyncClient):
     """Async HTTP client with Claude Code OAuth transformations.
 
     Handles:
@@ -128,7 +133,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             logger.debug("Failed to decode JWT age: %s", exc)
             return None
 
-    def _extract_bearer_token(self, request: httpx.Request) -> str | None:
+    def _extract_bearer_token(self, request: httpx2.Request) -> str | None:
         """Extract the bearer token from request headers."""
         auth_header = request.headers.get("Authorization") or request.headers.get(
             "authorization"
@@ -137,7 +142,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             return auth_header[7:]  # Strip "Bearer " prefix
         return None
 
-    def _jwt_refresh_decision(self, request: httpx.Request) -> bool | None:
+    def _jwt_refresh_decision(self, request: httpx2.Request) -> bool | None:
         """Return a JWT-based refresh decision, or ``None`` for stored fallback."""
         token = self._extract_bearer_token(request)
         if not token:
@@ -163,14 +168,14 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             )
         return should_refresh
 
-    def _should_refresh_token(self, request: httpx.Request) -> bool:
+    def _should_refresh_token(self, request: httpx2.Request) -> bool:
         """Synchronously check JWT age, then the stored-token callback."""
         decision = self._jwt_refresh_decision(request)
         if decision is not None:
             return decision
         return self._log_stored_token_refresh(self._check_stored_token_expiry())
 
-    async def _should_refresh_token_async(self, request: httpx.Request) -> bool:
+    async def _should_refresh_token_async(self, request: httpx2.Request) -> bool:
         """Check token expiry while awaiting async providers in ``send()``."""
         decision = self._jwt_refresh_decision(request)
         if decision is not None:
@@ -320,7 +325,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                 del headers[key]
 
     @staticmethod
-    def _add_beta_query_param(url: httpx.URL) -> httpx.URL:
+    def _add_beta_query_param(url: httpx2.URL) -> httpx2.URL:
         """Add ?beta=true query parameter to the URL if not already present."""
         parsed = urlparse(str(url))
         query_params = parse_qs(parsed.query)
@@ -328,12 +333,12 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             query_params["beta"] = ["true"]
             new_query = urlencode(query_params, doseq=True)
             new_parsed = parsed._replace(query=new_query)
-            return httpx.URL(urlunparse(new_parsed))
+            return httpx2.URL(urlunparse(new_parsed))
         return url
 
     async def send(
-        self, request: httpx.Request, *args: Any, **kwargs: Any
-    ) -> httpx.Response:  # type: ignore[override]
+        self, request: httpx2.Request, *args: Any, **kwargs: Any
+    ) -> httpx2.Response:  # type: ignore[override]
         is_messages_endpoint = request.url.path.endswith("/v1/messages")
         if not request.extensions.get("claude_oauth_proactive_refresh_attempted"):
             try:
@@ -450,10 +455,10 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         return response
 
     async def _send_with_retries(
-        self, request: httpx.Request, *args: Any, **kwargs: Any
-    ) -> httpx.Response:
+        self, request: httpx2.Request, *args: Any, **kwargs: Any
+    ) -> httpx2.Response:
         """Retry rate limits, server failures, and transient connections."""
-        last_response: httpx.Response | None = None
+        last_response: httpx2.Response | None = None
         last_exception: Exception | None = None
         for attempt in range(MAX_RETRIES + 1):
             status_code: int | None = None
@@ -467,7 +472,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                     return response
                 status_code = response.status_code
                 await response.aclose()
-            except (httpx.ConnectError, httpx.ReadTimeout, httpx.PoolTimeout) as exc:
+            except (httpx2.ConnectError, httpx2.ReadTimeout, httpx2.PoolTimeout) as exc:
                 last_exception = exc
                 if attempt >= MAX_RETRIES:
                     raise
@@ -515,7 +520,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         raise RuntimeError("Retry loop completed without response or exception")
 
     @staticmethod
-    def _extract_body_bytes(request: httpx.Request) -> bytes | None:
+    def _extract_body_bytes(request: httpx2.Request) -> bytes | None:
         try:
             content = request.content
             if content:
@@ -547,7 +552,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             headers["Authorization"] = bearer_value
 
     @staticmethod
-    async def _is_cloudflare_html_error(response: httpx.Response) -> bool:
+    async def _is_cloudflare_html_error(response: httpx2.Response) -> bool:
         """Return whether a 400 HTML response is a Cloudflare auth failure."""
         if "text/html" not in response.headers.get("content-type", "").lower():
             return False

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/cli_runner.py

@@ -741,6 +741,35 @@ def _interactive_sigint_guard(_sig, _frame):
     return
 
 
+#: How long the quit paths (double Ctrl+C / Ctrl+D / exit) wait for a
+#: lingering agent task to finish cancelling before abandoning it. A stuck
+#: unwind must never freeze the exit — process teardown reaps the zombie.
+_QUIT_CANCEL_TIMEOUT_S = 5.0
+
+
+async def _shutdown_agent_task(agent_task) -> None:
+    """Cancel a lingering agent task on quit, bounded by a timeout.
+
+    ``asyncio.wait`` (not ``wait_for``) on purpose: ``wait_for``'s timeout
+    path awaits the inner cancellation, which is exactly the await that can
+    wedge. ``wait`` just stops waiting.
+    """
+    from code_puppy.messaging import emit_warning
+
+    if agent_task is None or agent_task.done():
+        return
+    emit_info(t("cli.agent.cancelling"))
+    agent_task.cancel()
+    done, _ = await asyncio.wait({agent_task}, timeout=_QUIT_CANCEL_TIMEOUT_S)
+    if agent_task not in done:
+        emit_warning(t("cli.agent.quit_cancel_timeout", seconds=_QUIT_CANCEL_TIMEOUT_S))
+        return
+    try:
+        agent_task.result()
+    except BaseException:
+        pass  # Expected when cancelling — nothing to do with it on the way out.
+
+
 async def interactive_mode(message_renderer, initial_command: str = None) -> None:
     """Run the agent in interactive mode."""
     from code_puppy.command_line.command_handler import handle_command
@@ -837,6 +866,16 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     except (ValueError, OSError):
         pass
 
+    # Field diagnostics: `kill -USR2 <pid>` dumps thread + asyncio-task
+    # stacks to ~/.code_puppy/stackdumps/ — the conviction kit for wedged
+    # cancellations (a frozen REPL can't be introspected any other way).
+    try:
+        from code_puppy.diagnostics import install_stack_dump_handler
+
+        install_stack_dump_handler(asyncio.get_running_loop())
+    except Exception:
+        pass  # diagnostics must never block the REPL
+
     # ------------------------------------------------------------------
     # Persistent-prompt mode: the bottom-bar editor is THE prompt (idle AND
     # running) — pinned input row, output scrolls above. Classic path behind
@@ -921,13 +960,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             now = time.monotonic()
             if was_plain_ctrl_c and now - last_idle_ctrl_c <= DOUBLE_CTRL_C_WINDOW_S:
                 emit_success("\n" + t("cli.goodbye_ctrld"))
-                if current_agent_task and not current_agent_task.done():
-                    emit_info(t("cli.agent.cancelling"))
-                    current_agent_task.cancel()
-                    try:
-                        await current_agent_task
-                    except asyncio.CancelledError:
-                        pass  # Expected when cancelling
+                await _shutdown_agent_task(current_agent_task)
                 break
             last_idle_ctrl_c = now if was_plain_ctrl_c else 0.0
 
@@ -940,14 +973,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
             emit_success("\n" + t("cli.goodbye_ctrld"))
 
-            # Cancel any running agent task for clean shutdown
-            if current_agent_task and not current_agent_task.done():
-                emit_info(t("cli.agent.cancelling"))
-                current_agent_task.cancel()
-                try:
-                    await current_agent_task
-                except asyncio.CancelledError:
-                    pass  # Expected when cancelling
+            # Cancel any running agent task for clean shutdown (bounded — a
+            # stuck unwind must not freeze Ctrl+D).
+            await _shutdown_agent_task(current_agent_task)
 
             break
 
@@ -975,14 +1003,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
             emit_success(t("cli.goodbye"))
 
-            # Cancel any running agent task for clean shutdown
-            if current_agent_task and not current_agent_task.done():
-                emit_info(t("cli.agent.cancelling"))
-                current_agent_task.cancel()
-                try:
-                    await current_agent_task
-                except asyncio.CancelledError:
-                    pass  # Expected when cancelling
+            # Cancel any running agent task for clean shutdown (bounded — a
+            # stuck unwind must not freeze `exit`).
+            await _shutdown_agent_task(current_agent_task)
 
             # The renderer is stopped in the finally block of main().
             break
@@ -1365,13 +1388,44 @@ async def run_prompt_with_attachments(
         )
     )
 
+    # Escape hatch: a cancelled run can wedge mid-unwind (sub-agent/MCP
+    # cancel-scope teardown). Racing the task against a detach event keeps
+    # the REPL recoverable — repeated cancel gestures escalate to a detach
+    # (see _run_signals.make_schedule_cancel) and we abandon the zombie.
+    from code_puppy.agents._run_signals import (
+        clear_detach_event,
+        install_detach_event,
+    )
+
+    detach_event = asyncio.Event()
+    install_detach_event(detach_event)
+
     async def _await_agent():
+        detach_wait = asyncio.create_task(detach_event.wait())
         try:
-            result = await agent_task
-            return result, agent_task
-        except asyncio.CancelledError:
-            emit_info(t("cli.agent.task_cancelled"))
-            return None, agent_task
+            try:
+                done, _ = await asyncio.wait(
+                    {agent_task, detach_wait}, return_when=asyncio.FIRST_COMPLETED
+                )
+            except asyncio.CancelledError:
+                # The waiter itself was cancelled (shutdown teardown) — same
+                # contract as the old bare ``await agent_task`` path.
+                emit_info(t("cli.agent.task_cancelled"))
+                return None, agent_task
+            if agent_task not in done:
+                # Escalated cancel: abandon the stuck unwind, free the REPL.
+                emit_warning(t("cli.agent.detached"))
+                return None, agent_task
+            if agent_task.cancelled():
+                emit_info(t("cli.agent.task_cancelled"))
+                return None, agent_task
+            exc = agent_task.exception()
+            if exc is not None:
+                raise exc
+            return agent_task.result(), agent_task
+        finally:
+            detach_wait.cancel()
+            clear_detach_event()
 
     if use_run_ui:
         # Interactive run: bottom bar stays up while the agent works. run_ui() is

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/command_line/mcp/trust_command.py

@@ -150,11 +150,14 @@ class TrustCommand(MCPCommandBase):
 
     def _revoke(self, group_id: str) -> None:
         if revoke_project_mcp():
+            try:
+                self.manager.sync_from_config()
+            except Exception as exc:  # pragma: no cover - defensive
+                logger.warning("Post-revoke registry sync failed: %s", exc)
             emit_info(
                 Text.from_markup(
                     "[green]\u2713 Revoked[/green] trust for this project's MCP "
-                    "config. Its servers will no longer load. Restart or re-sync "
-                    "to drop already-registered ones."
+                    "config. Its servers will no longer load."
                 ),
                 message_group=group_id,
             )

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/config.py

@@ -595,7 +595,7 @@ def _parse_mcp_servers_mapping(raw_text: str) -> dict:
     return servers
 
 
-def load_mcp_server_configs():
+def load_mcp_server_configs(*, raise_on_error: bool = False):
     """Load MCP server configs, merging user-level and trusted project-level.
 
     Sources, in ascending order of precedence:
@@ -610,6 +610,11 @@ def load_mcp_server_configs():
     Project entries win on name collision, matching how project agents, skills,
     and plugins override their user-level counterparts. Returns an empty dict
     when nothing is configured.
+
+    When *raise_on_error* is true, a parse/IO failure of an existing user-level
+    file (or a failure of the project loader) is re-raised after the error is
+    emitted, so callers that unregister missing names can skip that drop
+    instead of treating ``{}`` as "configure nothing".
     """
     from code_puppy.messaging.message_queue import emit_error
 
@@ -622,6 +627,8 @@ def load_mcp_server_configs():
                 configs.update(_parse_mcp_servers_mapping(f.read()))
     except Exception as e:
         emit_error(f"Failed to load MCP servers - {str(e)}")
+        if raise_on_error:
+            raise
 
     # 2. Project-level config (opt-in, trust-gated). A broken or untrusted
     #    project file must never break user-level loading.
@@ -633,6 +640,8 @@ def load_mcp_server_configs():
             configs.update(project_configs)
     except Exception as e:
         emit_error(f"Failed to load project MCP servers - {str(e)}")
+        if raise_on_error:
+            raise
 
     return configs
 

code_puppy-0.0.786/code_puppy/diagnostics.py

@@ -0,0 +1,124 @@
+"""On-demand stack dumps for wedged runs (``kill -USR2 <pid>``).
+
+Field diagnosis for the "cancelled run wedges mid-unwind" class of bug
+(Discord: "death spiral of 2 asyncs waiting for the other to finish").
+``faulthandler`` alone is useless there — the event-loop thread is parked
+in ``select()`` and every interesting frame lives in a *suspended asyncio
+task*, which faulthandler cannot see. This module dumps BOTH:
+
+- OS-thread stacks via ``faulthandler.dump_traceback`` (key listener,
+  renderer, shell readers, ...); and
+- every asyncio task's coroutine stack via ``Task.print_stack`` (the REPL
+  coroutine stuck on ``await agent_task``, the agent task stuck in its
+  cancel-scope teardown — the actual smoking gun).
+
+Dumps are written to ``~/.code_puppy/stackdumps/`` (never the terminal:
+the bottom-bar TUI owns it, and a wedged app may not repaint anyway) with
+a one-line breadcrumb on stderr. POSIX only — Windows has no SIGUSR2;
+``install_stack_dump_handler`` degrades to a no-op there.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import faulthandler
+import logging
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+from typing import Optional, TextIO
+
+logger = logging.getLogger(__name__)
+
+DUMP_DIR = Path.home() / ".code_puppy" / "stackdumps"
+
+#: Frames per task stack. Wedges live near the leaf; unbounded dumps of
+#: deep pydantic-ai graphs just bury the signal.
+TASK_STACK_LIMIT = 40
+
+_captured_loop: Optional[asyncio.AbstractEventLoop] = None
+
+
+def dump_stacks(file: TextIO, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
+    """Write thread stacks + asyncio task stacks to ``file``.
+
+    Never raises: each section is best-effort so a half-broken process
+    can still confess as much as it knows.
+    """
+    print(f"=== code-puppy stack dump (pid {os.getpid()}) ===", file=file)
+    print("--- OS threads (faulthandler) ---", file=file)
+    try:
+        file.flush()
+        faulthandler.dump_traceback(file=file, all_threads=True)
+    except Exception:
+        logger.debug("faulthandler dump failed", exc_info=True)
+        print("<faulthandler dump failed>", file=file)
+
+    loop = loop or _captured_loop
+    if loop is None:
+        print("--- asyncio tasks: no loop captured ---", file=file)
+        return
+    try:
+        tasks = asyncio.all_tasks(loop)
+    except Exception:
+        logger.debug("asyncio.all_tasks failed", exc_info=True)
+        print("--- asyncio tasks: enumeration failed ---", file=file)
+        return
+    print(f"--- asyncio tasks: {len(tasks)} ---", file=file)
+    for task in tasks:
+        print(f"\nTask: {task!r}", file=file)
+        try:
+            task.print_stack(limit=TASK_STACK_LIMIT, file=file)
+        except Exception:
+            logger.debug("task.print_stack failed", exc_info=True)
+            print("<task stack unavailable>", file=file)
+
+
+def write_stack_dump(
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> Optional[Path]:
+    """Dump to a timestamped file under ``DUMP_DIR``; return its path.
+
+    Returns ``None`` (and stays silent beyond a debug log) if even the
+    file can't be created — diagnostics must never hurt the patient.
+    """
+    try:
+        DUMP_DIR.mkdir(parents=True, exist_ok=True)
+        path = DUMP_DIR / f"stackdump-{os.getpid()}-{int(time.time())}.txt"
+        with open(path, "w", encoding="utf-8") as f:
+            dump_stacks(f, loop=loop)
+        # stderr, not the message bus: a wedged loop may never render a
+        # bus message, and stderr survives a hung TUI.
+        print(f"[code-puppy] stack dump written to {path}", file=sys.stderr)
+        return path
+    except Exception:
+        logger.debug("stack dump failed", exc_info=True)
+        return None
+
+
+def install_stack_dump_handler(
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> bool:
+    """Register the SIGUSR2 stack-dump handler. Returns True if installed.
+
+    Safe to call more than once (last loop reference wins). No-op on
+    platforms without SIGUSR2 (Windows) and off the main thread, where
+    ``signal.signal`` raises.
+    """
+    global _captured_loop
+    if not hasattr(signal, "SIGUSR2"):
+        return False
+    if loop is not None:
+        _captured_loop = loop
+
+    def _handler(signum, frame) -> None:
+        write_stack_dump()
+
+    try:
+        signal.signal(signal.SIGUSR2, _handler)
+    except (ValueError, OSError):
+        logger.debug("SIGUSR2 handler install failed", exc_info=True)
+        return False
+    return True

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/i18n/locales/en-US.json

@@ -44,6 +44,8 @@
   "cli.agent.set_error": "Error setting agent: {error}",
   "cli.agent.cancelling": "Cancelling running agent task...",
   "cli.agent.task_cancelled": "Agent task cancelled",
+  "cli.agent.detached": "Run abandoned — it was stuck cancelling. Back at the prompt (the old run may still unwind in the background).",
+  "cli.agent.quit_cancel_timeout": "Agent task didn't finish cancelling within {seconds}s — exiting anyway.",
   "cli.resume.quick_searching": "🔍 Quick Resume selected - finding latest session for {scope}",
   "cli.resume.none_found": "No previous session found for this scope; starting fresh.",
   "cli.resume.available_sessions": "Available sessions: {sessions}",

{code_puppy-0.0.784 → code_puppy-0.0.786}/code_puppy/mcp_/manager.py

@@ -161,10 +161,7 @@ class MCPManager:
         try:
             from code_puppy.config import load_mcp_server_configs
 
-            configs = load_mcp_server_configs()
-            if not configs:
-                logger.debug("No servers found in mcp_servers.json")
-                return
+            configs = load_mcp_server_configs(raise_on_error=True) or {}
 
             synced_count = 0
             updated_count = 0
@@ -209,9 +206,23 @@ class MCPManager:
                     logger.warning(f"Failed to sync server '{name}' from config: {e}")
                     continue
 
-            if synced_count > 0 or updated_count > 0:
+            configured_names = {
+                name for name, conf in configs.items() if isinstance(conf, dict)
+            }
+            dropped_count = 0
+            for existing in list(self.registry.list_all()):
+                if existing.name not in configured_names:
+                    if self.remove_server(existing.id):
+                        dropped_count += 1
+                        logger.debug(
+                            "Dropped server no longer in mcp_servers.json: %s",
+                            existing.name,
+                        )
+
+            if synced_count > 0 or updated_count > 0 or dropped_count > 0:
                 logger.info(
-                    f"Synced {synced_count} new and updated {updated_count} servers from mcp_servers.json"
+                    f"Synced {synced_count} new, updated {updated_count}, "
+                    f"dropped {dropped_count} servers from mcp_servers.json"
                 )
 
         except Exception as e: