ttasks 0.3.0__tar.gz → 0.3.1__tar.gz

{ttasks-0.3.0 → ttasks-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ttasks
-Version: 0.3.0
+Version: 0.3.1
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: github-copilot-sdk>=0.1.0

{ttasks-0.3.0 → ttasks-0.3.1}/src/ttasks/_executor.py

@@ -11,9 +11,10 @@ import time
 import warnings
 from collections.abc import Callable, Mapping
 from concurrent.futures import Future, ThreadPoolExecutor
+from contextlib import suppress
 from dataclasses import dataclass
 from datetime import datetime
-from threading import RLock, Thread
+from threading import RLock, Thread, current_thread
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, TextIO, cast
 
@@ -236,6 +237,8 @@ class TaskExecutor:
         :meth:`Future.cancel` only cancels work that has not started yet; cancel
         running tasks through :meth:`cancel`.
         """
+        self._validate_task(task)
+        policy = self._resolve_retry_policy(retry_policy)
         # Shallow-copy the mapping so caller mutation cannot race the worker;
         # Task refs themselves intentionally remain shared.
         upstream_snapshot = dict(upstream or {})
@@ -244,12 +247,27 @@ class TaskExecutor:
                 raise RuntimeError("executor is shut down")
             if self._pool is None:
                 self._pool = ThreadPoolExecutor(thread_name_prefix="ttasks")
-            return self._pool.submit(
-                self.execute,
+            future = self._pool.submit(
+                self._execute_submitted,
                 task,
                 upstream_snapshot,
-                retry_policy=retry_policy,
+                policy,
             )
+            future.add_done_callback(
+                lambda submitted: self.cancel(task) if submitted.cancelled() else None
+            )
+            return future
+
+    def _execute_submitted(
+        self,
+        task: Task,
+        upstream: Mapping[str, Task],
+        retry_policy: RetryPolicy,
+    ) -> TaskResult:
+        """Execute submitted work, preserving queued cancellation semantics."""
+        if task.status == TaskStatus.CANCELLED:
+            raise TaskCancelled(f"Task {task.id!r} was cancelled")
+        return self.execute(task, upstream, retry_policy=retry_policy)
 
     def shutdown(self) -> None:
         """Shut down async submission, waiting for submitted work to finish.
@@ -265,7 +283,15 @@ class TaskExecutor:
             pool = self._pool
             self._pool = None
         if pool is not None:
-            pool.shutdown(wait=True)
+            current = current_thread()
+            pool_threads = list(getattr(pool, "_threads", ()))
+            if current in pool_threads:
+                pool.shutdown(wait=False)
+                for thread in pool_threads:
+                    if thread is not current:
+                        thread.join()
+            else:
+                pool.shutdown(wait=True)
 
     def close(self) -> None:
         """Alias for :meth:`shutdown` for resource-cleanup contexts."""
@@ -417,10 +443,11 @@ class TaskExecutor:
             self.store.graphs.save(graph)
         except BaseException as error:
             self.graph_persistence_errors.append((graph.id, error))
-            warnings.warn(
-                f"graph persistence failed for graph {graph.id!r}: {error}",
-                stacklevel=2,
-            )
+            with suppress(Warning):
+                warnings.warn(
+                    f"graph persistence failed for graph {graph.id!r}: {error}",
+                    stacklevel=2,
+                )
 
     def cancel(self, task: Task) -> None:
         """Cancel a task and terminate its subprocess if one is active.
@@ -495,7 +522,8 @@ class TaskExecutor:
         ``retry_policy`` retries failed attempts for this single task only.
         Cancellation is never retried.
         """
-        policy = retry_policy or RetryPolicy()
+        self._validate_task(task)
+        policy = self._resolve_retry_policy(retry_policy)
         if policy.max_attempts == 1 or self._handlers.get(task.type) is None:
             return self._execute_once(task, upstream)
 
@@ -513,7 +541,7 @@ class TaskExecutor:
                 if out_of_attempts or task.status != TaskStatus.FAILED:
                     raise
                 if policy.backoff:
-                    time.sleep(policy.backoff)
+                    self._sleep_retry_backoff(task, policy.backoff)
                 if task.status == TaskStatus.CANCELLED:
                     raise TaskCancelled(
                         f"Task {task.id!r} was cancelled",
@@ -521,6 +549,35 @@ class TaskExecutor:
 
         raise AssertionError("unreachable retry loop exit")  # pragma: no cover
 
+    @staticmethod
+    def _validate_task(task: Task) -> None:
+        """Reject malformed task arguments before accessing Task internals."""
+        if not isinstance(task, Task):
+            raise TypeError("task must be a Task")
+
+    @staticmethod
+    def _resolve_retry_policy(retry_policy: RetryPolicy | None) -> RetryPolicy:
+        """Return a concrete RetryPolicy, rejecting malformed public input."""
+        if retry_policy is None:
+            return RetryPolicy()
+        if not isinstance(retry_policy, RetryPolicy):
+            raise TypeError("retry_policy must be a RetryPolicy")
+        return retry_policy
+
+    @staticmethod
+    def _sleep_retry_backoff(task: Task, backoff: float) -> None:
+        """Sleep between retry attempts while periodically observing cancel()."""
+        if backoff <= 0.5:
+            time.sleep(backoff)
+            return
+
+        deadline = time.monotonic() + backoff
+        while task.status != TaskStatus.CANCELLED:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return
+            time.sleep(min(remaining, 0.05))
+
     def _execute_once(
         self,
         task: Task,
@@ -714,6 +771,16 @@ class TaskExecutor:
         stderr_thread.start()
         timed_out = False
         timeout_error: subprocess.TimeoutExpired | None = None
+        deadline = (
+            None if context.timeout is None else time.monotonic() + context.timeout
+        )
+
+        def remaining_timeout() -> float | None:
+            """Return remaining wall-clock timeout for process/output draining."""
+            if deadline is None:
+                return None
+            return max(0.0, deadline - time.monotonic())
+
         if context.cancelled:
             self._terminate_process(process)
         try:
@@ -724,14 +791,23 @@ class TaskExecutor:
                 timed_out = True
                 timeout_error = e
         finally:
-            stdout_thread.join()
-            stderr_thread.join()
+            for thread in (stdout_thread, stderr_thread):
+                thread.join(remaining_timeout())
+            if (
+                not timed_out
+                and deadline is not None
+                and (stdout_thread.is_alive() or stderr_thread.is_alive())
+            ):
+                self._terminate_process(process)
+                timed_out = True
+            if timed_out:
+                stdout_thread.join()
+                stderr_thread.join()
             self._running_processes.pop(context.id, None)
 
         stdout = "".join(stdout_chunks)
         stderr = "".join(stderr_chunks)
         if timed_out:
-            assert timeout_error is not None
             message = f"Task timed out after {context.timeout} seconds"
             completed = subprocess.CompletedProcess(
                 args=args,
@@ -739,7 +815,9 @@ class TaskExecutor:
                 stdout=stdout,
                 stderr=stderr,
             )
-            raise TaskTimeoutError(message, completed) from timeout_error
+            if timeout_error is not None:
+                raise TaskTimeoutError(message, completed) from timeout_error
+            raise TaskTimeoutError(message, completed)
 
         result = subprocess.CompletedProcess(
             args=args,

{ttasks-0.3.0 → ttasks-0.3.1}/src/ttasks/_graph.py

@@ -72,6 +72,8 @@ class TaskGraph:
         self._tasks[task.id] = task
         deps: list[str] = []
         for dep in after:
+            if not isinstance(dep, Task):
+                raise TypeError(f"Expected Task dependency, got {type(dep).__name__}")
             if dep.id not in deps:
                 deps.append(dep.id)
         self._deps[task.id] = deps
@@ -349,11 +351,12 @@ class TaskGraph:
 
             def inactive(tid: str) -> bool:
                 """Return whether tid can no longer change in this run."""
+                if tid in futures:
+                    return futures[tid].done()
                 task = self._tasks[tid]
                 return (
                     (task.is_terminal and not retryable_this_run(tid))
                     or tid in self._errors
-                    or (tid in futures and futures[tid].done())
                 )
 
             def ready(tid: str) -> bool:
@@ -373,6 +376,10 @@ class TaskGraph:
                 authoritative.
                 """
                 for d in self._deps[tid]:
+                    if d in futures and not futures[d].done():
+                        continue
+                    if d in self._errors:
+                        return d
                     if self._tasks[d].status.is_bad and not retryable_this_run(d):
                         return d
                 return None

{ttasks-0.3.0 → ttasks-0.3.1}/src/ttasks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)
 
 __commit_id__ = commit_id = None

{ttasks-0.3.0 → ttasks-0.3.1}/tests/test_executor.py

@@ -357,6 +357,51 @@ def test_retry_policy_rejects_invalid_backoff() -> None:
         RetryPolicy(backoff=float("nan"))
 
 
+def test_execute_rejects_invalid_retry_policy() -> None:
+    """execute() rejects malformed retry_policy values clearly."""
+    executor = TaskExecutor()
+    bad_policy: Any = object()
+
+    with pytest.raises(TypeError, match="retry_policy must be a RetryPolicy"):
+        executor.execute(Task.bash("", title="Example"), retry_policy=bad_policy)
+
+
+def test_execute_rejects_non_task() -> None:
+    """execute() rejects malformed task objects before accessing internals."""
+    executor = TaskExecutor()
+    not_task: Any = object()
+
+    with pytest.raises(TypeError, match="task must be a Task"):
+        executor.execute(not_task)
+
+
+def test_submit_rejects_invalid_retry_policy_synchronously() -> None:
+    """submit() rejects malformed retry_policy values before queueing work."""
+    executor = TaskExecutor()
+    task = Task.bash("", title="Example")
+    bad_policy: Any = object()
+
+    with pytest.raises(TypeError, match="retry_policy must be a RetryPolicy"):
+        executor.submit(task, retry_policy=bad_policy)
+
+    assert task.status == TaskStatus.PENDING
+    assert task.result is None
+    assert executor.is_shutdown is False
+    executor.close()
+
+
+def test_submit_rejects_non_task_synchronously() -> None:
+    """submit() rejects malformed task objects before creating async work."""
+    executor = TaskExecutor()
+    not_task: Any = object()
+
+    with pytest.raises(TypeError, match="task must be a Task"):
+        executor.submit(not_task)
+
+    assert executor.is_shutdown is False
+    executor.close()
+
+
 def test_execute_retry_policy_recovers_after_handler_failure() -> None:
     """A retry policy re-runs a failed single task until it succeeds."""
     executor = TaskExecutor()
@@ -503,6 +548,44 @@ def test_execute_retry_policy_honors_cancellation_during_backoff(
     assert task.status == TaskStatus.CANCELLED
 
 
+def test_retry_backoff_observes_external_cancellation_promptly() -> None:
+    """A real backoff sleep wakes promptly when another thread cancels the task."""
+    executor = TaskExecutor()
+    task = Task.bash("", title="Example")
+    failed = threading.Event()
+    attempts = 0
+
+    def handler(context: TaskContext) -> None:
+        """Fail each attempt; cancellation should stop retries during backoff."""
+        nonlocal attempts
+        attempts += 1
+        raise RuntimeError("boom")
+
+    def note_failure(event: TaskEvent) -> None:
+        if event.type is TaskEventType.FAILED:
+            failed.set()
+
+    executor.register(TaskType.BASH, handler)
+    executor.events.subscribe(note_failure)
+
+    future = executor.submit(
+        task,
+        retry_policy=RetryPolicy(max_attempts=2, backoff=1.0),
+    )
+    assert failed.wait(timeout=1)
+    start = time.monotonic()
+    executor.cancel(task)
+
+    with pytest.raises(TaskCancelled, match="was cancelled"):
+        future.result(timeout=0.5)
+    elapsed = time.monotonic() - start
+    executor.close()
+
+    assert attempts == 1
+    assert task.status == TaskStatus.CANCELLED
+    assert elapsed < 0.5
+
+
 def test_execute_retry_policy_honors_zero_backoff_cancellation() -> None:
     """Cancellation between immediate retry attempts is still observed."""
     executor = TaskExecutor()
@@ -715,6 +798,80 @@ def test_submit_missing_handler_future_raises_after_failed_event() -> None:
     assert [event.type for event in events] == [TaskEventType.FAILED]
 
 
+def test_executor_cancelled_queued_submit_raises_task_cancelled() -> None:
+    """executor.cancel() for queued async work is reflected on the future."""
+    executor = TaskExecutor()
+    blocker = Task.bash("", title="Blocker")
+    queued = Task.bash("", title="Queued")
+    blocker_started = threading.Event()
+    release_blocker = threading.Event()
+
+    def handler(context: TaskContext) -> str:
+        """Keep one worker occupied so the second future remains queued."""
+        if context.id == blocker.id:
+            blocker_started.set()
+            assert release_blocker.wait(timeout=1)
+        return context.title
+
+    executor.register(TaskType.BASH, handler)
+    with executor._pool_lock:
+        executor._pool = ThreadPoolExecutor(max_workers=1)
+
+    blocker_future = executor.submit(blocker)
+    assert blocker_started.wait(timeout=1)
+    queued_future = executor.submit(queued)
+    executor.cancel(queued)
+    release_blocker.set()
+
+    assert blocker_future.result(timeout=1).output == "Blocker"
+    with pytest.raises(TaskCancelled, match="was cancelled"):
+        queued_future.result(timeout=1)
+    executor.close()
+
+    assert queued.status == TaskStatus.CANCELLED
+    assert queued.result is not None
+    assert queued.result.termination_reason == "cancelled"
+
+
+def test_future_cancel_marks_queued_task_cancelled() -> None:
+    """Future.cancel() on queued work is reflected in task state and events."""
+    executor = TaskExecutor()
+    blocker = Task.bash("", title="Blocker")
+    queued = Task.bash("", title="Queued")
+    blocker_started = threading.Event()
+    release_blocker = threading.Event()
+    events: list[TaskEvent] = []
+
+    def handler(context: TaskContext) -> str:
+        """Keep one worker occupied so the second future remains queued."""
+        if context.id == blocker.id:
+            blocker_started.set()
+            assert release_blocker.wait(timeout=1)
+        return context.title
+
+    executor.register(TaskType.BASH, handler)
+    executor.events.subscribe(events.append)
+    with executor._pool_lock:
+        executor._pool = ThreadPoolExecutor(max_workers=1)
+
+    blocker_future = executor.submit(blocker)
+    assert blocker_started.wait(timeout=1)
+    queued_future = executor.submit(queued)
+
+    assert queued_future.cancel() is True
+    release_blocker.set()
+    executor.close()
+
+    assert blocker_future.result(timeout=1).output == "Blocker"
+    assert queued.status == TaskStatus.CANCELLED
+    assert queued.result is not None
+    assert queued.result.termination_reason == "cancelled"
+    cancelled = [event for event in events if event.type is TaskEventType.CANCELLED]
+    assert len(cancelled) == 1
+    assert cancelled[0].task is queued
+    assert cancelled[0].previous_status == TaskStatus.PENDING
+
+
 def test_future_cancel_does_not_cancel_running_task() -> None:
     """Running submitted tasks are cancelled through executor.cancel(), not Future."""
     executor = TaskExecutor()
@@ -818,6 +975,67 @@ def test_shutdown_allows_queued_submissions_to_finish() -> None:
     assert queued.status == TaskStatus.SUCCEEDED
 
 
+def test_shutdown_from_worker_waits_for_other_running_workers() -> None:
+    """shutdown() from a worker still waits for other in-flight work."""
+    executor = TaskExecutor()
+    shutdown_task = Task.bash("", title="Shutdown")
+    other_task = Task.bash("", title="Other")
+    other_started = threading.Event()
+    release_other = threading.Event()
+    other_finished = threading.Event()
+
+    def handler(context: TaskContext) -> str:
+        """One worker shuts down while the other is still running."""
+        if context.id == other_task.id:
+            other_started.set()
+            assert release_other.wait(timeout=1)
+            other_finished.set()
+            return "other done"
+        assert other_started.wait(timeout=1)
+        timer = threading.Timer(0.1, release_other.set)
+        timer.start()
+        try:
+            executor.shutdown()
+        finally:
+            timer.cancel()
+        return "waited" if other_finished.is_set() else "returned early"
+
+    executor.register(TaskType.BASH, handler)
+    with executor._pool_lock:
+        executor._pool = ThreadPoolExecutor(max_workers=2)
+
+    other_future = executor.submit(other_task)
+    assert other_started.wait(timeout=1)
+    shutdown_future = executor.submit(shutdown_task)
+
+    assert shutdown_future.result(timeout=1).output == "waited"
+    assert other_future.result(timeout=1).output == "other done"
+    assert executor.is_shutdown is True
+
+
+def test_submitted_task_can_shutdown_its_executor() -> None:
+    """shutdown() from an executor worker should not fail the running task."""
+    executor = TaskExecutor()
+    task = Task.bash("", title="Self shutdown")
+
+    def handler(context: TaskContext) -> str:
+        """Close async submission from inside the running submitted task."""
+        executor.shutdown()
+        return "ok"
+
+    executor.register(TaskType.BASH, handler)
+
+    future = executor.submit(task)
+    result = future.result(timeout=1)
+
+    assert result.status == TaskStatus.SUCCEEDED
+    assert result.output == "ok"
+    assert task.status == TaskStatus.SUCCEEDED
+    assert executor.is_shutdown is True
+    with pytest.raises(RuntimeError, match="executor is shut down"):
+        executor.submit(Task.bash("", title="Later"))
+
+
 def test_close_aliases_shutdown() -> None:
     """close() remains a resource-cleanup alias for graceful shutdown."""
     executor = TaskExecutor()
@@ -1390,6 +1608,28 @@ def test_real_subprocess_timeout_kills_within_wall_budget() -> None:
     assert not executor.is_running(task.id)
 
 
+def test_timeout_applies_while_draining_output_from_background_children() -> None:
+    """A child inheriting stdout cannot make streaming output bypass timeout."""
+    executor = TaskExecutor()
+    task = Task.bash(
+        "printf 'before\\n'; sleep 2 &",
+        title="Background output holder",
+        timeout=0.1,
+    )
+
+    start = time.monotonic()
+    with pytest.raises(TaskTimeoutError, match="Task timed out after 0.1 seconds"):
+        executor.execute(task)
+    elapsed = time.monotonic() - start
+
+    assert task.status == TaskStatus.FAILED
+    assert task.result is not None
+    assert task.result.termination_reason == "timeout"
+    assert task.result.output == "before\n"
+    assert elapsed < 1.0, f"timeout waited for background child (took {elapsed:.2f}s)"
+    assert not executor.is_running(task.id)
+
+
 def test_timed_out_subprocess_result_preserves_partial_output() -> None:
     """Timeout results retain output captured before termination."""
     executor = TaskExecutor()

{ttasks-0.3.0 → ttasks-0.3.1}/tests/test_workflow.py

@@ -287,6 +287,28 @@ def test_run_no_progress_guard_raises_runtime_error() -> None:
         graph._run_inner(TaskExecutor(), max_workers=1)
 
 
+def test_executor_setup_error_blocks_descendants_without_deadlock() -> None:
+    """A future error before task terminalization still blocks descendants."""
+    parent = _bash("Parent", "")
+    child = _bash("Child", "")
+
+    class ExplodingExecutor(TaskExecutor):
+        def execute(self, *args: Any, **kwargs: Any) -> Any:
+            raise RuntimeError("setup boom")
+
+    graph = TaskGraph()
+    graph[parent] = []
+    graph[child] = [parent]
+
+    graph.run(ExplodingExecutor.empty())
+
+    assert parent.status == TaskStatus.PENDING
+    assert child.status == TaskStatus.BLOCKED
+    assert child.blocked_by == parent.id
+    assert isinstance(graph.errors[parent.id], RuntimeError)
+    assert graph.ok is False
+
+
 # ---- Execution ---------------------------------------------------------------
 
 
@@ -1033,6 +1055,16 @@ def test_add_rejects_non_task_and_non_bool_finally() -> None:
         graph.add(_bash("A", "echo a"), finally_=bad_finally)
 
 
+def test_add_rejects_non_task_dependency() -> None:
+    """add(after=...) validates dependencies instead of leaking AttributeError."""
+    graph = TaskGraph()
+    task = _bash("A", "echo a")
+    not_task: Any = object()
+
+    with pytest.raises(TypeError, match="Expected Task dependency, got object"):
+        graph.add(task, after=[not_task])
+
+
 def test_add_runs_like_setitem_form() -> None:
     """A graph built with .add() executes to the same end state as the mapping form."""
     a = _bash("A", "echo a")
@@ -1129,6 +1161,38 @@ def test_carryover_blocked_with_failed_parent_stays_blocked() -> None:
     assert b.status == TaskStatus.BLOCKED
 
 
+def test_descendant_waits_for_submitted_carryover_blocked_parent() -> None:
+    """A queued carryover-BLOCKED parent must not immediately block its child."""
+    a = _bash("A", "")
+    b = _bash("B", "")
+    c = _bash("C", "")
+    a.transition_to(TaskStatus.RUNNING)
+    a.transition_to(TaskStatus.FAILED, error="old failure")
+    b.transition_to(TaskStatus.BLOCKED)
+    b._set_blocked_by(a.id)
+    seen: list[str] = []
+
+    executor = TaskExecutor.empty()
+
+    def handler(context: Any) -> str:
+        seen.append(context.title)
+        return context.title
+
+    executor.register(TaskType.BASH, handler)
+    graph = TaskGraph()
+    graph[a] = []
+    graph[b] = [a]
+    graph[c] = [b]
+
+    graph.run(executor, max_workers=1)
+
+    assert seen == ["A", "B", "C"]
+    assert graph.ok
+    assert graph.blocked == []
+    assert b.blocked_by is None
+    assert c.status == TaskStatus.SUCCEEDED
+
+
 def test_within_run_blocked_is_not_retried_same_run() -> None:
     """A task BLOCKED during this run is terminal-for-the-run, not retried."""
     attempts: dict[str, int] = {"B": 0}
@@ -1181,6 +1245,46 @@ def test_finally_waits_for_retryable_failed_dependency_added_later() -> None:
     assert cleanup.status == TaskStatus.SUCCEEDED
 
 
+def test_finally_waits_for_inflight_carryover_retry() -> None:
+    """Finally tasks must not run while a carryover-failed parent is retrying."""
+    import threading
+
+    parent = _bash("parent", "")
+    parent.transition_to(TaskStatus.RUNNING)
+    parent.transition_to(TaskStatus.FAILED, error="old failure")
+    cleanup = _bash("cleanup", "")
+    release_parent = threading.Event()
+
+    class SlowRetryExecutor(TaskExecutor):
+        def execute(self, task: Any, *args: Any, **kwargs: Any) -> Any:
+            if task is parent:
+                assert release_parent.wait(timeout=1)
+            return super().execute(task, *args, **kwargs)
+
+    executor = SlowRetryExecutor.empty()
+
+    def handler(context: Any) -> str:
+        if context.id == cleanup.id:
+            return context.upstream[parent.id].status.value
+        return "parent retried"
+
+    executor.register(TaskType.BASH, handler)
+    graph = TaskGraph()
+    graph.add(cleanup, after=[parent], finally_=True)
+    graph[parent] = []
+
+    timer = threading.Timer(0.1, release_parent.set)
+    timer.start()
+    try:
+        graph.run(executor, max_workers=2)
+    finally:
+        timer.cancel()
+
+    assert parent.status == TaskStatus.SUCCEEDED
+    assert cleanup.result is not None
+    assert cleanup.result.output == "succeeded"
+
+
 def test_finally_runs_after_carryover_blocked_recovers() -> None:
     """A finally task fires after a carryover-BLOCKED task recovers to SUCCEEDED."""
     finally_ran: list[str] = []
@@ -1235,28 +1339,30 @@ def test_graph_persistence_errors_initially_empty() -> None:
     assert executor.graph_persistence_errors == []
 
 
-def test_graph_save_failure_does_not_break_run_and_records_error() -> None:
-    """A failing graph save records on graph_persistence_errors and warns."""
-    import warnings
+class _BrokenGraphs:
+    def save(self, graph: Any) -> None:
+        raise RuntimeError("disk full")
+
+
+class _BrokenGraphStore:
+    @property
+    def tasks(self) -> Any:
+        return None
 
-    class _BrokenGraphs:
-        def save(self, graph: Any) -> None:
-            raise RuntimeError("disk full")
+    @property
+    def graphs(self) -> Any:
+        return _BrokenGraphs()
 
-    class _BrokenStore:
-        @property
-        def tasks(self) -> Any:
-            return None
 
-        @property
-        def graphs(self) -> Any:
-            return _BrokenGraphs()
+def test_graph_save_failure_does_not_break_run_and_records_error() -> None:
+    """A failing graph save records on graph_persistence_errors and warns."""
+    import warnings
 
     a = _bash("A", "echo a")
     graph = TaskGraph()
     graph[a] = []
 
-    executor = TaskExecutor(store=_BrokenStore())
+    executor = TaskExecutor(store=_BrokenGraphStore())
     with warnings.catch_warnings(record=True) as captured:
         warnings.simplefilter("always")
         graph.run(executor)
@@ -1267,6 +1373,25 @@ def test_graph_save_failure_does_not_break_run_and_records_error() -> None:
     assert any("graph persistence failed" in str(w.message) for w in captured)
 
 
+def test_graph_save_failure_does_not_propagate_when_warnings_are_errors() -> None:
+    """Graph persistence warnings remain non-fatal under strict warning filters."""
+    import warnings
+
+    a = _bash("A", "")
+    graph = TaskGraph()
+    graph[a] = []
+
+    executor = TaskExecutor.empty(store=_BrokenGraphStore())
+    executor.register(TaskType.BASH, lambda _context: "ok")
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        graph.run(executor)
+
+    assert a.status == TaskStatus.SUCCEEDED
+    assert executor.graph_persistence_errors
+    assert all(gid == graph.id for gid, _ in executor.graph_persistence_errors)
+
+
 def test_persist_graph_no_store_is_noop() -> None:
     """Without a configured store, _persist_graph silently does nothing."""
     executor = TaskExecutor()