messagefoundry 0.2.0__tar.gz → 0.2.1__tar.gz

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/.github/workflows/release-sync-check.yml

@@ -32,6 +32,12 @@ jobs:
           python-version: "3.13"
       - name: Check tag / PyPI / mirror are in sync
         run: |
+          # The script lives under the deny-listed scripts/publish/, so it is ABSENT on the OSS mirror;
+          # the sync check only runs on the private repo (the publish source). Skip where it's absent.
+          if [ ! -f scripts/publish/check_release_sync.py ]; then
+            echo "scripts/publish/check_release_sync.py absent (OSS mirror) — skipping the release-sync check."
+            exit 0
+          fi
           # `packaging` gives canonical version normalization (so a "0.1.0-rc1" tag and PyPI's
           # "0.1.0rc1" compare equal); the script falls back to a naive form if it's absent.
           python -m pip install --upgrade pip packaging

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/.github/workflows/security.yml

@@ -202,5 +202,12 @@ jobs:
         with:
           python-version: "3.13"
       - name: Scan the publishable subset for forbidden content
-        # Stdlib-only scanner (no install). Exits non-zero — failing the build — on any hit.
-        run: python scripts/publish/scan_forbidden.py --published
+        # Stdlib-only scanner (no install). Exits non-zero — failing the build — on any hit. The scanner
+        # lives under the deny-listed scripts/publish/, so it is ABSENT on the OSS mirror — there's
+        # nothing to gate there (everything is already the published subset); skip rather than error.
+        run: |
+          if [ -f scripts/publish/scan_forbidden.py ]; then
+            python scripts/publish/scan_forbidden.py --published
+          else
+            echo "scripts/publish/scan_forbidden.py absent (OSS mirror) — skipping the publish leak-gate."
+          fi

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/CHANGELOG.md

@@ -6,6 +6,21 @@ All notable changes to MessageFoundry are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.2.1] — 2026-06-23 — Early Access
+
+### Fixed
+- **Windows: `messagefoundry --help` crashed on a legacy codepage** — the top-level help rendered a
+  non-cp1252 character (a `->` arrow in the `adr-analyze` subcommand help, new in 0.2.0), so `--help`
+  aborted with `UnicodeEncodeError` on a cp1252/charmap console (cmd, PowerShell, or any redirected
+  stdout). `main()` now reconfigures stdout/stderr with `errors="replace"` and the help text is ASCII;
+  the machine-read JSON introspection subcommands are unaffected (`json.dumps(ensure_ascii=True)`).
+- **`verify --section host` crashed without the `[console]` extra** — `check_console_no_window()`
+  resolved a console submodule via `find_spec`, which imported the console package and its eager `httpx`
+  dependency, so a `[sqlserver]`-only install aborted with `ModuleNotFoundError: No module named 'httpx'`
+  instead of skipping the console check. The console package now imports its API client lazily (PEP 562
+  `__getattr__`), so resolving a submodule no longer requires `httpx`, and the check degrades to SKIP if a
+  console dependency is absent.
+
 ## [0.2.0] — 2026-06-23 — Early Access
 
 ### Added
@@ -75,5 +90,7 @@ tests, but the external code review + penetration test (the bar for a security-c
 - Releases are built, SBOM'd (CycloneDX), and signed with [Sigstore](https://www.sigstore.dev/) — see the
   `release` workflow.
 
-[Unreleased]: https://github.com/wshallwshall/MessageFoundry/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/wshallwshall/MessageFoundry/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/wshallwshall/MessageFoundry/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/wshallwshall/MessageFoundry/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/wshallwshall/MessageFoundry/releases/tag/v0.1.0

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: messagefoundry
-Version: 0.2.0
+Version: 0.2.1
 Summary: Open-source healthcare integration engine — route, transform, and validate messages across many formats and connection types
 License-Expression: AGPL-3.0-or-later
 License-File: LICENSE

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/__init__.py

@@ -60,7 +60,7 @@ from messagefoundry.parsing.message import Message, RawMessage
 from messagefoundry.parsing.split import split_by_obr
 from messagefoundry.timezone import convert_hl7_timestamp, to_zone
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = [
     "Message",

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/__main__.py

@@ -30,6 +30,21 @@ from messagefoundry.logging_setup import LOG_LEVELS, SyslogForward, configure_lo
 
 
 def main(argv: list[str] | None = None) -> int:
+    # Harden the human-facing streams for a legacy Windows codepage (cp1252/charmap): argparse's own
+    # --help/usage printer and runtime log/print() lines bypass _safe_print, so a non-cp1252 char
+    # (an arrow or other symbol in a help string or log line) would otherwise abort with
+    # UnicodeEncodeError. errors="replace" is lossy for such chars, but the machine-read JSON
+    # subcommands stay ASCII (json.dumps ensure_ascii=True). Guarded: some stream wrappers
+    # (PYTHONLEGACYWINDOWSSTDIO, pytest capture) lack reconfigure or reject it, and the hardening
+    # must never itself crash the CLI.
+    for _stream in (sys.stdout, sys.stderr):
+        _reconfigure = getattr(_stream, "reconfigure", None)
+        if _reconfigure is not None:
+            try:
+                _reconfigure(errors="replace")
+            except (ValueError, OSError):
+                pass
+
     parser = argparse.ArgumentParser(prog="messagefoundry", description=__doc__)
     parser.add_argument("--version", action="version", version=f"messagefoundry {__version__}")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -111,8 +126,8 @@ def main(argv: list[str] | None = None) -> int:
 
     adr_analyze = sub.add_parser(
         "adr-analyze",
-        help="advisory spec-driven ADR coverage: acceptance-criteria→test links, missing criteria, "
-        "open clarifications (Secure Development Standards §5)",
+        help="advisory spec-driven ADR coverage: acceptance-criteria->test links, missing criteria, "
+        "open clarifications (Secure Development Standards section 5)",
     )
     adr_analyze.add_argument(
         "--adr-dir", default="docs/adr", help="ADR directory (default: docs/adr)"
@@ -458,7 +473,7 @@ def _serve(args: argparse.Namespace) -> int:
         # Only announce forwarding when configure_logging actually installed the handler — a TCP
         # collector that is down at startup is skipped (it warns), so this must not contradict it.
         logging.getLogger(__name__).info(
-            "off-box log forwarding enabled → %s:%d (%s, %s)",
+            "off-box log forwarding enabled -> %s:%d (%s, %s)",
             log_forward.host,
             log_forward.port,
             log_forward.protocol,

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/api/app.py

@@ -81,6 +81,8 @@ from messagefoundry.api.models import (
     ReloadRequest,
     ReloadResult,
     ReplayResult,
+    StatsResetRequest,
+    StatsResetResult,
     StatsResponse,
     SystemStatus,
 )
@@ -565,9 +567,9 @@ def create_app(
         _user: Identity = Depends(require(Permission.MONITORING_READ)),
     ) -> list[ConnectionRow]:
         now = time.time()
-        metrics = await engine.store.connection_metrics(
-            since=engine.started_at, now=now, rate_window=_RATE_WINDOW
-        )
+        # Offset-adjusted: subtracts any operator stats-resets (in-memory baselines). Identical to the
+        # raw store metrics when nothing has been reset.
+        metrics = await engine.connection_metrics_view(now=now, rate_window=_RATE_WINDOW)
         rows: list[ConnectionRow] = []
 
         # A source row per inbound connection, and a destination row per (inbound → outbound)
@@ -855,6 +857,58 @@ def create_app(
         cancelled = await engine.store.cancel_queued(None, name, top_only=(scope == "top"))
         return PurgeResult(cancelled=cancelled)
 
+    @app.post("/statistics/reset", response_model=StatsResetResult)
+    async def reset_statistics(
+        req: StatsResetRequest,
+        engine: Engine = Depends(_get_engine),
+        identity: Identity = Depends(require(Permission.MONITORING_DIAGNOSE)),
+    ) -> StatsResetResult:
+        """Zero the connections-dashboard cumulative counters (inbound read/errored, outbound
+        written/dead) for the selected connections, or all of them. This moves an in-memory baseline —
+        message rows (the PHI/audit record) and the Prometheus ``/metrics`` counters are untouched, as
+        are live gauges (queue depth, ages)."""
+        inbound: list[str] = []
+        outbound: list[tuple[str, str]] = []
+        if req.all:
+            # "Reset all" spans every channel, so a channel-scoped user may not run it (mirror purge).
+            if identity.allowed_channels is not None:
+                await _audit_channel_denied(engine, identity, None)
+                raise HTTPException(403, "channel-scoped users cannot reset all statistics")
+        else:
+            for t in req.targets:
+                # Per-channel RBAC: a scoped user may reset only endpoints of their own inbound channels
+                # (a destination row is the channel_id->destination edge, so the same scope applies).
+                if identity.allowed_channels is not None and not identity.can_access_channel(
+                    t.channel_id
+                ):
+                    await _audit_channel_denied(engine, identity, t.channel_id)
+                    raise HTTPException(403, "connection is outside your channel scope")
+                if t.role == "source":
+                    if t.channel_id not in inbound:
+                        inbound.append(t.channel_id)
+                else:
+                    if t.destination is None:
+                        raise HTTPException(422, "destination rows require a destination name")
+                    key = (t.channel_id, t.destination)
+                    if key not in outbound:
+                        outbound.append(key)
+        count = await engine.reset_stats(
+            all_connections=req.all, inbound=inbound, outbound=outbound, now=time.time()
+        )
+        await engine.store.record_audit(
+            "stats_reset",
+            actor=identity.username,
+            detail=json.dumps(
+                {
+                    "all": req.all,
+                    "inbound": inbound,
+                    "outbound": [list(k) for k in outbound],
+                    "reset": count,
+                }
+            ),
+        )
+        return StatsResetResult(reset=count)
+
     # --- dead letters (verify + recover) -------------------------------------
 
     @app.get("/dead-letters", response_model=DeadLetterList)

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/api/models.py

@@ -10,7 +10,7 @@ body (PHI) appears only in the single-message detail view, which is audited.
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field
 
@@ -243,6 +243,26 @@ class ConnectionRow(BaseModel):
     )
 
 
+class StatsResetTarget(BaseModel):
+    """One connections-dashboard endpoint to reset, matching a row's (role, channel_id, destination).
+    For ``source`` rows ``destination`` is ignored; for ``destination`` rows it is required."""
+
+    role: Literal["source", "destination"]
+    channel_id: str = Field(min_length=1, max_length=256)
+    destination: str | None = Field(default=None, max_length=256)
+
+
+class StatsResetRequest(BaseModel):
+    """Reset the dashboard's cumulative counters for ``targets``, or for every connection (``all``)."""
+
+    all: bool = False
+    targets: list[StatsResetTarget] = Field(default_factory=list)
+
+
+class StatsResetResult(BaseModel):
+    reset: int  # number of connection endpoints whose dashboard counters were reset
+
+
 class StatsResponse(BaseModel):
     outbox_by_status: dict[str, int]
     # NOT-DONE rows (pending|inflight) across every stage (ingress + routed + outbound) — a

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/console/__init__.py

@@ -15,6 +15,21 @@ PySide6 unless you actually open the GUI.
 
 from __future__ import annotations
 
-from messagefoundry.console.client import ApiError, EngineClient
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # Static-only re-export: mypy --strict still resolves the names, but at runtime they load lazily
+    # via __getattr__ below, so importing this package (or find_spec'ing a sibling submodule like
+    # service_control) no longer hard-requires the [console] extra's httpx. Mirrors the
+    # lazy-truststore import already in client.py and the lazy-pydantic api/__init__ convention.
+    from messagefoundry.console.client import ApiError, EngineClient
 
 __all__ = ["EngineClient", "ApiError"]
+
+
+def __getattr__(name: str) -> object:
+    if name in __all__:
+        from messagefoundry.console import client
+
+        return getattr(client, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/console/client.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 import logging
 import ssl
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from json import JSONDecodeError
 from types import TracebackType
 from typing import TypeVar
@@ -56,6 +56,7 @@ from messagefoundry.api.models import (
     PurgeResult,
     ReloadResult,
     ReplayResult,
+    StatsResetResult,
     StatsResponse,
     SystemStatus,
 )
@@ -375,6 +376,23 @@ class EngineClient:
             PurgeResult,
         )
 
+    def reset_stats(
+        self,
+        *,
+        all_connections: bool = False,
+        targets: Sequence[tuple[str, str, str | None]] = (),
+    ) -> StatsResetResult:
+        """Reset the connections-dashboard counters for ``targets`` (each ``(role, channel_id,
+        destination)``), or for every connection when ``all_connections`` is set."""
+        body = {
+            "all": all_connections,
+            "targets": [
+                {"role": role, "channel_id": channel_id, "destination": destination}
+                for (role, channel_id, destination) in targets
+            ],
+        }
+        return _decode(self._request("POST", "/statistics/reset", json=body), StatsResetResult)
+
     def list_messages(
         self,
         *,

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/console/connections.py

@@ -127,6 +127,9 @@ class ConnectionsPage(QWidget):
         menu.addSeparator()
         act_purge_top = menu.addAction("Purge Top Message")
         act_purge_all = menu.addAction("Purge All Queued Messages")
+        menu.addSeparator()
+        act_reset_sel = menu.addAction("Reset Statistics (Selected)")
+        act_reset_all = menu.addAction("Reset All Statistics")
         self._actions.setMenu(menu)
 
         self._start.clicked.connect(lambda: self._inbound_action(self._client.start_connection))
@@ -134,6 +137,8 @@ class ConnectionsPage(QWidget):
         act_restart.triggered.connect(lambda: self._inbound_action(self._client.restart_connection))
         act_purge_top.triggered.connect(lambda: self._purge("top"))
         act_purge_all.triggered.connect(lambda: self._purge("all"))
+        act_reset_sel.triggered.connect(lambda: self._reset_stats(all_connections=False))
+        act_reset_all.triggered.connect(lambda: self._reset_stats(all_connections=True))
 
         toolbar = QHBoxLayout()
         toolbar.addWidget(QLabel("Connections"))
@@ -292,7 +297,10 @@ class ConnectionsPage(QWidget):
         has = bool(self._selected_keys())
         self._start.setEnabled(has)
         self._stop.setEnabled(has)
-        self._actions.setEnabled(has)
+        # The Actions menu stays enabled even with no selection: "Reset All Statistics" needs none. The
+        # selection-dependent items (Restart / Purge / Reset Selected) guard themselves and report when
+        # nothing is selected.
+        self._actions.setEnabled(True)
 
     # --- actions -------------------------------------------------------------
 
@@ -343,6 +351,36 @@ class ConnectionsPage(QWidget):
             return
         self.refresh()
 
+    def _reset_stats(self, *, all_connections: bool) -> None:
+        """Zero the dashboard's cumulative counters (read / errored / written) for the selected rows,
+        or for every connection. Non-destructive: it moves a display baseline on the engine — messages
+        and history are untouched — so only "Reset All" is confirmed (it's broad)."""
+        targets: list[tuple[str, str, str | None]] = []
+        if all_connections:
+            answer = QMessageBox.question(
+                self,
+                "Reset all statistics",
+                "Reset the counters (read / errored / written) for ALL connections?\n\n"
+                "This only clears the dashboard tallies — messages and history are untouched.",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                QMessageBox.StandardButton.No,
+            )
+            if answer != QMessageBox.StandardButton.Yes:
+                return
+        else:
+            # Each row key is (role, channel_id, dest|""); "" (source rows) becomes None for the API.
+            for role, channel_id, dest in self._selected_keys():
+                targets.append((role, channel_id, dest or None))
+            if not targets:
+                self.error.emit("Select one or more rows to reset, or use Reset All Statistics.")
+                return
+        try:
+            self._client.reset_stats(all_connections=all_connections, targets=targets)
+        except ApiError as exc:
+            self.error.emit(str(exc))
+            return
+        self.refresh()
+
     def _on_cell_clicked(self, row: int, col: int) -> None:
         if col != _LOGS_COL:
             return

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/pipeline/engine.py

@@ -13,6 +13,7 @@ import asyncio
 import logging
 import time
 from collections.abc import Callable, Mapping, Sequence
+from dataclasses import replace
 from pathlib import Path
 from typing import Any
 
@@ -42,6 +43,7 @@ from messagefoundry.pipeline.retention import RetentionRunner
 from messagefoundry.pipeline.state_convergence import StateConvergenceRunner
 from messagefoundry.pipeline.wiring_runner import RegistryRunner
 from messagefoundry.store import MessageStore, Store
+from messagefoundry.store.store import ConnectionMetrics, DestinationMetrics, InboundMetrics
 
 __all__ = ["Engine", "ConfigReloadDenied"]
 
@@ -180,6 +182,15 @@ class Engine:
         self._graph_reconcile_interval = 1.0
         # Set when start() runs; the "since" for since-engine-start metric counts.
         self.started_at: float = 0.0
+        # Console stats-reset baselines (in-memory; dropped on restart, like the counts they offset).
+        # When an operator resets a connection's dashboard stats, we snapshot its current cumulative
+        # counters here; the connections view subtracts the snapshot so the visible read/errored/
+        # written/dead zero out without touching any message rows (the PHI/audit record). Keyed by
+        # channel_id (inbound) and (channel_id, destination) (outbound). See reset_stats().
+        self._inbound_stat_offsets: dict[str, tuple[int, int]] = {}  # cid -> (read, errored)
+        self._outbound_stat_offsets: dict[
+            tuple[str, str], tuple[int, int]
+        ] = {}  # key -> (written, dead)
         # The startup config dir is the default reload target and an implicit allowed root.
         self.config_dir: Path | None = Path(config_dir).resolve() if config_dir else None
         roots = [Path(r).resolve() for r in config_reload_roots]
@@ -712,6 +723,83 @@ class Engine:
             self._registry_runner.notify_work()
         return requeued
 
+    # --- connections-dashboard stats (in-memory reset baselines) -------------
+
+    async def connection_metrics_view(
+        self, *, now: float | None = None, rate_window: float = 60.0
+    ) -> ConnectionMetrics:
+        """Per-connection metrics for the dashboard with operator stats-resets applied. The cumulative
+        counters (inbound read/errored, outbound written/dead) have their reset baseline subtracted
+        (clamped at ``>= 0``); live gauges (queue depth, ages, last-seen) pass through untouched. With
+        no resets active this returns the store metrics verbatim, so the dashboard is byte-identical to
+        before this feature."""
+        metrics = await self.store.connection_metrics(
+            since=self.started_at, now=now, rate_window=rate_window
+        )
+        if not self._inbound_stat_offsets and not self._outbound_stat_offsets:
+            return metrics  # fast path: nothing reset
+        inbound = {cid: self._apply_inbound_offset(cid, m) for cid, m in metrics.inbound.items()}
+        destinations = {
+            key: self._apply_outbound_offset(key, m) for key, m in metrics.destinations.items()
+        }
+        return ConnectionMetrics(inbound=inbound, destinations=destinations)
+
+    def _apply_inbound_offset(self, channel_id: str, m: InboundMetrics) -> InboundMetrics:
+        off = self._inbound_stat_offsets.get(channel_id)
+        if off is None:
+            return m
+        read0, errored0 = off
+        return replace(m, read=max(0, m.read - read0), errored=max(0, m.errored - errored0))
+
+    def _apply_outbound_offset(
+        self, key: tuple[str, str], m: DestinationMetrics
+    ) -> DestinationMetrics:
+        off = self._outbound_stat_offsets.get(key)
+        if off is None:
+            return m
+        written0, dead0 = off
+        return replace(m, written=max(0, m.written - written0), dead=max(0, m.dead - dead0))
+
+    async def reset_stats(
+        self,
+        *,
+        all_connections: bool = False,
+        inbound: Sequence[str] = (),
+        outbound: Sequence[tuple[str, str]] = (),
+        now: float | None = None,
+    ) -> int:
+        """Move the connections-dashboard "count from" mark to now for the targeted connections so the
+        visible cumulative counters (inbound read/errored, outbound written/dead) zero out. Implemented
+        as an in-memory snapshot of the current counts — message rows are never touched, and the
+        Prometheus ``/metrics`` counters (which must stay monotonic) are untouched too. ``all_connections``
+        resets every connection that has carried traffic. Returns the number of endpoints reset.
+
+        A connection with no traffic yet snapshots to ``(0, 0)``, which is correct: everything it sees
+        from here on arrives after the reset. Re-resetting overwrites the snapshot with the live counts,
+        so it re-zeroes."""
+        # Snapshot the RAW store counts (no offsets) so a re-reset captures the live cumulative value.
+        metrics = await self.store.connection_metrics(since=self.started_at, now=now)
+        count = 0
+        if all_connections:
+            for cid, m in metrics.inbound.items():
+                self._inbound_stat_offsets[cid] = (m.read, m.errored)
+                count += 1
+            for key, dm in metrics.destinations.items():
+                self._outbound_stat_offsets[key] = (dm.written, dm.dead)
+                count += 1
+            return count
+        for cid in inbound:
+            im = metrics.inbound.get(cid)
+            self._inbound_stat_offsets[cid] = (im.read, im.errored) if im is not None else (0, 0)
+            count += 1
+        for key in outbound:
+            dmet = metrics.destinations.get(key)
+            self._outbound_stat_offsets[key] = (
+                (dmet.written, dmet.dead) if dmet is not None else (0, 0)
+            )
+            count += 1
+        return count
+
     async def stop(self) -> None:
         """Stop the retention task + the wired graph, then close the store."""
         log.info("engine stopping")

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/messagefoundry/verify/checks.py

@@ -196,7 +196,13 @@ def check_console_importable() -> CheckResult:
 
 def check_console_no_window() -> CheckResult:
     """The console's service-control path passes CREATE_NO_WINDOW (no console flash on Status poll)."""
-    spec = importlib.util.find_spec("messagefoundry.console.service_control")
+    try:
+        # find_spec on a SUBMODULE imports the parent package; if console/__init__ ever drags a
+        # missing [console]-extra dep (e.g. httpx) this raises ModuleNotFoundError. Degrade to SKIP
+        # like every sibling check instead of crashing the whole `verify` run on a non-[console] box.
+        spec = importlib.util.find_spec("messagefoundry.console.service_control")
+    except (ImportError, ValueError):
+        spec = None
     if spec is None or not spec.origin:
         return CheckResult(
             "host.noflash",

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/tests/test_anon_core.py

@@ -5,6 +5,8 @@ fail-closed leak-check — engine side."""
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 
 from messagefoundry.anon import (
@@ -22,6 +24,15 @@ from messagefoundry.anon import (
 )
 from messagefoundry.anon.surrogates import Seps, scrub_site_codes, surrogate_field
 
+# The leak-check delegates to scripts/publish/scan_forbidden.py (the owner-managed publish guard — a
+# dev/source-checkout tool, not in the wheel and deny-listed in the OSS mirror). Skip the two tests that
+# exercise it where it's absent; the engine raises LeakCheckUnavailable there by design.
+_LEAK_SCANNER = Path(__file__).resolve().parents[1] / "scripts" / "publish" / "scan_forbidden.py"
+_NO_SCANNER = pytest.mark.skipif(
+    not _LEAK_SCANNER.exists(),
+    reason="leak-check needs scripts/publish/scan_forbidden.py (private-only; OSS-mirror deny-list)",
+)
+
 _SALT = "unit-salt-0123456789abcdef"
 _SEPS = Seps()
 
@@ -184,6 +195,7 @@ def test_anonymize_reads_custom_separators_from_msh() -> None:
 # --- leak-check -----------------------------------------------------------------------------------
 
 
+@_NO_SCANNER
 def test_leak_check_clean_and_dirty() -> None:
     assert leak_check(anonymize(_SAMPLE, salt=_SALT)) == []
     hits = leak_check("note mentioning OMNICELL and 540099")
@@ -191,6 +203,7 @@ def test_leak_check_clean_and_dirty() -> None:
     assert any("54" in h for h in hits)
 
 
+@_NO_SCANNER
 def test_anonymize_checked_fails_closed_and_is_phi_safe() -> None:
     # estate token in a KEPT field (MSH-3) survives surrogation -> must raise
     dirty = _msg(

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/tests/test_anon_parity.py

@@ -38,6 +38,11 @@ _REFUSED = ["", "PID|1||9^^^H^MR||DOE^JOHN", "MSH|^~|A|B", "not hl7 at all"]
 
 def _load_scan_forbidden() -> object:
     path = _ROOT / "scripts" / "publish" / "scan_forbidden.py"
+    if not path.exists():
+        # Private-only (scripts/publish/ is deny-listed in the OSS mirror); skip where it's absent.
+        pytest.skip(
+            "scan_forbidden.py is private-only (OSS-mirror deny-list)", allow_module_level=True
+        )
     spec = importlib.util.spec_from_file_location("scan_forbidden", path)
     assert spec is not None and spec.loader is not None
     mod = importlib.util.module_from_spec(spec)

{messagefoundry-0.2.0 → messagefoundry-0.2.1}/tests/test_cli.py

@@ -40,6 +40,24 @@ def test_validate_clean_sample(capsys: pytest.CaptureFixture[str]) -> None:
     assert _out_json(capsys) == []
 
 
+def test_top_level_help_encodes_on_legacy_windows_codepage(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    # Regression: `messagefoundry --help` crashed with UnicodeEncodeError on a cp1252/charmap
+    # console because of a U+2192 arrow in the adr-analyze subparser help. Render the help string
+    # in-process and assert it survives a cp1252 encode -- reproduces the Windows-only crash on any
+    # runner without touching the real terminal (argparse --help raises SystemExit after printing).
+    with pytest.raises(SystemExit):
+        main(["--help"])
+    help_text = capsys.readouterr().out
+    assert "adr-analyze" in help_text, "top-level help did not render the subcommand list"
+    try:
+        help_text.encode("cp1252")
+    except UnicodeEncodeError as exc:
+        bad = help_text[exc.start]
+        pytest.fail(f"top-level --help is not cp1252-encodable: U+{ord(bad):04X} {bad!r}")
+
+
 def test_validate_reports_problems(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
     (tmp_path / "bad.py").write_text("raise ValueError('boom')\n", encoding="utf-8")
     assert main(["validate", "--config", str(tmp_path), "--json"]) == 1