diff --git a/README.md b/README.md
index 408cbf51..0231c082 100644
--- a/README.md
+++ b/README.md
@@ -1757,6 +1757,8 @@ Compose any of the flags above; the dispatcher applies impact selection → tag
 
 **Impact-based selection.** `--affected-by KIND:VALUE` (repeatable; `KIND` is `locator`, `url`, `template` or `command`; `@file` reads one per line) runs only the action files that use one of those names. `--changed-since REF` runs the action files `git diff REF...HEAD` changed, plus every file sharing a locator or template with them, so changing a setup file that saves `login_button` also runs the tests that use it (URLs and commands are not followed: almost every file shares them). Both can be combined; tags, `--rerun-failed` and `--shard` then apply to what they selected. `--impact-cache PATH` keeps the impact index between runs.
 
+`python -m je_web_runner` exits with status 1 when an action or a file of the run failed, after the rest has run, and prints `error: N action(s) or file(s) failed` on stderr. Under [TestPioneer](https://github.com/Integration-Automation/TestPioneer), which sets `TEST_PIONEER_ARTIFACT_DIR`, a report asked for under a relative name (JSON, XML, HTML, JUnit, Allure, interactive HTML, and `generate_all_reports`) is written below that directory.
+
 ## Test Record
 
 ```python
diff --git a/README/README_zh-CN.md b/README/README_zh-CN.md
index 42ebbad4..82444af7 100644
--- a/README/README_zh-CN.md
+++ b/README/README_zh-CN.md
@@ -1745,6 +1745,8 @@ python -m je_web_runner -d ./actions --changed-since origin/main --impact-cache
 
 **按影响范围挑选。** `--affected-by KIND:VALUE`（可重复；`KIND` 为 `locator`、`url`、`template` 或 `command`；`@文件` 每行读一个）只跑用到这些名称的动作文件。`--changed-since REF` 跑 `git diff REF...HEAD` 改到的动作文件，以及与它们共用 locator 或模板的文件，所以改了存放 `login_button` 的设置文件，用到它的测试也会跑（URL 与命令不追：几乎每个文件都共用）。两者可以并用；之后才应用 tag、`--rerun-failed` 与 `--shard`。`--impact-cache PATH` 在多次执行之间保留影响索引。
 
+`python -m je_web_runner` 在该次执行有动作或文件失败时，会在其余部分执行完之后以状态 1 结束，并在 stderr 打印 `error: N action(s) or file(s) failed`。由 [TestPioneer](https://github.com/Integration-Automation/TestPioneer) 启动时（它会设置 `TEST_PIONEER_ARTIFACT_DIR`），以相对名称要求的报告（JSON、XML、HTML、JUnit、Allure、交互式 HTML，以及 `generate_all_reports`）会写到该目录底下。
+
 ## 测试记录
 
 ```python
diff --git a/README/README_zh-TW.md b/README/README_zh-TW.md
index 1ad4a934..9e7bb652 100644
--- a/README/README_zh-TW.md
+++ b/README/README_zh-TW.md
@@ -1745,6 +1745,8 @@ python -m je_web_runner -d ./actions --changed-since origin/main --impact-cache
 
 **依影響範圍挑選。** `--affected-by KIND:VALUE`（可重複；`KIND` 為 `locator`、`url`、`template` 或 `command`；`@檔案` 每行讀一個）只跑用到這些名稱的動作檔。`--changed-since REF` 跑 `git diff REF...HEAD` 改到的動作檔，以及與它們共用 locator 或範本的檔案，所以改了存放 `login_button` 的設定檔，用到它的測試也會跑（URL 與命令不追：幾乎每個檔都共用）。兩者可以並用；之後才套用 tag、`--rerun-failed` 與 `--shard`。`--impact-cache PATH` 在多次執行之間保留影響索引。
 
+`python -m je_web_runner` 在該次執行有動作或檔案失敗時，會在其餘部分執行完之後以狀態 1 結束，並在 stderr 印出 `error: N action(s) or file(s) failed`。由 [TestPioneer](https://github.com/Integration-Automation/TestPioneer) 啟動時（它會設定 `TEST_PIONEER_ARTIFACT_DIR`），以相對名稱要求的報告（JSON、XML、HTML、JUnit、Allure、互動式 HTML，以及 `generate_all_reports`）會寫到該目錄底下。
+
 ## 測試記錄
 
 ```python
diff --git a/architecture.md b/architecture.md
index e742c2a5..66122f24 100644
--- a/architecture.md
+++ b/architecture.md
@@ -124,7 +124,7 @@ python -m je_web_runner -d DIR [--tag/--exclude-tag] [--rerun-failed LEDGER] [--
 | Jeffrey_RPA | `JeffreyRPA/webrunner_je_only.py` and `webrunner_novelai.py` insert a WebRunner working tree at `sys.path[0]`, so the **live working tree** is imported. The tree is `WEBRUNNER_PATH`, else `bot_config.json` `webrunner_path`, else the sibling `D:\Codes\WebRunner`, else the installed package (one rule, `JeffreyRPA/_webrunner_location.py`). Before importing it sets `WEBRUNNER_LOG_PATH` (if unset) to its own `webrunner.log`; `Jeffrey_RPA/requirements.txt` requires `je_web_runner>=0.0.88` because of the four wrapper methods listed here. | `TestObject`, `webdriver_wrapper_instance` and its methods `get_current_url`, `get_title`, `save_screenshot`, `add_script_to_evaluate_on_new_document`; for its je_web_runner variant, `set_driver(..., install_driver=False)` (start without webdriver-manager) and `executor.set_raise_wrapper_errors`; `test/test_je_facade.py` (in Jeffrey_RPA) imports `je_web_runner.webdriver.webdriver_wrapper` and checks `_webdriver_dict`. |
 | Jeffrey_RPA tests | `JeffreyRPA/conftest.py` hooks the import of `je_web_runner.utils.logging.loggin_instance` to park the log file outside the repo. | That exact, misspelled module path. **Do not rename it.** |
 | AutoControlGUI | Optional `utils/webrunner_bridge/bridge.py` (not a declared dependency; found with `importlib.util.find_spec`, imported lazily). | `je_web_runner.utils.executor.action_executor`: `execute_one` (one action through the gates, raising `WebRunnerExecuteException`), falling back to `executor.event_dict` on releases without it; `executor.event_dict` `WR_*` keys for listing; the commands `WR_get_webdriver_manager`, `WR_to_url`, `WR_quit`, `WR_save_screenshot`, `WR_get_current_url` (guarded by `test/unit_test/test_public_api.py`); `je_web_runner.utils.exception.exceptions.WebRunnerException` as the failure it wraps. |
-| TestPioneer | Declared dependency; `from je_web_runner import execute_action` in-process. | `execute_action`. |
+| TestPioneer | Declared dependency; `from je_web_runner import execute_action` in-process, and `parallel_run` spawns `python -m je_web_runner --execute_file <script>`. It sets `TEST_PIONEER_ARTIFACT_DIR` for both. | `execute_action`; the exit status of the CLI, 1 when an action or file failed (`utils/cli/failure_count.py`); the `<name>_success.json` / `<name>_failure.json` pair, written below the artifact directory for a relative name (`utils/generate_report/report_path.py`). |
 | PyBreeze | Subprocess `python -m je_web_runner --execute_str <json>` / `--execute_file <path>`, reading stdout. | Legacy CLI flags, Windows double-encoded `--execute_str`, results printed to stdout; guarded by `test/unit_test/test_legacy_cli_contract.py`. |
 
 **Outbound (required):** `je_action_core>=0.0.3` (PyPI), the executor core shared with APITestka, LoadDensity,
diff --git a/docs/source/Eng/doc/cli/cli_doc.rst b/docs/source/Eng/doc/cli/cli_doc.rst
index 46a27d13..b119b42f 100644
--- a/docs/source/Eng/doc/cli/cli_doc.rst
+++ b/docs/source/Eng/doc/cli/cli_doc.rst
@@ -76,3 +76,16 @@ Error Handling
 
 If no arguments are provided, WebRunner raises a ``WebRunnerExecuteException``.
 All errors are printed to stderr and the process exits with code 1.
+
+A failed action does not stop its list: the remaining actions run, and so do the remaining files of
+``-d``. Once everything has run, the process exits with code 1 and prints
+``error: N action(s) or file(s) failed`` when anything failed, and with code 0 otherwise.
+
+Running Under TestPioneer
+-------------------------
+
+TestPioneer starts a runner with ``TEST_PIONEER_ARTIFACT_DIR`` set to the directory that run's
+output belongs in. A report asked for under a relative name (JSON, XML, HTML, JUnit, Allure,
+interactive HTML, and ``generate_all_reports``) is then written below that directory, and the
+folders it needs are created. An absolute name, and a name that would leave the directory, are
+used as given. Without the variable nothing changes.
diff --git a/docs/source/Zh/doc/cli/cli_doc.rst b/docs/source/Zh/doc/cli/cli_doc.rst
index b33f8674..4f1b93e6 100644
--- a/docs/source/Zh/doc/cli/cli_doc.rst
+++ b/docs/source/Zh/doc/cli/cli_doc.rst
@@ -62,3 +62,14 @@ WebRunner 可以直接從命令列使用 ``je_web_runner`` 模組執行。安裝
 
 若未提供任何參數，WebRunner 會引發 ``WebRunnerExecuteException``。
 所有錯誤會輸出到 stderr，程序以代碼 1 退出。
+
+失敗的動作不會中止所在的清單：其餘動作會繼續執行，``-d`` 的其餘檔案也是。全部執行完之後，
+只要有任何失敗，程序就以代碼 1 退出並印出 ``error: N action(s) or file(s) failed``，否則以 0 退出。
+
+在 TestPioneer 之下執行
+-----------------------
+
+TestPioneer 啟動 runner 時會把 ``TEST_PIONEER_ARTIFACT_DIR`` 設為該次執行的輸出目錄。
+以相對名稱要求的報告（JSON、XML、HTML、JUnit、Allure、互動式 HTML，以及 ``generate_all_reports``）
+會寫到該目錄底下，所需的資料夾會自動建立。絕對路徑，以及會離開該目錄的名稱，則照原樣使用。
+沒有設定這個變數時，行為不變。
diff --git a/docs/updates/2026-10.md b/docs/updates/2026-10.md
index a4db34bf..517f5e59 100644
--- a/docs/updates/2026-10.md
+++ b/docs/updates/2026-10.md
@@ -615,3 +615,15 @@ Index and query commands: [README.md](README.md). New entries go at the end.
 - **Result / numbers**: built in a throwaway worktree with `build` 1.6.1 and `setuptools` 84.0.0 and no isolation: sdist and wheel build, `twine check` passes, the wheel has the 664 `je_web_runner` files.
 - **Files**: `.github/requirements/publish.in`, `.github/requirements/publish.txt`, `.github/workflows/publish_stable.yml`, `.github/workflows/test_dev.yml`, `test/unit_test/test_workflow_actions.py`, `test/unit_test/test_dev_release.py`, `architecture.md`.
 - **Open items**: none.
+
+## U-20261008-01 · 2026-10-08 · The CLI exits 1 when the run failed; reports go below TestPioneer's artifact directory · #feature #cli #report #testpioneer
+
+- **What**: two things TestPioneer needs from a runner (its `docs/artifacts.rst`, "Native Support").
+  - **Exit status**: `python -m je_web_runner` ended with status 0 whatever happened, because the executor records a failed action and runs the next one. `cli_main.main` now runs the dispatch inside `FailureCount` (`utils/cli/failure_count.py`), which wraps the executor's reporter and counts `on_failure`, and exits 1 with `error: N action(s) or file(s) failed`. The rest of the run still happens first. A file that failed where this process's executor cannot see it, in `--parallel-mode process` or `async`, is counted through `note_failed_file`. LoadDensity made the same change in its PR #118.
+  - **Report location**: with `TEST_PIONEER_ARTIFACT_DIR` set, a report asked for under a relative name is written below that directory (`utils/generate_report/report_path.py`): JSON, XML, HTML, JUnit, Allure, interactive HTML, and `generate_all_reports`, which resolves its base name once so its manifest lists the files where they are. An absolute name, a name that leaves the directory and a directory that cannot be created fall back to the name as given. Without the variable nothing changes.
+- **Effect on callers**: a script with a failing action ends with status 1 where it ended with 0. PyBreeze reads stdout and only displays the status. `execute_action` and what it returns are unchanged.
+- **Completion**: process workers count failed actions even when recording is disabled. Ledger and dependency execution use the current thread's failure count, avoiding failures from another concurrent file. Unreadable files are counted and remaining directory files still execute in sequential, thread, process and async modes. Invalid artifact paths fall back to the supplied name; the Allure directory is resolved before constructing the manifest.
+- **Tests**: `test/unit_test/test_failure_count.py`, `test/unit_test/test_report_path.py`, `test/unit_test/test_legacy_cli_contract.py` (including real process workers), and file-selection regression tests.
+- **Validation**: final Windows / Python 3.14 unit suite: 4868 passed, 5 skipped (63 subtests passed); integration suite: 43 passed, 19 skipped. A real TestPioneer workflow against this checkout ran a passing and a failing WebRunner in parallel, verified exit codes 0 / 1, generated JSON / XML / HTML / JUnit reports and their manifests under the supplied artifact directories, imported the cases, and ran the next workflow step. Six Grid e2e tests skipped because no Selenium Grid was available.
+- **Docs**: `README.md`, `README/README_zh-TW.md`, `README/README_zh-CN.md` (CLI Usage), `docs/source/Eng/doc/cli/cli_doc.rst` and its `Zh` counterpart, `architecture.md`.
+- **Files**: `je_web_runner/utils/cli/` (`failure_count.py` new, `cli_main.py`), `je_web_runner/utils/generate_report/` (`report_path.py` new; seven writers), the tests and docs above.
diff --git a/docs/updates/README.md b/docs/updates/README.md
index 7ed4b0ad..00864b63 100644
--- a/docs/updates/README.md
+++ b/docs/updates/README.md
@@ -58,6 +58,7 @@ In the same commit: delete the item from `progress.md`, add a `#done` entry here
 
 | ID | Date | Title | Tags | Batch |
 |---|---|---|---|---|
+| U-20261008-01 | 2026-10-08 | The CLI exits 1 when the run failed; reports go below TestPioneer's artifact directory | #feature #cli #report #testpioneer | [2026-10](2026-10.md) |
 | U-20261001-53 | 2026-10-01 | The publish jobs build with the locked setuptools instead of downloading the newest | #ci #security #X-13 | [2026-10](2026-10.md) |
 | U-20261001-52 | 2026-10-01 | Dependabot watches the hash-locked requirements; a guard keeps the publish jobs on them | #ci #security #X-13 | [2026-10](2026-10.md) |
 | U-20261001-51 | 2026-10-01 | The autocontrol extra asks for je_auto_control 0.0.225, the first release with AC_write_secret | #change #dependencies #autocontrol #X-27 | [2026-10](2026-10.md) |
@@ -142,5 +143,5 @@ In the same commit: delete the item from `progress.md`, add a `#done` entry here
 
 | File | Period | Entries |
 |---|---|---:|
-| [2026-10.md](2026-10.md) | 2026-10 | 53 |
+| [2026-10.md](2026-10.md) | 2026-10 | 54 |
 | [2026-09.md](2026-09.md) | 2026-09 | 25 |
diff --git a/je_web_runner/utils/cli/cli_main.py b/je_web_runner/utils/cli/cli_main.py
index a225f290..8d7ca029 100644
--- a/je_web_runner/utils/cli/cli_main.py
+++ b/je_web_runner/utils/cli/cli_main.py
@@ -12,6 +12,7 @@
 from pathlib import Path
 from typing import Sequence
 
+from je_web_runner.utils.cli.failure_count import FailureCount, note_failed_file, thread_failure_count
 from je_web_runner.utils.exception.exception_tags import argparse_get_wrong_data
 from je_web_runner.utils.exception.exceptions import WebRunnerExecuteException
 from je_web_runner.utils.executor.action_executor import execute_action, execute_files
@@ -179,11 +180,15 @@ def _run_one_file(path: str) -> bool:
     """Execute one file; return True if no failures were recorded."""
     failure_marker = "program_exception"
     baseline = len(test_record_instance.test_record_list)
+    failure_baseline = thread_failure_count()
     failed = False
     try:
         execute_action(read_action_json(path))
     except Exception:
         failed = True
+        note_failed_file()
+    if failure_baseline is not None:
+        return not failed and thread_failure_count() == failure_baseline
     new_records = test_record_instance.test_record_list[baseline:]
     if any(record.get(failure_marker, "None") != "None" for record in new_records):
         failed = True
@@ -209,7 +214,9 @@ def _run_one_file_isolated(path: str) -> tuple[str, bool, list]:
     baseline = len(_records.test_record_list)
     failed = False
     try:
-        _execute(_read_json(path))
+        with FailureCount() as failures:
+            _execute(_read_json(path))
+        failed = bool(failures.failed)
     except Exception:  # pylint: disable=broad-except
         # Failure path — the tuple we return signals it to the parent.
         failed = True
@@ -224,7 +231,7 @@ def _run_with_dependencies(
     ledger_path: str | None,
 ) -> None:
     """Run files in topological order, skipping downstream when upstream fails."""
-    graph = build_dependency_graph(files)
+    graph = build_dependency_graph(files, allow_invalid=True)
     ordered = topological_order(graph)
     failed_set: set = set()
     for path in ordered:
@@ -278,7 +285,12 @@ def _select_files(directory: str, selection: FileSelection) -> list:
 def _run_sequential(files, ledger_path: str | None) -> None:
     """Sequential execution with optional ledger recording."""
     if not ledger_path:
-        execute_files(files)
+        for path in files:
+            try:
+                execute_files([path])
+            except Exception as error:
+                web_runner_logger.error(f"execute_file, path: {path}, failed: {error!r}")
+                note_failed_file()
         return
     for path in files:
         passed = _run_one_file(path)
@@ -290,6 +302,8 @@ def _run_with_process_pool(files, parallel: int, ledger_path: str | None) -> Non
     with ProcessPoolExecutor(max_workers=parallel) as pool:
         for path, passed, records in pool.map(_run_one_file_isolated, files):
             test_record_instance.test_record_list.extend(records)
+            if not passed:
+                note_failed_file()
             if ledger_path:
                 record_run(ledger_path, path, passed=passed)
 
@@ -297,11 +311,28 @@ def _run_with_process_pool(files, parallel: int, ledger_path: str | None) -> Non
 def _run_with_asyncio(files, parallel: int, ledger_path: str | None) -> None:
     """asyncio branch: one browser, one context per file, at most ``parallel`` files at a time."""
     from je_web_runner.utils.async_executor.executor import run_action_lists
-    results = run_action_lists([read_action_json(path) for path in files], concurrency=max(1, parallel))
-    for path, (record, failed) in zip(files, results):
+    loaded_files = []
+    action_lists = []
+    for path in files:
+        try:
+            actions = read_action_json(path)
+        except Exception as error:
+            web_runner_logger.error(f"execute_file, path: {path}, failed: {error!r}")
+            note_failed_file()
+            if ledger_path:
+                record_run(ledger_path, path, passed=False)
+            continue
+        loaded_files.append(path)
+        action_lists.append(actions)
+    if not loaded_files:
+        return
+    results = run_action_lists(action_lists, concurrency=max(1, parallel))
+    for path, (record, failed) in zip(loaded_files, results):
         for key, value in record.items():
             print(key)
             print(value)
+        if failed:
+            note_failed_file()
         if ledger_path:
             record_run(ledger_path, path, passed=not failed)
 
@@ -330,7 +361,7 @@ def _run_dir(
     parallel_mode: str = "thread",
 ) -> None:
     files = _select_files(directory, selection)
-    if any(build_dependency_graph(files).get(path) for path in files):
+    if any(build_dependency_graph(files, allow_invalid=True).values()):
         _run_with_dependencies(files, ledger_path)
         return
     if parallel_mode == "async":
@@ -440,5 +471,10 @@ def main(argv: Sequence[str] | None = None) -> int:
     args = parser.parse_args(argv)
     if not _has_any_action(args):
         raise WebRunnerExecuteException(argparse_get_wrong_data)
-    _dispatch(args)
+    # A failed action does not stop its list, so the run is judged once everything has run.
+    with FailureCount() as failures:
+        _dispatch(args)
+    if failures.failed:
+        print(f"error: {failures.failed} action(s) or file(s) failed", file=sys.stderr)
+        return 1
     return 0
diff --git a/je_web_runner/utils/cli/failure_count.py b/je_web_runner/utils/cli/failure_count.py
new file mode 100644
index 00000000..4598b8ca
--- /dev/null
+++ b/je_web_runner/utils/cli/failure_count.py
@@ -0,0 +1,106 @@
+"""
+計算一次 CLI 執行中失敗了多少
+Count what fails during one CLI run, for the exit status.
+
+The executor records a failed action and runs the next one, so ``execute_action`` returns the
+same way whether the run passed or not. :class:`FailureCount` wraps the executor's reporter for
+the length of a ``with`` block and counts the actions that raised. Files run in another process
+or on the asyncio executor never reach this process's reporter; their runner reports them with
+:func:`note_failed_file`.
+"""
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import replace
+from threading import Lock, local
+from types import TracebackType
+from typing import Any
+
+from je_action_core import ExecutionReporter
+
+from je_web_runner.utils.executor.action_executor import executor
+
+
+class _CountingReporter(ExecutionReporter):
+    """Passes every event on to the executor's own reporter and counts the actions that raised."""
+
+    def __init__(self, delegate: ExecutionReporter) -> None:
+        self._delegate = delegate
+        self._lock = Lock()
+        self._thread = local()
+        self.raised = 0
+
+    def add(self, count: int = 1) -> None:
+        """Count ``count`` more failures (thread-safe: ``--parallel-mode=thread`` runs files on threads)."""
+        with self._lock:
+            self.raised += count
+        self._thread.raised = self.thread_failed + count
+
+    @property
+    def thread_failed(self) -> int:
+        """Failures seen on this worker thread, independent of other files."""
+        return getattr(self._thread, "raised", 0)
+
+    def on_start(self, action_list: Any) -> None:
+        self._delegate.on_start(action_list)
+
+    def on_event(self, action: Any) -> None:
+        self._delegate.on_event(action)
+
+    def on_success(self, action: Any) -> None:
+        self._delegate.on_success(action)
+
+    def on_failure(self, action: Any, error: Exception) -> None:
+        self.add()
+        self._delegate.on_failure(action, error)
+
+    def on_empty(self, action_list: Any) -> None:
+        self._delegate.on_empty(action_list)
+
+    def on_records(self, records: Mapping[str, Any]) -> None:
+        self._delegate.on_records(records)
+
+
+class FailureCount:
+    """Counts what fails while its ``with`` block runs; ``failed`` is the total."""
+
+    _active: FailureCount | None = None
+
+    def __init__(self) -> None:
+        self._settings = executor.settings
+        self._reporter = _CountingReporter(self._settings.reporter)
+        self._outer: FailureCount | None = None
+
+    def __enter__(self) -> FailureCount:
+        self._settings = executor.settings
+        self._reporter = _CountingReporter(self._settings.reporter)
+        executor.settings = replace(self._settings, reporter=self._reporter)
+        self._outer = FailureCount._active
+        FailureCount._active = self
+        return self
+
+    def __exit__(self, kind: type[BaseException] | None, error: BaseException | None,
+                 trace: TracebackType | None) -> None:
+        executor.settings = self._settings
+        FailureCount._active = self._outer
+
+    @property
+    def failed(self) -> int:
+        """How many actions raised, and files were reported as failed, since the block was entered."""
+        return self._reporter.raised
+
+    def _note(self) -> None:
+        self._reporter.add()
+
+
+def note_failed_file() -> None:
+    """Count a file that failed where this process's executor could not see it; a no-op outside a count."""
+    active = FailureCount._active  # pylint: disable=protected-access
+    if active is not None:
+        active._note()  # pylint: disable=protected-access
+
+
+def thread_failure_count() -> int | None:
+    """Return this thread's count during CLI dispatch, or None outside it."""
+    active = FailureCount._active  # pylint: disable=protected-access
+    return active._reporter.thread_failed if active is not None else None  # pylint: disable=protected-access
diff --git a/je_web_runner/utils/generate_report/generate_allure_report.py b/je_web_runner/utils/generate_report/generate_allure_report.py
index 0b0b443e..f9b7cbe4 100644
--- a/je_web_runner/utils/generate_report/generate_allure_report.py
+++ b/je_web_runner/utils/generate_report/generate_allure_report.py
@@ -21,6 +21,7 @@
 
 from je_web_runner.utils.exception.exception_tags import cant_generate_json_report
 from je_web_runner.utils.exception.exceptions import WebRunnerGenerateJsonReportException
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 from je_web_runner.utils.test_record.test_record_class import test_record_instance
 
@@ -105,7 +106,7 @@ def generate_allure_report(output_dir: str = "allure-results") -> list[str]:
     """
     web_runner_logger.info(f"generate_allure_report: {output_dir}")
     cases = generate_allure()
-    target_dir = Path(output_dir)
+    target_dir = Path(report_path(output_dir))
     target_dir.mkdir(parents=True, exist_ok=True)
     written: list[str] = []
     for case in cases:
diff --git a/je_web_runner/utils/generate_report/generate_html_report.py b/je_web_runner/utils/generate_report/generate_html_report.py
index 06602d3d..a89ff7f7 100644
--- a/je_web_runner/utils/generate_report/generate_html_report.py
+++ b/je_web_runner/utils/generate_report/generate_html_report.py
@@ -3,6 +3,7 @@
 
 from je_web_runner.utils.exception.exception_tags import html_generate_no_data_tag
 from je_web_runner.utils.exception.exceptions import WebRunnerHTMLException
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 from je_web_runner.utils.test_record.test_record_class import test_record_instance
 
@@ -173,7 +174,7 @@ def generate_html_report(html_name: str = "default_name"):
     new_html_string = generate_html()
     try:
         # ``_lock`` serialises concurrent writers; ``with`` guarantees release.
-        with _lock, open(html_name + ".html", "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
+        with _lock, open(report_path(html_name + ".html"), "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
             file_to_write.write(new_html_string)
     except OSError as error:
         web_runner_logger.error(f"generate_html_report write failed: {error!r}")
\ No newline at end of file
diff --git a/je_web_runner/utils/generate_report/generate_json_report.py b/je_web_runner/utils/generate_report/generate_json_report.py
index a8fcf80c..8b683bd1 100644
--- a/je_web_runner/utils/generate_report/generate_json_report.py
+++ b/je_web_runner/utils/generate_report/generate_json_report.py
@@ -3,6 +3,7 @@
 
 from je_web_runner.utils.exception.exception_tags import cant_generate_json_report
 from je_web_runner.utils.exception.exceptions import WebRunnerGenerateJsonReportException
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 from je_web_runner.utils.test_record.test_record_class import test_record_instance
 
@@ -85,7 +86,7 @@ def generate_json_report(json_file_name: str = "default_name"):
     # 輸出成功紀錄
     # Write success records
     try:
-        with _lock, open(json_file_name + "_success.json", "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
+        with _lock, open(report_path(json_file_name + "_success.json"), "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
             json.dump(dict(success_dict), file_to_write, indent=4)
     except (OSError, TypeError, ValueError) as error:
         web_runner_logger.error(f"generate_json_report, json_file_name: {json_file_name}, failed: {error!r}")
@@ -93,7 +94,7 @@ def generate_json_report(json_file_name: str = "default_name"):
     # 輸出失敗紀錄
     # Write failure records
     try:
-        with _lock, open(json_file_name + "_failure.json", "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
+        with _lock, open(report_path(json_file_name + "_failure.json"), "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
             json.dump(dict(failure_dict), file_to_write, indent=4)
     except (OSError, TypeError, ValueError) as error:
         web_runner_logger.error(f"generate_json_report, json_file_name: {json_file_name}, failed: {error!r}")
\ No newline at end of file
diff --git a/je_web_runner/utils/generate_report/generate_junit_xml_report.py b/je_web_runner/utils/generate_report/generate_junit_xml_report.py
index a5c06aca..05d97541 100644
--- a/je_web_runner/utils/generate_report/generate_junit_xml_report.py
+++ b/je_web_runner/utils/generate_report/generate_junit_xml_report.py
@@ -8,6 +8,7 @@
 
 from je_web_runner.utils.exception.exception_tags import cant_generate_json_report
 from je_web_runner.utils.exception.exceptions import WebRunnerGenerateJsonReportException
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 from je_web_runner.utils.test_record.test_record_class import test_record_instance
 
@@ -91,7 +92,7 @@ def generate_junit_xml_report(junit_file_name: str = "default_name") -> None:
     web_runner_logger.info(f"generate_junit_xml_report, junit_file_name: {junit_file_name}")
 
     junit_xml = generate_junit_xml()
-    target = junit_file_name + "_junit.xml"
+    target = report_path(junit_file_name + "_junit.xml")
     try:
         with _lock, open(target, "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
             file_to_write.write('<?xml version="1.0" encoding="UTF-8"?>\n')
diff --git a/je_web_runner/utils/generate_report/generate_xml_report.py b/je_web_runner/utils/generate_report/generate_xml_report.py
index 32f0d68f..6742c0e8 100644
--- a/je_web_runner/utils/generate_report/generate_xml_report.py
+++ b/je_web_runner/utils/generate_report/generate_xml_report.py
@@ -3,6 +3,7 @@
 from defusedxml.minidom import parseString
 
 from je_web_runner.utils.generate_report.generate_json_report import generate_json
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 from je_web_runner.utils.xml.change_xml_structure.change_xml_structure import dict_to_elements_tree
 
@@ -59,7 +60,7 @@ def generate_xml_report(xml_file_name: str = "default_name"):
     # 輸出失敗報告
     # Write failure report
     try:
-        with _lock, open(xml_file_name + "_failure.xml", "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
+        with _lock, open(report_path(xml_file_name + "_failure.xml"), "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
             file_to_write.write(failure_xml)
     except OSError as error:
         web_runner_logger.error(f"generate_xml_report, xml_file_name: {xml_file_name}, failed: {error!r}")
@@ -67,7 +68,7 @@ def generate_xml_report(xml_file_name: str = "default_name"):
     # 輸出成功報告
     # Write success report
     try:
-        with _lock, open(xml_file_name + "_success.xml", "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
+        with _lock, open(report_path(xml_file_name + "_success.xml"), "w", encoding="utf-8") as file_to_write:  # NOSONAR S8707 — developer-supplied path (own report/config file), not untrusted input
             file_to_write.write(success_xml)
     except OSError as error:
         web_runner_logger.error(f"generate_xml_report, xml_file_name: {xml_file_name}, failed: {error!r}")
\ No newline at end of file
diff --git a/je_web_runner/utils/generate_report/interactive_html_report.py b/je_web_runner/utils/generate_report/interactive_html_report.py
index 76cb271b..714c4382 100644
--- a/je_web_runner/utils/generate_report/interactive_html_report.py
+++ b/je_web_runner/utils/generate_report/interactive_html_report.py
@@ -28,6 +28,7 @@
 from typing import Any
 
 from je_web_runner.utils.exception.exceptions import WebRunnerHTMLException
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 from je_web_runner.utils.test_record.test_record_class import test_record_instance
 
@@ -218,7 +219,7 @@ def generate_interactive_html_report(html_name: str = "default_name", screenshot
     Write :func:`generate_interactive_html` to ``<html_name>.html`` and return that path.
     """
     web_runner_logger.info(f"generate_interactive_html_report, html_name: {html_name}")
-    target = Path(f"{html_name}.html")
+    target = Path(report_path(f"{html_name}.html"))
     target.parent.mkdir(parents=True, exist_ok=True)
     target.write_text(generate_interactive_html(screenshot_dir, har_path, a11y_results), encoding="utf-8")
     return str(target)
diff --git a/je_web_runner/utils/generate_report/report_manifest.py b/je_web_runner/utils/generate_report/report_manifest.py
index 1ea77ee8..75c96209 100644
--- a/je_web_runner/utils/generate_report/report_manifest.py
+++ b/je_web_runner/utils/generate_report/report_manifest.py
@@ -26,6 +26,7 @@
 from je_web_runner.utils.generate_report.generate_json_report import generate_json_report
 from je_web_runner.utils.generate_report.generate_junit_xml_report import generate_junit_xml_report
 from je_web_runner.utils.generate_report.generate_xml_report import generate_xml_report
+from je_web_runner.utils.generate_report.report_path import report_path
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
 
 
@@ -74,6 +75,9 @@ def generate_all_reports(
              ``manifest_path``（manifest 檔位置或 None）
     """
     web_runner_logger.info(f"generate_all_reports base={base_name}")
+    # Resolved once, so the generators, the expected paths and the manifest agree on where the files are.
+    base_name = report_path(base_name)
+    allure_dir = report_path(allure_dir) if allure_dir else None
     plan = expected_paths(base_name, allure_dir=allure_dir)
     errors: dict[str, str] = {}
 
diff --git a/je_web_runner/utils/generate_report/report_path.py b/je_web_runner/utils/generate_report/report_path.py
new file mode 100644
index 00000000..58f57d63
--- /dev/null
+++ b/je_web_runner/utils/generate_report/report_path.py
@@ -0,0 +1,43 @@
+"""
+報告檔案寫到哪裡
+Where a report file is written.
+
+TestPioneer starts a runner with ``TEST_PIONEER_ARTIFACT_DIR`` set to the directory that run's
+output belongs in. A report asked for under a relative name goes there, so the workflow does
+not have to say which files to collect. Outside TestPioneer nothing changes.
+"""
+import os
+from pathlib import Path
+
+from je_web_runner.utils.logging.loggin_instance import web_runner_logger
+
+# Set by TestPioneer for every runner it starts, in a child process and in-process alike.
+ARTIFACT_DIR_VARIABLE: str = "TEST_PIONEER_ARTIFACT_DIR"
+
+
+def report_path(name: str) -> str:
+    """
+    回傳報告實際寫入的路徑
+    Return where the report called ``name`` is written.
+
+    With ``TEST_PIONEER_ARTIFACT_DIR`` set, a relative ``name`` is placed below that directory
+    and the folders it needs are created. ``name`` is returned as given when the variable is
+    not set, when ``name`` is absolute, when it would leave the directory (``../x``), and when
+    the folders cannot be created.
+
+    :param name: 報告檔名或路徑 / the report's file name or path, as the caller gave it
+    :return: 寫入路徑 / the path to write to
+    """
+    directory = os.environ.get(ARTIFACT_DIR_VARIABLE, "").strip()
+    if not directory or Path(name).is_absolute():
+        return name
+    try:
+        base = Path(directory).resolve()
+        target = (base / name).resolve()
+        if base not in target.parents:
+            return name
+        target.parent.mkdir(parents=True, exist_ok=True)
+    except (OSError, ValueError, RuntimeError) as error:
+        web_runner_logger.error(f"report_path, name: {name}, the artifact directory is not usable: {error!r}")
+        return name
+    return str(target)
diff --git a/je_web_runner/utils/test_filter/dependency.py b/je_web_runner/utils/test_filter/dependency.py
index 947514bb..37dac8f2 100644
--- a/je_web_runner/utils/test_filter/dependency.py
+++ b/je_web_runner/utils/test_filter/dependency.py
@@ -12,7 +12,7 @@
 
 from je_web_runner.utils.exception.exceptions import WebRunnerException
 from je_web_runner.utils.logging.loggin_instance import web_runner_logger
-from je_web_runner.utils.test_filter.tag_filter import read_metadata
+from je_web_runner.utils.test_filter.tag_filter import TagFilterError, read_metadata
 
 
 class DependencyError(WebRunnerException):
@@ -30,7 +30,7 @@ def read_depends_on(path: str) -> list[str]:
     return [str(dep) for dep in deps if isinstance(dep, str)]
 
 
-def build_dependency_graph(paths: Sequence[str]) -> dict[str, list[str]]:
+def build_dependency_graph(paths: Sequence[str], *, allow_invalid: bool = False) -> dict[str, list[str]]:
     """
     依基本檔名建立 ``{path: [dep_path, ...]}`` 圖
     Build a ``{path: [dep_path, …]}`` graph by matching ``depends_on`` entries
@@ -38,11 +38,20 @@ def build_dependency_graph(paths: Sequence[str]) -> dict[str, list[str]]:
 
     無法對應到 ``paths`` 中任何檔案的依賴會被忽略並寫入 log（避免阻擋執行）。
     Dependencies that do not match any input path are dropped with a warning.
+
+    With ``allow_invalid``, an unreadable file remains a node with no declared dependencies
+    so the CLI can record its execution failure and continue the other files.
     """
     by_stem: dict[str, str] = {_basename_key(path): path for path in paths}
     graph: dict[str, list[str]] = {path: [] for path in paths}
     for path in paths:
-        for dep_name in read_depends_on(path):
+        try:
+            dependencies = read_depends_on(path)
+        except (TagFilterError, OSError):
+            if not allow_invalid:
+                raise
+            dependencies = []
+        for dep_name in dependencies:
             dep_path = by_stem.get(dep_name)
             if dep_path is None:
                 web_runner_logger.warning(
diff --git a/test/unit_test/test_cli_file_selection.py b/test/unit_test/test_cli_file_selection.py
index f434edef..15b8044a 100644
--- a/test/unit_test/test_cli_file_selection.py
+++ b/test/unit_test/test_cli_file_selection.py
@@ -30,7 +30,7 @@ def setUp(self):
     def _ran(self, *flags) -> list:
         with patch("je_web_runner.utils.cli.cli_main.execute_files") as run:
             main(["-d", self.dir, *flags])
-        return sorted(run.call_args.args[0]) if run.called else []
+        return sorted(path for call in run.call_args_list for path in call.args[0])
 
     def test_everything_without_filters(self):
         self.assertEqual(self._ran(), sorted([self.smoke, self.slow, self.plain]))
diff --git a/test/unit_test/test_failure_count.py b/test/unit_test/test_failure_count.py
new file mode 100644
index 00000000..c93411a2
--- /dev/null
+++ b/test/unit_test/test_failure_count.py
@@ -0,0 +1,175 @@
+"""The CLI's exit status: a run in which an action or a file failed returns 1."""
+import json
+
+import pytest
+
+from je_web_runner.utils.cli import cli_main
+from je_web_runner.utils.cli.failure_count import FailureCount, note_failed_file
+from je_web_runner.utils.executor.action_executor import execute_action, executor
+
+# No command has this name, so binding the action raises.
+RAISES = ["WR_no_such_command"]
+PASSES = ["print", ["failure-count-test"]]
+
+
+def _write(path, actions) -> str:
+    path.write_text(json.dumps(actions), encoding="utf-8")
+    return str(path)
+
+
+def test_an_action_that_raises_is_counted():
+    with FailureCount() as count:
+        execute_action([RAISES, PASSES, RAISES])
+    assert count.failed == 2  # nosec B101
+
+
+def test_nothing_failed_is_zero():
+    with FailureCount() as count:
+        execute_action([PASSES])
+    assert count.failed == 0  # nosec B101
+
+
+def test_a_file_reported_as_failed_is_counted():
+    with FailureCount() as count:
+        note_failed_file()
+    assert count.failed == 1  # nosec B101
+
+
+def test_a_failed_file_outside_a_count_is_ignored():
+    note_failed_file()
+    with FailureCount() as count:
+        pass
+    assert count.failed == 0  # nosec B101
+
+
+def test_the_executor_gets_its_reporter_back():
+    reporter = executor.settings.reporter
+    with FailureCount():
+        assert executor.settings.reporter is not reporter  # nosec B101
+    assert executor.settings.reporter is reporter  # nosec B101
+
+
+def test_the_reporter_comes_back_when_the_block_raises():
+    reporter = executor.settings.reporter
+    with pytest.raises(RuntimeError), FailureCount():
+        raise RuntimeError("stopped")
+    assert executor.settings.reporter is reporter  # nosec B101
+
+
+def test_main_returns_1_when_an_action_failed(tmp_path, capsys):
+    assert cli_main.main(["-e", _write(tmp_path / "bad.json", [RAISES, PASSES])]) == 1  # nosec B101
+    captured = capsys.readouterr()
+    assert "error: 1 action(s) or file(s) failed" in captured.err  # nosec B101
+    assert "failure-count-test" in captured.out  # nosec B101
+
+
+def test_main_returns_0_when_every_action_passed(tmp_path):
+    assert cli_main.main(["-e", _write(tmp_path / "ok.json", [PASSES])]) == 0  # nosec B101
+
+
+def test_main_counts_every_file_of_a_directory(tmp_path, capsys):
+    _write(tmp_path / "a_ok.json", [PASSES])
+    _write(tmp_path / "b_bad.json", [RAISES])
+    _write(tmp_path / "c_bad.json", [RAISES])
+    assert cli_main.main(["-d", str(tmp_path)]) == 1  # nosec B101
+    assert "error: 2 action(s) or file(s) failed" in capsys.readouterr().err  # nosec B101
+
+
+def test_a_file_that_failed_in_another_process_fails_the_run(tmp_path, monkeypatch):
+    # The process pool is replaced: what matters is that a file reported as not passed is counted.
+    class _Pool:
+        def __init__(self, max_workers):
+            self.max_workers = max_workers
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *_details):
+            return False
+
+        @staticmethod
+        def map(_function, files):
+            return [(path, False, []) for path in files]
+
+    monkeypatch.setattr(cli_main, "ProcessPoolExecutor", _Pool)
+    _write(tmp_path / "a.json", [PASSES])
+    _write(tmp_path / "b.json", [PASSES])
+    assert cli_main.main(["-d", str(tmp_path), "--parallel", "2", "--parallel-mode", "process"]) == 1  # nosec B101
+
+
+def test_async_failed_files_are_counted_once(tmp_path, monkeypatch, capsys):
+    from je_web_runner.utils.async_executor import executor as async_executor
+
+    _write(tmp_path / "a.json", [PASSES])
+    _write(tmp_path / "b.json", [PASSES])
+    monkeypatch.setattr(async_executor, "run_action_lists", lambda *args, **kwargs: [
+        ({"first": "failed", "second": "failed"}, ["first", "second"]),
+        ({"third": "passed"}, []),
+    ])
+    assert cli_main.main(["-d", str(tmp_path), "--parallel-mode", "async"]) == 1  # nosec B101
+    assert "error: 1 action(s) or file(s) failed" in capsys.readouterr().err  # nosec B101
+
+
+def test_thread_failures_are_counted(tmp_path, capsys):
+    for index in range(8):
+        _write(tmp_path / f"{index}.json", [RAISES, PASSES])
+    assert cli_main.main(["-d", str(tmp_path), "--parallel", "4"]) == 1  # nosec B101
+    captured = capsys.readouterr()
+    assert "error: 8 action(s) or file(s) failed" in captured.err  # nosec B101
+    assert captured.out.count("failure-count-test") >= 8  # nosec B101
+
+
+@pytest.mark.parametrize("flags", [[], ["--ledger"], ["--parallel", "2"]], ids=["sequential", "ledger", "thread"])
+def test_unreadable_file_fails_run_and_remaining_files_run(tmp_path, capsys, flags):
+    actions = tmp_path / "actions"
+    actions.mkdir()
+    (actions / "a_bad.json").write_text("{invalid", encoding="utf-8")
+    _write(actions / "b_ok.json", [PASSES])
+    if flags == ["--ledger"]:
+        flags = [*flags, str(tmp_path / "ledger.json")]
+    assert cli_main.main(["-d", str(actions), *flags]) == 1  # nosec B101
+    captured = capsys.readouterr()
+    assert "error: 1 action(s) or file(s) failed" in captured.err  # nosec B101
+    assert "failure-count-test" in captured.out  # nosec B101
+
+
+def test_ledger_detects_failed_actions_without_recording(tmp_path, monkeypatch):
+    from je_web_runner.utils.run_ledger.ledger import latest_status
+    from je_web_runner.utils.test_record.test_record_class import test_record_instance
+
+    monkeypatch.setattr(test_record_instance, "init_record", False)
+    actions = tmp_path / "actions"
+    actions.mkdir()
+    bad = _write(actions / "bad.json", [RAISES])
+    good = _write(actions / "good.json", [PASSES])
+    ledger = str(tmp_path / "ledger.json")
+    assert cli_main.main(["-d", str(actions), "--ledger", ledger]) == 1  # nosec B101
+    assert latest_status(ledger) == {bad: False, good: True}  # nosec B101
+
+
+def test_dependency_failure_skips_downstream_without_recording(tmp_path, monkeypatch, capsys):
+    from je_web_runner.utils.test_record.test_record_class import test_record_instance
+
+    monkeypatch.setattr(test_record_instance, "init_record", False)
+    _write(tmp_path / "upstream.json", [RAISES])
+    _write(tmp_path / "downstream.json", {
+        "meta": {"depends_on": ["upstream"]},
+        "webdriver_wrapper": [["print", ["must-not-run-downstream"]]],
+    })
+    assert cli_main.main(["-d", str(tmp_path)]) == 1  # nosec B101
+    assert "must-not-run-downstream" not in capsys.readouterr().out  # nosec B101
+
+
+def test_async_unreadable_file_does_not_stop_other_files(tmp_path, monkeypatch, capsys):
+    from je_web_runner.utils.async_executor import executor as async_executor
+
+    (tmp_path / "a_bad.json").write_text("{invalid", encoding="utf-8")
+    _write(tmp_path / "b_good.json", [PASSES])
+    def run_loaded(actions, **kwargs):
+        assert actions == [[PASSES]]  # nosec B101
+        return [({"passed": "async-continued"}, [])]
+    monkeypatch.setattr(async_executor, "run_action_lists", run_loaded)
+    assert cli_main.main(["-d", str(tmp_path), "--parallel-mode", "async"]) == 1  # nosec B101
+    captured = capsys.readouterr()
+    assert "async-continued" in captured.out  # nosec B101
+    assert "error: 1 action(s) or file(s) failed" in captured.err  # nosec B101
diff --git a/test/unit_test/test_impact_selection.py b/test/unit_test/test_impact_selection.py
index af58419f..a35a6056 100644
--- a/test/unit_test/test_impact_selection.py
+++ b/test/unit_test/test_impact_selection.py
@@ -95,7 +95,7 @@ class TestCli(_Suite):
     def _ran(self, *flags):
         with patch("je_web_runner.utils.cli.cli_main.execute_files") as run:
             main(["-d", str(self.dir), *flags])
-        return sorted(run.call_args.args[0]) if run.called else []
+        return sorted(path for call in run.call_args_list for path in call.args[0])
 
     def test_affected_by_with_a_cache_and_tags_still_applying_after(self):
         cache = self.root / "impact.json"
diff --git a/test/unit_test/test_legacy_cli_contract.py b/test/unit_test/test_legacy_cli_contract.py
index 659db2a2..0819db9d 100644
--- a/test/unit_test/test_legacy_cli_contract.py
+++ b/test/unit_test/test_legacy_cli_contract.py
@@ -78,6 +78,45 @@ def test_execute_str_as_pybreeze_sends_it(tmp_path):
     _assert_ran(_run_cli(tmp_path, "--execute_str", _pybreeze_execute_str(_actions(target))), target)
 
 
+def _failing_actions() -> list:
+    """An action that fails (no command has that name), then one that prints MARKER."""
+    return [["WR_no_such_command"], ["print", [MARKER]]]
+
+
+@pytest.mark.parametrize("flag", ["-e", "--execute_file"])
+def test_a_failed_action_exits_1_after_the_rest_ran(tmp_path, flag):
+    action_file = tmp_path / "actions.json"
+    action_file.write_text(json.dumps(_failing_actions()), encoding="utf-8")
+    result = _run_cli(tmp_path, flag, str(action_file))
+    assert result.returncode == 1, result.stdout + result.stderr  # nosec B101
+    assert "error: 1 action(s) or file(s) failed" in result.stderr  # nosec B101
+    assert MARKER in result.stdout, result.stdout + result.stderr  # nosec B101
+
+
+def test_a_failed_action_in_a_directory_exits_1(tmp_path):
+    action_dir = tmp_path / "actions"
+    action_dir.mkdir()
+    (action_dir / "a_ok.json").write_text(json.dumps(_actions(tmp_path)), encoding="utf-8")
+    (action_dir / "b_bad.json").write_text(json.dumps(_failing_actions()), encoding="utf-8")
+    assert _run_cli(tmp_path, "--execute_dir", str(action_dir)).returncode == 1  # nosec B101
+
+
+def test_a_failed_action_in_execute_str_exits_1(tmp_path):
+    result = _run_cli(tmp_path, "--execute_str", _pybreeze_execute_str(_failing_actions()))
+    assert result.returncode == 1, result.stdout + result.stderr  # nosec B101
+
+
+def test_process_mode_detects_failure_without_action_recording(tmp_path):
+    action_dir = tmp_path / "actions"
+    action_dir.mkdir()
+    (action_dir / "a_bad.json").write_text(json.dumps(_failing_actions()), encoding="utf-8")
+    (action_dir / "b_ok.json").write_text(json.dumps(_actions(tmp_path)), encoding="utf-8")
+    result = _run_cli(tmp_path, "-d", str(action_dir), "--parallel", "2", "--parallel-mode", "process")
+    assert result.returncode == 1, result.stdout + result.stderr  # nosec B101
+    assert "error: 1 action(s) or file(s) failed" in result.stderr  # nosec B101
+    assert result.stdout.count(MARKER) >= 2, result.stdout + result.stderr  # nosec B101
+
+
 def test_no_flag_exits_non_zero(tmp_path):
     assert _run_cli(tmp_path).returncode != 0  # nosec B101
 
diff --git a/test/unit_test/test_report_path.py b/test/unit_test/test_report_path.py
new file mode 100644
index 00000000..f1e5321e
--- /dev/null
+++ b/test/unit_test/test_report_path.py
@@ -0,0 +1,127 @@
+"""Under TestPioneer a report asked for under a relative name goes below ``TEST_PIONEER_ARTIFACT_DIR``."""
+import json
+from pathlib import Path
+
+import pytest
+
+from je_web_runner.utils.generate_report.generate_allure_report import generate_allure_report
+from je_web_runner.utils.generate_report.generate_html_report import generate_html_report
+from je_web_runner.utils.generate_report.generate_json_report import generate_json_report
+from je_web_runner.utils.generate_report.generate_junit_xml_report import generate_junit_xml_report
+from je_web_runner.utils.generate_report.generate_xml_report import generate_xml_report
+from je_web_runner.utils.generate_report.interactive_html_report import generate_interactive_html_report
+from je_web_runner.utils.generate_report.report_manifest import generate_all_reports
+from je_web_runner.utils.generate_report.report_path import ARTIFACT_DIR_VARIABLE, report_path
+from je_web_runner.utils.test_record.test_record_class import record_action_to_list, test_record_instance
+
+
+@pytest.fixture(autouse=True)
+def _records():
+    recording = test_record_instance.init_record
+    test_record_instance.clean_record()
+    test_record_instance.init_record = True
+    record_action_to_list("ok_func", None, None)
+    record_action_to_list("bad_func", None, RuntimeError("boom"))
+    yield
+    test_record_instance.clean_record()
+    test_record_instance.init_record = recording
+
+
+@pytest.fixture
+def artifact_dir(tmp_path, monkeypatch):
+    """A TestPioneer run: the variable is set, and the working directory is somewhere else."""
+    directory = tmp_path / "artifacts" / "run-1" / "runners" / "web-runner" / "01-web"
+    work = tmp_path / "work"
+    work.mkdir()
+    monkeypatch.chdir(work)
+    monkeypatch.setenv(ARTIFACT_DIR_VARIABLE, str(directory))
+    return directory
+
+
+def test_a_name_is_returned_as_given_outside_testpioneer(monkeypatch):
+    monkeypatch.delenv(ARTIFACT_DIR_VARIABLE, raising=False)
+    assert report_path("reports/web") == "reports/web"  # nosec B101
+
+
+def test_an_empty_variable_counts_as_unset(monkeypatch):
+    monkeypatch.setenv(ARTIFACT_DIR_VARIABLE, "  ")
+    assert report_path("reports/web") == "reports/web"  # nosec B101
+
+
+def test_a_relative_name_goes_below_the_artifact_directory(artifact_dir):
+    target = Path(report_path("reports/web_success.json"))
+    assert target == artifact_dir.resolve() / "reports" / "web_success.json"  # nosec B101
+    assert target.parent.is_dir()  # nosec B101
+
+
+def test_an_absolute_name_is_left_alone(artifact_dir, tmp_path):
+    name = str(tmp_path / "elsewhere" / "web.json")
+    assert report_path(name) == name  # nosec B101
+    assert not artifact_dir.exists()  # nosec B101
+
+
+def test_a_name_that_leaves_the_directory_is_left_alone(artifact_dir):
+    assert report_path("../outside.json") == "../outside.json"  # nosec B101
+    assert not artifact_dir.exists()  # nosec B101
+
+
+def test_a_directory_that_cannot_be_created_falls_back_to_the_name(tmp_path, monkeypatch):
+    not_a_directory = tmp_path / "file"
+    not_a_directory.write_text("x", encoding="utf-8")
+    monkeypatch.setenv(ARTIFACT_DIR_VARIABLE, str(not_a_directory))
+    assert report_path("reports/web.json") == "reports/web.json"  # nosec B101
+
+
+@pytest.mark.parametrize("generate, written", [
+    (generate_json_report, ["reports/web_success.json", "reports/web_failure.json"]),
+    (generate_xml_report, ["reports/web_success.xml", "reports/web_failure.xml"]),
+    (generate_html_report, ["reports/web.html"]),
+    (generate_junit_xml_report, ["reports/web_junit.xml"]),
+    (generate_interactive_html_report, ["reports/web.html"]),
+], ids=["json", "xml", "html", "junit", "interactive-html"])
+def test_a_report_is_written_below_the_artifact_directory(artifact_dir, generate, written):
+    generate("reports/web")
+    assert [(artifact_dir / path).is_file() for path in written] == [True] * len(written)  # nosec B101
+    # Nothing is left in the working directory, where the name used to point.
+    assert not Path("reports").exists()  # nosec B101
+
+
+def test_the_allure_results_are_written_below_the_artifact_directory(artifact_dir):
+    results = generate_allure_report("allure-results")
+    assert results  # nosec B101
+    assert {Path(result).parent for result in results} == {artifact_dir.resolve() / "allure-results"}  # nosec B101
+    assert not Path("allure-results").exists()  # nosec B101
+
+
+def test_the_manifest_lists_the_files_where_they_are(artifact_dir):
+    outcome = generate_all_reports("reports/web")
+    manifest = Path(outcome["manifest_path"])
+    assert manifest == artifact_dir.resolve() / "reports" / "web.manifest.json"  # nosec B101
+    produced = json.loads(manifest.read_text(encoding="utf-8"))["produced"]
+    assert produced["json"]  # nosec B101
+    assert all(Path(path).is_file() for paths in produced.values() for path in paths)  # nosec B101
+    assert not Path("reports").exists()  # nosec B101
+
+
+def test_outside_testpioneer_a_report_stays_in_the_working_directory(tmp_path, monkeypatch):
+    monkeypatch.delenv(ARTIFACT_DIR_VARIABLE, raising=False)
+    monkeypatch.chdir(tmp_path)
+    generate_json_report("web")
+    assert (tmp_path / "web_success.json").is_file()  # nosec B101
+
+
+def test_invalid_artifact_directory_falls_back(monkeypatch):
+    monkeypatch.setenv(ARTIFACT_DIR_VARIABLE, "artifacts")
+    def invalid_path(*args, **kwargs):
+        raise ValueError("invalid path")
+    monkeypatch.setattr(Path, "resolve", invalid_path)
+    assert report_path("web.json") == "web.json"  # nosec B101
+
+
+def test_manifest_resolves_allure_directory(artifact_dir):
+    outcome = generate_all_reports("reports/web", allure_dir="allure-results")
+    manifest = json.loads(Path(outcome["manifest_path"]).read_text(encoding="utf-8"))
+    assert manifest["produced"]["allure"]  # nosec B101
+    assert all(Path(path).is_file() for path in manifest["produced"]["allure"])  # nosec B101
+    assert all(Path(path).parent == artifact_dir.resolve() / "allure-results"
+               for path in manifest["produced"]["allure"])  # nosec B101