codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/core/hub.py

@@ -1,11 +1,13 @@
+import asyncio
 import dataclasses
 import enum
 import logging
 import re
 import shutil
+import threading
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from ..bootstrap import seed_repo_files
 from ..discovery import DiscoveryRecord, discover_and_init
@@ -16,23 +18,35 @@ from ..manifest import (
     sanitize_repo_id,
     save_manifest,
 )
+from .archive import archive_worktree_snapshot, build_snapshot_id
 from .config import HubConfig, RepoConfig, derive_repo_config, load_hub_config
-from .engine import Engine
 from .git_utils import (
     GitError,
     git_available,
+    git_branch,
     git_default_branch,
+    git_head_sha,
     git_is_clean,
     git_upstream_status,
     run_git,
 )
+from .lifecycle_events import LifecycleEvent, LifecycleEventEmitter, LifecycleEventStore
 from .locks import DEFAULT_RUNNER_CMD_HINTS, assess_lock, process_alive
+from .ports.backend_orchestrator import (
+    BackendOrchestrator as BackendOrchestratorProtocol,
+)
 from .runner_controller import ProcessRunnerController, SpawnRunnerFn
+from .runtime import RuntimeContext
 from .state import RunnerState, load_state, now_iso
+from .types import AppServerSupervisorFactory, BackendFactory
 from .utils import atomic_write
 
 logger = logging.getLogger("codex_autorunner.hub")
 
+BackendFactoryBuilder = Callable[[Path, RepoConfig], BackendFactory]
+AppServerSupervisorFactoryBuilder = Callable[[RepoConfig], AppServerSupervisorFactory]
+BackendOrchestratorBuilder = Callable[[Path, RepoConfig], BackendOrchestratorProtocol]
+
 
 def _git_failure_detail(proc) -> str:
     return (proc.stderr or proc.stdout or "").strip() or f"exit {proc.returncode}"
@@ -195,10 +209,29 @@ class RepoRunner:
         *,
         repo_config: RepoConfig,
         spawn_fn: Optional[SpawnRunnerFn] = None,
+        backend_factory_builder: Optional[BackendFactoryBuilder] = None,
+        app_server_supervisor_factory_builder: Optional[
+            AppServerSupervisorFactoryBuilder
+        ] = None,
+        backend_orchestrator_builder: Optional[BackendOrchestratorBuilder] = None,
+        agent_id_validator: Optional[Callable[[str], str]] = None,
     ):
         self.repo_id = repo_id
-        self._engine = Engine(repo_root, config=repo_config)
-        self._controller = ProcessRunnerController(self._engine, spawn_fn=spawn_fn)
+        backend_orchestrator = (
+            backend_orchestrator_builder(repo_root, repo_config)
+            if backend_orchestrator_builder is not None
+            else None
+        )
+        if backend_orchestrator is None:
+            raise ValueError(
+                "backend_orchestrator_builder is required for HubSupervisor"
+            )
+        self._ctx = RuntimeContext(
+            repo_root=repo_root,
+            config=repo_config,
+            backend_orchestrator=backend_orchestrator,
+        )
+        self._controller = ProcessRunnerController(self._ctx, spawn_fn=spawn_fn)
 
     @property
     def running(self) -> bool:
@@ -219,21 +252,60 @@ class RepoRunner:
 
 class HubSupervisor:
     def __init__(
-        self, hub_config: HubConfig, *, spawn_fn: Optional[SpawnRunnerFn] = None
+        self,
+        hub_config: HubConfig,
+        *,
+        spawn_fn: Optional[SpawnRunnerFn] = None,
+        backend_factory_builder: Optional[BackendFactoryBuilder] = None,
+        app_server_supervisor_factory_builder: Optional[
+            AppServerSupervisorFactoryBuilder
+        ] = None,
+        backend_orchestrator_builder: Optional[BackendOrchestratorBuilder] = None,
+        agent_id_validator: Optional[Callable[[str], str]] = None,
     ):
         self.hub_config = hub_config
         self.state_path = hub_config.root / ".codex-autorunner" / "hub_state.json"
         self._runners: Dict[str, RepoRunner] = {}
         self._spawn_fn = spawn_fn
+        self._backend_factory_builder = backend_factory_builder
+        self._app_server_supervisor_factory_builder = (
+            app_server_supervisor_factory_builder
+        )
+        self._backend_orchestrator_builder = backend_orchestrator_builder
+        self._agent_id_validator = agent_id_validator
         self.state = load_hub_state(self.state_path, self.hub_config.root)
         self._list_cache_at: Optional[float] = None
         self._list_cache: Optional[List[RepoSnapshot]] = None
+        self._list_lock = threading.Lock()
+        self._lifecycle_emitter = LifecycleEventEmitter(hub_config.root)
+        self._lifecycle_task_lock = threading.Lock()
+        self._lifecycle_stop_event = threading.Event()
+        self._lifecycle_thread: Optional[threading.Thread] = None
+        self._dispatch_interceptor_task: Optional[asyncio.Task] = None
+        self._dispatch_interceptor_stop_event: Optional[threading.Event] = None
+        self._dispatch_interceptor_thread: Optional[threading.Thread] = None
         self._reconcile_startup()
+        self._start_lifecycle_event_processor()
+        self._start_dispatch_interceptor()
 
     @classmethod
-    def from_path(cls, path: Path) -> "HubSupervisor":
+    def from_path(
+        cls,
+        path: Path,
+        *,
+        backend_factory_builder: Optional[BackendFactoryBuilder] = None,
+        app_server_supervisor_factory_builder: Optional[
+            AppServerSupervisorFactoryBuilder
+        ] = None,
+        backend_orchestrator_builder: Optional[BackendOrchestratorBuilder] = None,
+    ) -> "HubSupervisor":
         config = load_hub_config(path)
-        return cls(config)
+        return cls(
+            config,
+            backend_factory_builder=backend_factory_builder,
+            app_server_supervisor_factory_builder=app_server_supervisor_factory_builder,
+            backend_orchestrator_builder=backend_orchestrator_builder,
+        )
 
     def scan(self) -> List[RepoSnapshot]:
         self._invalidate_list_cache()
@@ -244,16 +316,17 @@ class HubSupervisor:
         return snapshots
 
     def list_repos(self, *, use_cache: bool = True) -> List[RepoSnapshot]:
-        if use_cache and self._list_cache and self._list_cache_at is not None:
-            if time.monotonic() - self._list_cache_at < 2.0:
-                return self._list_cache
-        manifest, records = self._manifest_records(manifest_only=True)
-        snapshots = self._build_snapshots(records)
-        self.state = HubState(last_scan_at=self.state.last_scan_at, repos=snapshots)
-        save_hub_state(self.state_path, self.state, self.hub_config.root)
-        self._list_cache = snapshots
-        self._list_cache_at = time.monotonic()
-        return snapshots
+        with self._list_lock:
+            if use_cache and self._list_cache and self._list_cache_at is not None:
+                if time.monotonic() - self._list_cache_at < 2.0:
+                    return self._list_cache
+            manifest, records = self._manifest_records(manifest_only=True)
+            snapshots = self._build_snapshots(records)
+            self.state = HubState(last_scan_at=self.state.last_scan_at, repos=snapshots)
+            save_hub_state(self.state_path, self.state, self.hub_config.root)
+            self._list_cache = snapshots
+            self._list_cache_at = time.monotonic()
+            return snapshots
 
     def _reconcile_startup(self) -> None:
         try:
@@ -268,8 +341,19 @@ class HubSupervisor:
                 repo_config = derive_repo_config(
                     self.hub_config, record.absolute_path, load_env=False
                 )
+                backend_orchestrator = (
+                    self._backend_orchestrator_builder(
+                        record.absolute_path, repo_config
+                    )
+                    if self._backend_orchestrator_builder is not None
+                    else None
+                )
                 controller = ProcessRunnerController(
-                    Engine(record.absolute_path, config=repo_config)
+                    RuntimeContext(
+                        repo_root=record.absolute_path,
+                        config=repo_config,
+                        backend_orchestrator=backend_orchestrator,
+                    )
                 )
                 controller.reconcile()
             except Exception as exc:
@@ -593,6 +677,9 @@ class HubSupervisor:
         worktree_repo_id: str,
         delete_branch: bool = False,
         delete_remote: bool = False,
+        archive: bool = True,
+        force_archive: bool = False,
+        archive_note: Optional[str] = None,
     ) -> None:
         self._invalidate_list_cache()
         manifest = load_manifest(self.hub_config.manifest_path, self.hub_config.root)
@@ -613,6 +700,44 @@ class HubSupervisor:
         if runner:
             runner.stop()
 
+        if archive:
+            branch_name = entry.branch or git_branch(worktree_path) or "unknown"
+            head_sha = git_head_sha(worktree_path) or "unknown"
+            snapshot_id = build_snapshot_id(branch_name, head_sha)
+            logger.info(
+                "Hub archive worktree start id=%s snapshot_id=%s",
+                worktree_repo_id,
+                snapshot_id,
+            )
+            try:
+                result = archive_worktree_snapshot(
+                    base_repo_root=base_path,
+                    base_repo_id=base.id,
+                    worktree_repo_root=worktree_path,
+                    worktree_repo_id=worktree_repo_id,
+                    branch=branch_name,
+                    worktree_of=entry.worktree_of,
+                    note=archive_note,
+                    snapshot_id=snapshot_id,
+                    head_sha=head_sha,
+                    source_path=entry.path,
+                )
+            except Exception as exc:
+                logger.exception(
+                    "Hub archive worktree failed id=%s snapshot_id=%s",
+                    worktree_repo_id,
+                    snapshot_id,
+                )
+                if not force_archive:
+                    raise ValueError(f"Worktree archive failed: {exc}") from exc
+            else:
+                logger.info(
+                    "Hub archive worktree complete id=%s snapshot_id=%s status=%s",
+                    worktree_repo_id,
+                    result.snapshot_id,
+                    result.status,
+                )
+
         # Remove worktree from base repo.
         try:
             proc = run_git(
@@ -777,6 +902,12 @@ class HubSupervisor:
             repo_root,
             repo_config=repo_config,
             spawn_fn=self._spawn_fn,
+            backend_factory_builder=self._backend_factory_builder,
+            app_server_supervisor_factory_builder=(
+                self._app_server_supervisor_factory_builder
+            ),
+            backend_orchestrator_builder=self._backend_orchestrator_builder,
+            agent_id_validator=self._agent_id_validator,
         )
         self._runners[repo_id] = runner
         return runner
@@ -819,8 +950,148 @@ class HubSupervisor:
         return snapshot
 
     def _invalidate_list_cache(self) -> None:
-        self._list_cache = None
-        self._list_cache_at = None
+        with self._list_lock:
+            self._list_cache = None
+            self._list_cache_at = None
+
+    @property
+    def lifecycle_emitter(self) -> LifecycleEventEmitter:
+        return self._lifecycle_emitter
+
+    @property
+    def lifecycle_store(self) -> LifecycleEventStore:
+        return self._lifecycle_emitter._store
+
+    def trigger_pma_from_lifecycle_event(self, event: LifecycleEvent) -> None:
+        if event.processed:
+            return
+        event_id = event.event_id
+        if event_id is None:
+            return
+        self.lifecycle_store.mark_processed(event_id)
+        self.lifecycle_store.prune_processed(keep_last=50)
+        logger.info(
+            "PMA wakeup triggered by lifecycle event: type=%s repo_id=%s run_id=%s",
+            event.event_type.value,
+            event.repo_id,
+            event.run_id,
+        )
+
+    def process_lifecycle_events(self) -> None:
+        events = self.lifecycle_store.get_unprocessed(limit=100)
+        if not events:
+            return
+        for event in events:
+            try:
+                self.trigger_pma_from_lifecycle_event(event)
+            except Exception as exc:
+                logger.exception(
+                    "Failed to process lifecycle event %s: %s", event.event_id, exc
+                )
+
+    def _start_lifecycle_event_processor(self) -> None:
+        if self._lifecycle_thread is not None:
+            return
+
+        def _process_loop():
+            while not self._lifecycle_stop_event.wait(5.0):
+                try:
+                    self.process_lifecycle_events()
+                except Exception:
+                    logger.exception("Error in lifecycle event processor")
+
+        self._lifecycle_thread = threading.Thread(
+            target=_process_loop, daemon=True, name="lifecycle-event-processor"
+        )
+        self._lifecycle_thread.start()
+
+    def _stop_lifecycle_event_processor(self) -> None:
+        if self._lifecycle_thread is None:
+            return
+        self._lifecycle_stop_event.set()
+        self._lifecycle_thread.join(timeout=2.0)
+        self._lifecycle_thread = None
+
+    def shutdown(self) -> None:
+        self._stop_lifecycle_event_processor()
+        self._stop_dispatch_interceptor()
+
+    def _start_dispatch_interceptor(self) -> None:
+        if not self.hub_config.pma.enabled:
+            return
+        if not self.hub_config.pma.dispatch_interception_enabled:
+            return
+        if self._dispatch_interceptor_thread is not None:
+            return
+
+        import asyncio
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            pass
+
+        def _run_interceptor():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            from .pma_dispatch_interceptor import run_dispatch_interceptor
+
+            stop_event = threading.Event()
+            self._dispatch_interceptor_stop_event = stop_event
+
+            async def run_until_stop():
+                task = None
+                try:
+                    task = await run_dispatch_interceptor(
+                        hub_root=self.hub_config.root,
+                        supervisor=self,
+                        interval_seconds=5.0,
+                        on_intercept=self._on_dispatch_intercept,
+                    )
+                    while not stop_event.is_set():
+                        await asyncio.sleep(0.1)
+                except asyncio.CancelledError:
+                    pass
+                finally:
+                    if task is not None and not task.done():
+                        task.cancel()
+                    if task is not None:
+                        try:
+                            await task
+                        except (asyncio.CancelledError, Exception):
+                            pass
+
+            loop.run_until_complete(run_until_stop())
+            loop.close()
+
+        self._dispatch_interceptor_thread = threading.Thread(
+            target=_run_interceptor, daemon=True, name="pma-dispatch-interceptor"
+        )
+        self._dispatch_interceptor_thread.start()
+
+    def _stop_dispatch_interceptor(self) -> None:
+        if self._dispatch_interceptor_stop_event is not None:
+            self._dispatch_interceptor_stop_event.set()
+        if self._dispatch_interceptor_thread is not None:
+            self._dispatch_interceptor_thread.join(timeout=2.0)
+            self._dispatch_interceptor_thread = None
+            self._dispatch_interceptor_stop_event = None
+
+    def _on_dispatch_intercept(self, event_id: str, result: Any) -> None:
+        logger.info(
+            "Dispatch intercepted: event_id=%s action=%s reason=%s",
+            event_id,
+            (
+                result.get("action")
+                if isinstance(result, dict)
+                else getattr(result, "action", None)
+            ),
+            (
+                result.get("reason")
+                if isinstance(result, dict)
+                else getattr(result, "reason", None)
+            ),
+        )
 
     def _snapshot_from_record(self, record: DiscoveryRecord) -> RepoSnapshot:
         repo_path = record.absolute_path

codex_autorunner/core/lifecycle_events.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from .locks import file_lock
+from .utils import atomic_write
+
+logger = logging.getLogger(__name__)
+
+LIFECYCLE_EVENTS_FILENAME = "lifecycle_events.json"
+LIFECYCLE_EVENTS_LOCK_SUFFIX = ".lock"
+
+
+class LifecycleEventType(str, Enum):
+    FLOW_PAUSED = "flow_paused"
+    FLOW_COMPLETED = "flow_completed"
+    FLOW_FAILED = "flow_failed"
+    FLOW_STOPPED = "flow_stopped"
+    DISPATCH_CREATED = "dispatch_created"
+
+
+@dataclass
+class LifecycleEvent:
+    event_type: LifecycleEventType
+    repo_id: str
+    run_id: str
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    processed: bool = False
+    event_id: str = ""
+
+    def __post_init__(self):
+        if not self.event_id:
+            import uuid
+
+            object.__setattr__(self, "event_id", str(uuid.uuid4()))
+
+
+def default_lifecycle_events_path(hub_root: Path) -> Path:
+    return hub_root / ".codex-autorunner" / LIFECYCLE_EVENTS_FILENAME
+
+
+class LifecycleEventStore:
+    def __init__(self, hub_root: Path) -> None:
+        self._path = default_lifecycle_events_path(hub_root)
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def _lock_path(self) -> Path:
+        return self._path.with_suffix(LIFECYCLE_EVENTS_LOCK_SUFFIX)
+
+    def load(self, *, ensure_exists: bool = True) -> list[LifecycleEvent]:
+        with file_lock(self._lock_path()):
+            if not self._path.exists():
+                return []
+            try:
+                raw = self._path.read_text(encoding="utf-8")
+            except OSError as exc:
+                logger.warning(
+                    "Failed to read lifecycle events at %s: %s", self._path, exc
+                )
+                return []
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError as exc:
+                logger.warning(
+                    "Failed to parse lifecycle events at %s: %s", self._path, exc
+                )
+                return []
+            if not isinstance(data, list):
+                logger.warning("Lifecycle events data is not a list: %s", self._path)
+                return []
+            events: list[LifecycleEvent] = []
+            for entry in data:
+                try:
+                    if not isinstance(entry, dict):
+                        continue
+                    event_type_str = entry.get("event_type")
+                    if not isinstance(event_type_str, str):
+                        continue
+                    try:
+                        event_type = LifecycleEventType(event_type_str)
+                    except ValueError:
+                        continue
+                    event_id_raw = entry.get("event_id")
+                    event_id = (
+                        str(event_id_raw) if isinstance(event_id_raw, str) else ""
+                    )
+                    if not event_id:
+                        import uuid
+
+                        event_id = str(uuid.uuid4())
+                    event = LifecycleEvent(
+                        event_type=event_type,
+                        repo_id=str(entry.get("repo_id", "")),
+                        run_id=str(entry.get("run_id", "")),
+                        data=dict(entry.get("data", {})),
+                        timestamp=str(entry.get("timestamp", "")),
+                        processed=bool(entry.get("processed", False)),
+                        event_id=event_id,
+                    )
+                    events.append(event)
+                except Exception as exc:
+                    logger.debug("Failed to parse lifecycle event entry: %s", exc)
+                    continue
+            return events
+
+    def save(self, events: list[LifecycleEvent]) -> None:
+        with file_lock(self._lock_path()):
+            self._save_unlocked(events)
+
+    def _save_unlocked(self, events: list[LifecycleEvent]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        data = [
+            {
+                "event_id": event.event_id,
+                "event_type": event.event_type.value,
+                "repo_id": event.repo_id,
+                "run_id": event.run_id,
+                "data": event.data,
+                "timestamp": event.timestamp,
+                "processed": event.processed,
+            }
+            for event in events
+        ]
+        atomic_write(self._path, json.dumps(data, indent=2) + "\n")
+
+    def append(self, event: LifecycleEvent) -> None:
+        events = self.load(ensure_exists=False)
+        events.append(event)
+        self.save(events)
+
+    def mark_processed(self, event_id: str) -> Optional[LifecycleEvent]:
+        if not event_id:
+            return None
+        events = self.load(ensure_exists=False)
+        updated = None
+        for event in events:
+            if event.event_id == event_id:
+                event.processed = True
+                updated = event
+                break
+        if updated:
+            self.save(events)
+        return updated
+
+    def get_unprocessed(self, *, limit: int = 100) -> list[LifecycleEvent]:
+        events = self.load(ensure_exists=False)
+        unprocessed = [e for e in events if not e.processed]
+        return unprocessed[:limit]
+
+    def prune_processed(self, *, keep_last: int = 100) -> None:
+        events = self.load(ensure_exists=False)
+        unprocessed = [e for e in events if not e.processed]
+        processed = [e for e in events if e.processed]
+        if len(processed) > keep_last:
+            processed = processed[-keep_last:]
+        self.save(unprocessed + processed)
+
+
+class LifecycleEventEmitter:
+    def __init__(self, hub_root: Path) -> None:
+        self._store = LifecycleEventStore(hub_root)
+        self._listeners: list[Callable[[LifecycleEvent], None]] = []
+
+    def emit(self, event: LifecycleEvent) -> str:
+        self._store.append(event)
+        for listener in self._listeners:
+            try:
+                listener(event)
+            except Exception as exc:
+                logger.exception("Error in lifecycle event listener: %s", exc)
+        return event.event_id
+
+    def emit_flow_paused(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_PAUSED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_flow_completed(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_COMPLETED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_flow_failed(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_FAILED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_flow_stopped(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_STOPPED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_dispatch_created(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.DISPATCH_CREATED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def add_listener(self, listener: Callable[[LifecycleEvent], None]) -> None:
+        self._listeners.append(listener)
+
+    def remove_listener(self, listener: Callable[[LifecycleEvent], None]) -> None:
+        self._listeners = [lst for lst in self._listeners if lst != listener]
+
+
+__all__ = [
+    "LifecycleEventType",
+    "LifecycleEvent",
+    "LifecycleEventStore",
+    "LifecycleEventEmitter",
+    "default_lifecycle_events_path",
+]

codex_autorunner/core/notifications.py

@@ -23,6 +23,18 @@ class NotificationManager:
         self._warned_missing: set[str] = set()
         self._enabled_mode = self._parse_enabled(self._cfg.get("enabled"))
         self._events = self._normalize_events(self._cfg.get("events"))
+        timeout_raw = self._cfg.get("timeout_seconds", DEFAULT_TIMEOUT_SECONDS)
+        try:
+            timeout_seconds = (
+                float(timeout_raw)
+                if timeout_raw is not None
+                else DEFAULT_TIMEOUT_SECONDS
+            )
+        except (TypeError, ValueError):
+            timeout_seconds = DEFAULT_TIMEOUT_SECONDS
+        if timeout_seconds <= 0:
+            timeout_seconds = DEFAULT_TIMEOUT_SECONDS
+        self._timeout_seconds = timeout_seconds
         self._warn_unknown_events(self._events)
         discord_cfg = self._cfg.get("discord")
         self._discord: Dict[str, Any] = (
@@ -202,7 +214,7 @@ class NotificationManager:
         if not targets:
             return
         try:
-            with httpx.Client(timeout=DEFAULT_TIMEOUT_SECONDS) as client:
+            with httpx.Client(timeout=self._timeout_seconds) as client:
                 self._send_sync(client, targets, message)
         except Exception as exc:
             self._log_warning("Notification delivery failed", exc)
@@ -216,7 +228,7 @@ class NotificationManager:
         if not targets:
             return
         try:
-            async with httpx.AsyncClient(timeout=DEFAULT_TIMEOUT_SECONDS) as client:
+            async with httpx.AsyncClient(timeout=self._timeout_seconds) as client:
                 await self._send_async(client, targets, message)
         except Exception as exc:
             self._log_warning("Notification delivery failed", exc)