processes 3.1.0__tar.gz → 7.0.0__tar.gz

processes-7.0.0/.github/workflows/lint-pr.yml

@@ -0,0 +1,31 @@
+name: "Lint PR"
+
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+permissions:
+  pull-requests: read
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          types: |
+            fix
+            feat
+            docs
+            style
+            refactor
+            perf
+            test
+            build
+            ci

{processes-3.1.0 → processes-7.0.0}/.github/workflows/tests.yml

@@ -12,7 +12,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
 
     steps:
       - name: Checkout code

{processes-3.1.0 → processes-7.0.0}/.gitignore

@@ -180,4 +180,8 @@ mail_config.toml
 
 /logs/
 logs/*
-logs
+logs
+
+PR_DESCRIPTION.md
+
+FEATURE_PLAN.md

processes-7.0.0/CHANGELOG.md

@@ -0,0 +1,204 @@
+## v7.0.0 (2026-06-20)
+
+### BREAKING CHANGE
+
+- Task(channels=...) and the NotificationChannel API are removed;
+HTMLEmailStyle.style and traced_vars_frame_filter are removed (the latter moves
+to Task). Per-task email/webhook alerts are replaced by report.notify.
+
+### Feat
+
+- add process name to report, email subject, and webhook payload
+- normalize task names to lowercase for case-insensitive matching
+- delegate notifications to ProcessExecutionReport, drop per-task channels
+- replace notify_errors with notify(only_errors=...) and add task filter
+- implement WebhookChannel and EmailChannel send_report
+- add ReportChannel architecture for report notifications
+- add ProcessExecutionReport.notify/.notify_errors stubs
+- add ProcessExecutionReport.to_json
+- add graph mutation methods to Process
+
+### Refactor
+
+- group communication code into a comms/ package
+- unify SMTP and webhook transport behind single classes
+- extract task value types to leaf module, break import cycle
+
+### Perf
+
+- cache palette CSS and report template loading
+- cache language string loading
+- add slots=True to frozen value types
+
+## v6.0.0 (2026-06-15)
+
+### BREAKING CHANGE
+
+- Process.run() returns ProcessExecutionReport instead of
+ProcessResult. Use report.successes / report.errored / report.skipped
+instead of passed_tasks_results / errored_tasks / skipped_tasks, and
+report.entries[name].result / .error instead of
+passed_tasks_results[name] / failed_tasks_results[name].
+
+### Feat
+
+- remove ProcessResult, have Process.run() return ProcessExecutionReport
+- expand TaskStatus with PENDING and add status field to TaskResult
+- add ProcessExecutionReport for per-task execution summaries
+- track failed task results in ProcessRunner and ProcessResult
+- promote ErrorData to public API and add timing/attempts to TaskResult
+
+### Fix
+
+- make Task.run never propagate dependency-resolution failures
+
+### Refactor
+
+- drop _is_unrunnable side effect and reuse TaskResult helpers
+
+## v5.0.0 (2026-06-14)
+
+### BREAKING CHANGE
+
+- log_path and func swap positions; existing positional
+Task(name, log_path, func, ...) calls must be updated to
+Task(name, func, log_path, ...).
+
+### Feat
+
+- add nest_under option to WebhookConfig for nested payload envelopes
+- make Task.log_path optional, reorder constructor signature
+
+## v4.1.0 (2026-06-14)
+
+### Feat
+
+- add extra_payload to WebhookConfig for service-specific routing keys
+- include traced variables in task logfiles
+- add generic WebhookChannel with optional HMAC body signing
+
+### Refactor
+
+- make traced_vars a plain {name: repr(value)} dict
+
+## v4.0.0 (2026-06-14)
+
+### BREAKING CHANGE
+
+- Task no longer accepts smtp_config or email_style.
+Pass channels=[EmailChannel(smtp_config, style)] instead.
+
+### Feat
+
+- add NotificationChannel abstraction with file and email channels
+
+### Refactor
+
+- configure email alerts via channels instead of Task smtp_config
+- keep file and email channel implementations internal
+- build task handlers through notification channels
+
+## v3.1.1 (2026-06-13)
+
+### Refactor
+
+- rename _log_formatting to _logfile_formatting and _TaskLogFormatter to _TaskLogfileFormatter
+
+## v3.1.0 (2026-06-13)
+
+### Feat
+
+- **logging**: include failure context in task logfiles
+
+### Refactor
+
+- extract typed _ErrorData from task_context via shared base formatter
+- inline single-use _task_context_lines helper
+- move task logfile formatting out of _email_internals
+
+## v3.0.1 (2026-06-13)
+
+### Refactor
+
+- **process**: use bare raise and extract _is_done helper
+
+## v3.0.0 (2026-06-13)
+
+### BREAKING CHANGE
+
+- html_mail_handler parameter removed from Task; use
+smtp_config and email_style instead. HTMLSMTPHandler removed from public API.
+
+### Feat
+
+- **html_logging**: expose last_path_traced_vars on HTMLSMTPHandler
+
+### Refactor
+
+- **email**: replace HTMLSMTPHandler with SMTPConfig/HTMLEmailStyle
+
+## v2.0.1 (2026-06-12)
+
+### Fix
+
+- **publish.yml**: remove unneeded step ruff format check in quality-gate
+
+## v2.0.0 (2026-06-12)
+
+### BREAKING CHANGE
+
+- log records no longer carry
+``post_traceback_html_body``. Consumers introspecting that attribute
+must read ``record.task_context`` instead.
+
+### Feat
+
+- **email_alerting**: Traced Variables section with file:line reference in email body
+- **email_alerting**: language alternatives for HTML email body
+- **email_alerting**: template-driven HTML body from pure metadata
+
+### Fix
+
+- **process**: parallel runner no longer raises on unrunnable tail
+
+## v1.0.5 (2026-01-19)
+
+### Fix
+
+- **docs**: added urls to pyproject file
+
+## v1.0.4 (2026-01-19)
+
+### Fix
+
+- **docs**: added pypi badge and pip install instruction to readme
+
+## v1.0.3 (2026-01-19)
+
+### Fix
+
+- **docs**: changes in readme and index of docs to show banner
+
+## v1.0.2 (2026-01-19)
+
+### Fix
+
+- **ci**: added a workflow for publishing to pypi
+
+## v1.0.1 (2026-01-19)
+
+### Fix
+
+- **lint**: fix ruff formatting
+
+## v1.0.0 (2026-01-19)
+
+### BREAKING CHANGE
+
+- Task.run method had one of its kwargs removed
+
+### Fix
+
+- **Task-can-no-longer-pass-logger-to-its-function.-Changed-some-examples,-documentations-and-better-type-hints**: Task.run method no longer can pass logger to its function as kwarg
+
+## v0.1.0 (2026-01-18)

{processes-3.1.0 → processes-7.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processes
-Version: 3.1.0
+Version: 7.0.0
 Summary: Orchestrate graphs of callables in Python with automatic dependency resolution, parallel execution, retries, timeouts, and HTML email alerts on failure — zero dependencies
 Project-URL: Homepage, https://github.com/oliverm91/processes
 Project-URL: Documentation, https://oliverm91.github.io/processes/
@@ -14,13 +14,12 @@ Keywords: dag,dependencies,etl,parallel,process,tasks,topological-sort,workflow
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -29,7 +28,7 @@ Description-Content-Type: text/markdown
 
 # Processes: Smart Task Orchestration
 
-[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![Python Version](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
 ![Fast & Lightweight](https://img.shields.io/badge/Library-Pure%20Python-green.svg)
 [![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue.svg)](https://oliverm91.github.io/processes/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -41,7 +40,7 @@ Description-Content-Type: text/markdown
 
 ---
 
-**Run a list of Python callables that depend on each other — in parallel when possible, with per-task log files and optional HTML email notification on failure. Zero dependencies. Pure Python 3.10+.**
+**Run a list of Python callables that depend on each other — in parallel when possible, with per-task log files and optional HTML email notification on failure. Zero dependencies. Pure Python 3.11+.**
 
 ---
 
@@ -52,7 +51,7 @@ Description-Content-Type: text/markdown
 - 🛡️ **One failure doesn't stop the rest** — a failed task skips only the jobs that depend on it, and **every other part of the workflow keeps running**.
 - 📝 **One log file per task** — share a single log across the whole run, or keep them separate for easier debugging.
 - 📧 **Email alerts when something breaks** — pass an `SMTPConfig` to a task and get a styled HTML email (with traceback, task context, and the list of jobs that were skipped) the instant it raises.
-- 🧰 **Modern, strictly-typed Python 3.10+** — `from __future__ import annotations`, full `mypy --strict` clean, `dict[str, TaskResult]`, `set[str]`, `|` unions.
+- 🧰 **Modern, strictly-typed Python 3.11+** — `from __future__ import annotations`, full `mypy --strict` clean, `dict[str, TaskResult]`, `set[str]`, `|` unions.
 
 ---
 
@@ -62,7 +61,7 @@ A `Process` holds a list of `Task`s. At construction it validates names, types,
 
 When you call `process.run()`, tasks are topologically sorted and scheduled: dependencies first, independent tasks in parallel.
 
-A `TaskDependency` can forward an upstream result directly into a downstream function, as a positional or keyword argument. The result is a `ProcessResult` with `passed_tasks_results` and `failed_tasks` for inspection.
+A `TaskDependency` can forward an upstream result directly into a downstream function, as a positional or keyword argument. The result is a `ProcessExecutionReport` with `successes`, `errored`, and `skipped` for inspection.
 
 ---
 
@@ -83,11 +82,11 @@ def enrich(users: list[dict]) -> list[dict]:
 
 
 tasks = [
-    Task("load", "run.log", load_users),
+    Task("load", load_users, "run.log"),
     Task(
         "enrich",
-        "run.log",
         enrich,
+        "run.log",
         dependencies=[TaskDependency("load", use_result_as_additional_args=True)],
     ),
 ]
@@ -95,7 +94,7 @@ tasks = [
 with Process(tasks) as p:
     result = p.run(parallel=True)
 
-print(result.passed_tasks_results["enrich"].result)
+print(result.successes["enrich"].result)
 # [{'id': 1, 'name': 'user-1'}, {'id': 2, 'name': 'user-2'}, {'id': 3, 'name': 'user-3'}]
 ```
 
@@ -112,7 +111,7 @@ A realistic mini-pipeline: fetch two sources **in parallel**, transform them, ag
 import logging
 from pathlib import Path
 
-from processes import HTMLEmailStyle, Process, SMTPConfig, Task, TaskDependency
+from processes import EmailChannel, HTMLEmailStyle, Process, SMTPConfig, Task, TaskDependency
 
 LOG_DIR = Path("logs")
 LOG_DIR.mkdir(exist_ok=True)
@@ -169,19 +168,19 @@ smtp = SMTPConfig(
 )
 
 tasks = [
-    Task("fetch_orders",   LOG_DIR / "fetch_orders.log",   fetch_orders),
-    Task("fetch_inventory", LOG_DIR / "fetch_inventory.log", fetch_inventory),
+    Task("fetch_orders",   fetch_orders,   LOG_DIR / "fetch_orders.log"),
+    Task("fetch_inventory", fetch_inventory, LOG_DIR / "fetch_inventory.log"),
 
     Task(
         "compute_revenue",
-        LOG_DIR / "compute_revenue.log",
         total_revenue,
+        LOG_DIR / "compute_revenue.log",
         dependencies=[TaskDependency("fetch_orders", use_result_as_additional_args=True)],
     ),
     Task(
         "compute_stock",
-        LOG_DIR / "compute_stock.log",
         stock_value,
+        LOG_DIR / "compute_stock.log",
         kwargs={"price_per_unit": 7.25},
         dependencies=[
             TaskDependency(
@@ -194,8 +193,8 @@ tasks = [
 
     Task(
         "build_report",
-        LOG_DIR / "build_report.log",
         build_report,
+        LOG_DIR / "build_report.log",
         dependencies=[
             TaskDependency("compute_revenue", use_result_as_additional_kwargs=True,
                            additional_kwarg_name="revenue"),
@@ -210,31 +209,31 @@ tasks = [
     # the workflow is not blackholed by one broken step.
     Task(
         "notify_slack",
-        LOG_DIR / "notify_slack.log",
         notify_slack,
+        LOG_DIR / "notify_slack.log",
         dependencies=[TaskDependency("build_report", use_result_as_additional_args=True)],
-        smtp_config=smtp,
     ),
     Task(
         "archive_report",
-        LOG_DIR / "archive_report.log",
         archive_report,
+        LOG_DIR / "archive_report.log",
         dependencies=[TaskDependency("build_report", use_result_as_additional_args=True)],
     ),
 ]
 
 with Process(tasks) as process:
     result = process.run(parallel=True)
+    result.notify(EmailChannel(smtp), only_errors=True)  # one report email for the failed task(s)
 
-print("passed:", sorted(result.passed_tasks_results))
+print("passed:", sorted(result.successes))
 # archive_report, build_report, compute_revenue, compute_stock, fetch_inventory, fetch_orders
-print("failed:", sorted(result.failed_tasks))
+print("failed:", sorted(set(result.errored) | set(result.skipped)))
 # notify_slack
-print("report:", result.passed_tasks_results["build_report"].result)
+print("report:", result.successes["build_report"].result)
 # daily-report | revenue=59.50 stock=262.50
 ```
 
-The failing `notify_slack` task does **not** abort the run. `archive_report` is a sibling of the failed task (both depend on the successful `build_report`), so it runs unaffected — the rest of the workflow is not blackholed by one broken step. The HTML email handler also fires on the `notify_slack` task, paging on-call with the full traceback and the list of downstream tasks that were skipped because of it.
+The failing `notify_slack` task does **not** abort the run. `archive_report` is a sibling of the failed task (both depend on the successful `build_report`), so it runs unaffected — the rest of the workflow is not blackholed by one broken step. Calling `result.notify(EmailChannel(smtp), only_errors=True)` then delivers a single report email covering the failed task with its traceback and the downstream tasks that were skipped because of it.
 
 </details>
 
@@ -250,13 +249,12 @@ The failing `notify_slack` task does **not** abort the run. `archive_report` is
 ```python
 Task(
     name: str,
-    log_path: str | os.PathLike,
     func: Callable[..., Any],
+    log_path: str | None = None,
     args: tuple = (),
     kwargs: dict | None = None,
     dependencies: list[TaskDependency] | None = None,
-    smtp_config: SMTPConfig | None = None,
-    email_style: HTMLEmailStyle | None = None,
+    traced_vars_frame_filter: str | None = None,
     timeout: float | None = None,
     retries: int | None = 0,
     retry_on: tuple[type[Exception], ...] | None = None,
@@ -264,10 +262,9 @@ Task(
 ```
 
 - `name` — unique within the `Process`; no spaces.
-- `log_path` — the file this task logs to (INFO level, format `%(asctime)s - %(name)s - %(levelname)s - %(message)s`).
+- `log_path` — the file this task logs to (INFO level, format `%(asctime)s - %(name)s - %(levelname)s - %(message)s`), with the structured failure context appended on error. `None` (the default) means no file logging; a `NullHandler` is attached instead. A `Task` does not send notifications — error notification is delegated to `ProcessExecutionReport.notify`.
 - `func` — the callable; receives `func(*args, **kwargs)` after result-injection.
-- `smtp_config` — when set, fires an HTML email on `logging.ERROR`; body includes `task_name`, `function`, `args`, `kwargs`, and `downstream_impact`.
-- `email_style` — optional presentation override; defaults to `HTMLEmailStyle()` (modern, neutral, English) when `smtp_config` is set.
+- `traced_vars_frame_filter` — substring selecting which traceback frame's locals are captured into the failure context (and thus into both the logfile and any report notification). `None` (default) captures the outermost user frame.
 - `timeout` — seconds allowed per attempt; `None` means no limit. When the timeout fires the underlying thread is detached (Python threading limitation).
 - `retries` — additional attempts after the first failure; `0` or `None` means a single attempt. Defaults to `0`.
 - `retry_on` — tuple of exception types that trigger a retry. When `retries >= 1` and `retry_on` is `None`, defaults to `(ConnectionError, TimeoutError)` at call time.
@@ -292,24 +289,86 @@ TaskDependency(
 ```python
 Process(tasks: list[Task])  # validates types, names, deps, cycles
 
-process.run(parallel: bool | None = None, max_workers: int = 4) -> ProcessResult
+process.run(parallel: bool | None = None, max_workers: int = 4) -> ProcessExecutionReport
 ```
 
 - Raises `DependencyNotFoundError`, `CircularDependencyError`, `TypeError`, `ValueError` on construction if the workflow is malformed.
 - `parallel=None` auto-parallelises when `len(tasks) >= 10`; `max_workers=1` is always sequential.
 - Use as a context manager — it cleans up `FileHandler`s on exit.
 
-### `ProcessResult`
+### `TaskResult`
+
+```python
+TaskResult(
+    status: TaskStatus,
+    result: Any,
+    exception: Exception | None,
+    error_data: ErrorData | None = None,
+    elapsed_seconds: float = 0.0,  # wall-clock time across all attempts
+    attempts: int = 0,             # attempts actually executed (0 if never run)
+)
+```
+
+- `status` — `TaskStatus.PENDING | SUCCESS | ERRORED | SKIPPED`.
+- `worked` — `True` if `status == TaskStatus.SUCCESS`.
+
+### `ProcessExecutionReport`
+
+```python
+report.entries    # dict[str, TaskReportEntry] — one entry per task, in topological order
+report.successes  # dict[str, TaskReportEntry] — entries with status == TaskStatus.SUCCESS
+report.errored    # dict[str, TaskReportEntry] — entries with status == TaskStatus.ERRORED
+report.skipped    # dict[str, TaskReportEntry] — entries with status == TaskStatus.SKIPPED
+```
+
+A `TaskReportEntry` carries `name`, `function`, `args`, `kwargs`, `status`
+(`TaskStatus.SUCCESS | ERRORED | SKIPPED`), `elapsed_seconds`, `attempts`,
+plus `result` (set when `SUCCESS`) and `error: ErrorData | None` (set when
+`ERRORED`).
 
 ```python
-result.passed_tasks_results  # dict[str, TaskResult] — name → TaskResult for every task that succeeded
-result.failed_tasks          # set[str] — all tasks that did not produce a result (errored + skipped)
-result.errored_tasks         # set[str] — tasks whose function actually raised
-result.skipped_tasks         # set[str] — tasks skipped because an upstream dependency failed
+with Process([load_task, apply_task, notify_task]) as process:
+    report = process.run()
+
+for name, entry in report.entries.items():
+    if entry.status is TaskStatus.ERRORED:
+        print(f"{name} failed after {entry.attempts} attempt(s): {entry.error.exception}")
+```
 
-TaskResult(worked: bool, result: Any, exception: Exception | None)
+Deliver the report through one or more channels with `notify`:
+
+```python
+report.notify(
+    *channels: ReportChannel,
+    only_errors: bool = False,        # restrict the payload to ERRORED tasks
+    tasks: list[str] | None = None,   # restrict to these task names (case-insensitive)
+    show_warnings: bool = True,       # warn (not raise) if a channel fails
+)
 ```
 
+`only_errors` and `tasks` compose (both filters apply). A failing channel never
+aborts the others. Built-in channels: `EmailChannel` (HTML email) and
+`WebhookChannel` (JSON POST).
+
+### `ErrorData`
+
+```python
+ErrorData(
+    task_name: str,
+    function: str,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    downstream_impact: list[str],
+    exception: str,
+    traceback_str: str,
+    traced_vars: dict[str, str],
+    traced_vars_location: str,
+)
+```
+
+Structured failure context for a single task, available via
+`TaskResult.error_data` and `TaskReportEntry.error`.
+
 ### `SMTPConfig`
 
 ```python
@@ -327,14 +386,92 @@ SMTPConfig(
 
 ```python
 HTMLEmailStyle(
-    style="modern",                # classic | modern | compact
     palette="neutral",             # neutral | catppuccin | neobones | slate
     language="en",                 # en | es | pt | fr | de | it
-    traced_vars_frame_filter=None, # substring to pick the traced frame | None
 )
 ```
 
-All fields are optional — omit `HTMLEmailStyle` entirely to use the defaults.
+### `ReportContent`
+
+```python
+ReportContent(
+    show_traceback=True,    # include each failure's full traceback
+    show_traced_vars=True,  # include each failure's traced local variables
+)
+```
+
+Per-channel selection of how much per-task detail a report notification includes.
+Pass the same instance to several channels for uniform content, or give each its
+own.
+
+### `EmailChannel`
+
+```python
+EmailChannel(
+    smtp_config: SMTPConfig,
+    style: HTMLEmailStyle | None = None,    # defaults to HTMLEmailStyle()
+    content: ReportContent | None = None,   # defaults to ReportContent()
+)
+```
+
+A `ReportChannel` that delivers a finished report as a styled HTML email when
+passed to `report.notify(...)`. The body lists every task with its status and,
+for each failure, the exception, traceback, downstream impact, and traced
+variables (subject to `content`).
+
+#### Traced Variables
+
+On failure, each task captures the local variables of the **outermost user
+frame in the traceback** — i.e. the last frame that is not inside
+`site-packages` or your virtualenv — into both its logfile and the report email.
+A `file:line` reference next to the section shows exactly where those values
+were captured. Point this at a different frame per task with
+`Task(traced_vars_frame_filter=…)`.
+
+### `WebhookChannel`
+
+```python
+WebhookChannel(
+    webhook_config: WebhookConfig,
+    content: ReportContent | None = None,   # defaults to ReportContent()
+)
+```
+
+A `ReportChannel` that POSTs the finished report as JSON when passed to
+`report.notify(...)`.
+
+```python
+WebhookConfig(
+    url: str,
+    headers: dict[str, str] = {},  # merged with default Content-Type: application/json
+    timeout: int = 5,
+    secret: str | None = None,  # HMAC-SHA256 signs the body when set
+    extra_payload: dict[str, Any] = {},  # extra top-level keys merged into the JSON body
+    nest_under: str | None = None,  # nest the generic fields under this key, e.g. "data"
+)
+```
+
+Transport configuration for `WebhookChannel`. When the report is delivered,
+POSTs a generic JSON payload to `url` — an `entries` object mapping each task
+name to its `status`, `function`, `elapsed_seconds`, `attempts`, and (for
+failures) an `error` block with `exception`, `traceback`, `downstream_impact`,
+and `traced_vars` (subject to `ReportContent`). Not coupled to any specific
+service (Slack, Discord, etc.).
+
+`extra_payload` keys are merged into the JSON body and take precedence over
+the generic fields on collision — useful for service-specific routing data
+(e.g. a Telegram `chat_id` or a Slack `channel`/`username` override) without
+subclassing.
+
+`nest_under` nests the generic fields under a single key instead of leaving
+them top-level, e.g. `nest_under="data"` produces
+`{"data": {"task_name": ..., ...}, "chat_id": "..."}`. `extra_payload` keys
+always stay top-level and still take precedence on collision. `None`
+(the default) keeps the flat payload shape.
+
+If `secret` is set, the request carries an `X-Signature-SHA256` header with
+the hex-encoded `hmac.new(secret, body, hashlib.sha256)` digest of the JSON
+body, so receivers can verify the payload wasn't tampered with.
 
 </details>
 
@@ -343,10 +480,10 @@ All fields are optional — omit `HTMLEmailStyle` entirely to use the defaults.
 
 When a task raises:
 
-1. The exception is caught and stored in `TaskResult.exception`; the task name goes into `failed_tasks` and `errored_tasks`.
-2. **Every task that depends on it (directly or indirectly) is skipped** — added to `failed_tasks` and `skipped_tasks` without running.
+1. The exception is caught and stored in `TaskResult.exception`; the task's entry in the report gets `status == TaskStatus.ERRORED`.
+2. **Every task that depends on it (directly or indirectly) is skipped** — its entry gets `status == TaskStatus.SKIPPED` without running.
 3. **Every other independent part of the workflow keeps running.** With `parallel=True` they keep running concurrently on the worker pool.
-4. After `run()` returns, `ProcessResult.errored_tasks` and `ProcessResult.skipped_tasks` let you distinguish root failures from cascade skips for triage or alerting.
+4. After `run()` returns, `ProcessExecutionReport.errored` and `ProcessExecutionReport.skipped` let you distinguish root failures from cascade skips for triage or alerting.
 
 When a task has `retries >= 1`, a failure matching `retry_on` triggers another attempt before the task is declared failed and its dependants are skipped. This gives transient errors (network blips, connection resets) a chance to resolve without aborting downstream work.
 
@@ -355,19 +492,9 @@ This makes the library a good fit for fan-out / fan-in pipelines, "best-effort"
 </details>
 
 <details>
-<summary>Show comparison with other libraries</summary>
-
-| | **Processes** | Airflow | Celery | Luigi |
-|---|---|---|---|---|
-| External dependencies | **None** | many | broker (Redis/RabbitMQ) | few |
-| Setup cost | `pip install` | cluster | broker + workers | task + config |
-| Parallelism | built-in | via executors | via workers | via workers |
-| Per-task file logs | **yes (built-in)** | via handlers | via signals | partial |
-| HTML email on failure | **yes (built-in)** | via callbacks | via signals | manual |
-| DAG validation at construction | **yes** | yes (DAG file) | n/a | partial |
-| Strict typing (`mypy --strict`) | **yes** | partial | partial | no |
+<summary>Show scope &amp; limitations</summary>
 
-`Processes` is **not** a distributed scheduler — there are no workers on remote machines, no SLA monitoring, no web UI. If you need any of those, you need Airflow or a similar orchestrator. If you want a small, fast, dependency-aware pipeline that *just runs* in a single process, this is it.
+`Processes` is **not** a distributed scheduler — there are no workers on remote machines, no SLA monitoring, no web UI. If you need any of those, reach for a full orchestrator. If you want a small, fast, dependency-aware pipeline that *just runs* in a single process, this is it.
 
 </details>
 
@@ -376,7 +503,7 @@ This makes the library a good fit for fan-out / fan-in pipelines, "best-effort"
 
 - **Shared log file** — pass the same `log_path` to every `Task` for a single combined run.log; pass distinct paths for per-task isolation.
 - **Auto-parallel** — `Process.run()` with no argument runs sequentially for small workflows and switches to parallel for `len(tasks) >= 10`. Pass `parallel=True` or `parallel=False` to force the mode.
-- **Result inspection** — iterate `result.passed_tasks_results.items()` to log or post-process every successful task; iterate `result.failed_tasks` for triage.
+- **Result inspection** — iterate `report.successes.items()` to log or post-process every successful task; iterate `set(report.errored) | set(report.skipped)` for triage.
 - **Re-raising** — wrap `process.run()` in `try/except` if you need a non-zero exit code on any failure; the library itself does not raise on partial failure.
 
 </details>
@@ -397,7 +524,7 @@ Or straight from the repository (pure Python, no build step):
 pip install git+https://github.com/oliverm91/processes.git
 ```
 
-Requires **Python 3.10+**.
+Requires **Python 3.11+**.
 
 ---