teddy-cli 0.1.17.dev1397__tar.gz → 0.1.17.dev1399__tar.gz

{teddy_cli-0.1.17.dev1397 → teddy_cli-0.1.17.dev1399}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1397
+Version: 0.1.17.dev1399
 Summary: The local-first, test-driven agentic engineering harness. Because you should own the means of development.
 Author: Raphael Atteritano
 License: AGPL-3.0-only

{teddy_cli-0.1.17.dev1397 → teddy_cli-0.1.17.dev1399}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1397"
+version = "0.1.17.dev1399"
 description = "The local-first, test-driven agentic engineering harness. Because you should own the means of development."
 readme = "README.md"
 keywords = [

{teddy_cli-0.1.17.dev1397 → teddy_cli-0.1.17.dev1399}/src/teddy_executor/core/services/planning_service.py

@@ -2,6 +2,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Sequence
 from teddy_executor.core.domain.models import ProjectContext
 from teddy_executor.core.ports.inbound.planning_use_case import IPlanningUseCase
+from teddy_executor.core.utils.interruptible_call import run_interruptible
 
 
 class PlanningService(IPlanningUseCase):
@@ -93,6 +94,36 @@ class PlanningService(IPlanningUseCase):
             (turn_path / "input.md").as_posix(), full_context
         )
 
+        response, token_count, plan_content, turn_cost = run_interruptible(
+            lambda: self._run_planning_phase(messages, model, meta)
+        )
+
+        cost_val = self._prompt_manager.log_telemetry(token_count, turn_cost)
+        plan_path = (turn_path / "plan.md").as_posix()
+        self._file_system_manager.write_file(plan_path, plan_content)
+        # Pre-populate meta["model"] before update_meta to ensure the user-configured
+        # model (with routing prefix like openrouter/) is preserved.
+        # This prevents the bug where meta["model"] was missing on first turn (no --model flag)
+        # and update_meta overwrote it with the bare actual model.
+        meta.setdefault("model", model)
+        self._prompt_manager.update_meta(
+            meta, response, token_count, turn_cost, meta_file_path
+        )
+
+        return plan_path, cost_val, context
+
+    def _run_planning_phase(
+        self,
+        messages: list[Dict[str, str]],
+        model: str,
+        meta: Dict[str, Any],
+    ) -> tuple[Any, int, str, float]:
+        """Perform every blocking planning call on the interruptible worker.
+
+        Hydration, the token count, telemetry, the budget check, and the
+        completion all touch the network. The main thread waits on this worker's
+        future, so a quit interrupts the wait instead of the raw socket read.
+        """
         # Pre-emptive Hydration: Trigger hydration via get_context_window BEFORE counting tokens.
         # This ensures the model is known to the registry so token counting and telemetry work.
         if self._user_interactor:
@@ -112,20 +143,7 @@ class PlanningService(IPlanningUseCase):
             messages,
             model=model,
         )
-
-        cost_val = self._prompt_manager.log_telemetry(token_count, turn_cost)
-        plan_path = (turn_path / "plan.md").as_posix()
-        self._file_system_manager.write_file(plan_path, plan_content)
-        # Pre-populate meta["model"] before update_meta to ensure the user-configured
-        # model (with routing prefix like openrouter/) is preserved.
-        # This prevents the bug where meta["model"] was missing on first turn (no --model flag)
-        # and update_meta overwrote it with the bare actual model.
-        meta.setdefault("model", model)
-        self._prompt_manager.update_meta(
-            meta, response, token_count, turn_cost, meta_file_path
-        )
-
-        return plan_path, cost_val, context
+        return response, token_count, plan_content, turn_cost
 
     def _perform_generation_with_retry(
         self,

{teddy_cli-0.1.17.dev1397 → teddy_cli-0.1.17.dev1399}/src/teddy_executor/core/utils/interrupt_guard.py

@@ -18,6 +18,7 @@ import-free of DI frameworks (hexagonal core boundary).
 """
 
 import signal
+import sys
 import threading
 from collections.abc import Callable
 from contextlib import contextmanager
@@ -128,8 +129,16 @@ def raise_interrupt() -> None:
 
     ``os.kill(os.getpid(), signal.SIGINT)`` terminates the process on Windows
     through ``TerminateProcess`` instead of invoking the Python SIGINT handler,
-    which suppresses the interrupt notice. ``signal.raise_signal`` uses the
-    process-level CRT raise path and reaches the handler from the main thread
-    and from a reader thread on every platform.
+    which suppresses the interrupt notice. On POSIX the signal targets the main
+    thread through ``signal.pthread_kill``, so delivery wakes a blocked main
+    thread at its next checkpoint instead of waiting for the calling thread to
+    return. Windows and any platform without ``pthread_kill`` use
+    ``signal.raise_signal``, which keeps the CRT raise path so the installed
+    handler still runs there.
     """
+    if sys.platform != "win32" and hasattr(signal, "pthread_kill"):
+        main_ident = threading.main_thread().ident
+        if main_ident is not None:
+            signal.pthread_kill(main_ident, signal.SIGINT)
+            return
     signal.raise_signal(signal.SIGINT)

teddy_cli-0.1.17.dev1399/src/teddy_executor/core/utils/interruptible_call.py

@@ -0,0 +1,35 @@
+"""Run a blocking callable on a daemon worker so a quit can wake the waiter.
+
+The planning completion blocks the main thread inside a raw socket read. A
+POSIX signal reaches that call only through a main-thread target, and the
+Windows CRT raise cannot wake it at all. Running the call on a daemon worker
+keeps the main thread in a condition wait, which every SIGINT delivery
+primitive wakes immediately.
+
+The worker is a daemon so a pending completion cannot block process exit after
+a quit. Every worker failure is forwarded to the waiter unchanged.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+from concurrent.futures import Future
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+def run_interruptible(func: Callable[[], T]) -> T:
+    """Run ``func`` on a daemon worker and return its result or raise its error."""
+    future: Future[T] = Future()
+
+    def _work() -> None:
+        try:
+            future.set_result(func())
+        except BaseException as exc:  # forward every failure to the waiter
+            future.set_exception(exc)
+
+    worker = threading.Thread(target=_work, name="interruptible-call", daemon=True)
+    worker.start()
+    return future.result()