swarph-cli 0.40.0__tar.gz → 0.40.1__tar.gz

{swarph_cli-0.40.0/src/swarph_cli.egg-info → swarph_cli-0.40.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.40.0
+Version: 0.40.1
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.40.0 → swarph_cli-0.40.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.40.0"
+version = "0.40.1"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.40.0 → swarph_cli-0.40.1}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.40.0"
+__version__ = "0.40.1"
 
 __all__ = ["__version__"]

{swarph_cli-0.40.0 → swarph_cli-0.40.1}/src/swarph_cli/commands/daemon.py

@@ -170,7 +170,7 @@ def _write_daemon_pidfile(state_dir: Path) -> Optional[Path]:
         os.replace(tmp, path)
         return path
     except OSError as exc:
-        print(f"[swarph-daemon] could not write {DAEMON_PIDFILE}: {exc}",
+        _print_safe(f"[swarph-daemon] could not write {DAEMON_PIDFILE}: {exc}",
               file=sys.stderr, flush=True)
         return None
 
@@ -182,7 +182,7 @@ def _read_cursor(path: Path) -> dict:
         return json.loads(path.read_text(encoding="utf-8"))
     except json.JSONDecodeError as exc:
         # Loud — corrupted cursor needs operator attention, not silent reset.
-        print(
+        _print_safe(
             f"[swarph-daemon] CORRUPTED cursor at {path}: {exc}. "
             f"Refusing to overwrite. Inspect manually.",
             file=sys.stderr,
@@ -260,16 +260,87 @@ class DaemonState:
 
 def _log_dm(state: DaemonState, dm: dict) -> None:
     """Both stdout (visible to operator + journald) AND inbox.log (cursor
-    audit trail). Inbox.log is append-only structured JSONL."""
+    audit trail). Inbox.log is append-only structured JSONL.
+
+    >>> THE AUDIT WRITE COMES FIRST AND THE OPERATOR LINE CANNOT KILL THE LOOP. <<<
+    MEASURED on workstation-lc 2026-07-29 (French Windows, cp1252 console, Task
+    Scheduler): this function printed a hardcoded U+2192 to a charmap stdout, raising
+    UnicodeEncodeError on EVERY DM. `_drain_iteration` aborted, THE CURSOR NEVER
+    ADVANCED, ZERO DMS WERE DELIVERED — and the outer handler swallowed it as
+    "iteration error (continuing)", so Get-ScheduledTask reported Running and every
+    surface was green. THE CELL WAS DM-BLIND WITH NOTHING ANYWHERE SAYING SO.
+
+    Three separate faults, fixed separately because each is sufficient alone:
+      1. the separator was a hardcoded non-ASCII character -> now ASCII "->"
+      2. DM CONTENT is arbitrary (French, emoji, arrows) and reprs unescaped on py3,
+         so the console can still refuse it -> the write is encode-safe
+      3. >>> A DISPLAY FAILURE MUST NEVER BE ABLE TO STOP DELIVERY. <<< The audit
+         trail is written FIRST, and the operator line is best-effort. Losing a
+         console line is cosmetic; losing the cursor is a silent outage.
+    """
+    # 1. AUDIT FIRST — utf-8 explicitly, never the locale default. If anything below
+    #    fails, the DM is already durably recorded and the cursor may safely advance.
+    state.inbox_log_path.parent.mkdir(parents=True, exist_ok=True)
+    with state.inbox_log_path.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(dm) + "\n")
+
+    # 2. OPERATOR LINE — best-effort, ASCII separator, and encode-safe against a
+    #    console that cannot represent the content.
     line = (
         f"[{dm.get('created_at', '?')}] "
         f"id={dm['id']} from={dm.get('from_node')} kind={dm.get('kind')} "
-        f"→ {dm['content'][:120]!r}"
+        f"-> {dm['content'][:120]!r}"
     )
-    print(line, flush=True)
-    state.inbox_log_path.parent.mkdir(parents=True, exist_ok=True)
-    with state.inbox_log_path.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(dm) + "\n")
+    _print_safe(line)
+
+
+def _print_safe(line: str, *, stream=None, file=None, flush: bool = True) -> None:
+    """Print, degrading to a lossy transliteration rather than raising.
+
+    A console whose encoding cannot represent a DM (cp1252 on a French Windows box,
+    any 8-bit codepage) must cost a mangled character, never a poll iteration.
+
+    >>> EVERY output path in this module goes through here, not just the DM line. <<<
+    droplet measured the first version's coverage at 1 call site out of 13, and named
+    the one that matters: the delivery-error handler in `attempt_delivery`, whose own
+    comment promises it will never crash the loop. A raise inside an `except` block
+    propagates past the `try` entirely — so the handler reached ONLY when something has
+    already gone wrong was itself the crash, on precisely the text most likely to carry
+    our characters (an exception message).
+
+    cp1252 coverage of what this fleet actually emits, measured:
+        renders : em-dash, bullet, accented e, guillemet
+        RAISES  : arrow, box-drawing, emoji, check-mark
+    Our DMs and operator lines are full of arrows and emoji, and the em-dash is FINE —
+    so the original DM-blindness was an arrow or an emoji, never punctuation.
+
+    A SYMBOL GREP MEASURES PRESENCE, NOT COVERAGE: `grep _print_safe` returns 1 whether
+    this guards one path or all thirteen. Coverage is asserted by a test that walks the
+    module's AST for unguarded `print(` calls, not by the symbol existing.
+    """
+    # `file=` is accepted as an alias for `stream=`, and `flush` is accepted and
+    # ignored (this always flushes). Deliberate: every call site here was a `print`,
+    # and a future author reaching for the print spelling must land in the guard
+    # rather than a TypeError — a TypeError in the delivery-error handler is the
+    # exact crash this function exists to prevent, merely with a different name.
+    out = stream if stream is not None else (file if file is not None else sys.stdout)
+    try:
+        print(line, file=out, flush=True)
+    except UnicodeEncodeError:
+        enc = getattr(out, "encoding", None) or "ascii"
+        try:
+            out.write(line.encode(enc, errors="replace").decode(enc, errors="replace"))
+            out.write("\n")
+            out.flush()
+        except (OSError, UnicodeEncodeError, ValueError):
+            # The fallback failing must not resurrect the crash it exists to prevent.
+            # Losing an operator line is survivable; losing the loop is not.
+            pass
+    except (OSError, ValueError):
+        # A closed/broken stream (detached service, full disk) is not a reason to stop
+        # draining — the audit write already succeeded. ValueError covers
+        # write-on-closed-file, which service teardown reaches.
+        pass
 
 
 def _route_to_handler(state: DaemonState, dm: dict) -> None:
@@ -343,7 +414,7 @@ def attempt_delivery(state: DaemonState) -> None:
         # inject failure → leave queued, retry next tick (no counter bump —
         # the cell was idle; a send failure is transient, not a stall).
     except Exception as exc:  # noqa: BLE001 — bridge must never crash the loop
-        print(f"[swarph-daemon] delivery error (continuing): "
+        _print_safe(f"[swarph-daemon] delivery error (continuing): "
               f"{type(exc).__name__}: {exc}", file=sys.stderr, flush=True)
 
 
@@ -380,7 +451,7 @@ async def _drain_iteration(state: DaemonState) -> None:
             state.disconnect_since = time.time()
         elapsed = time.time() - state.disconnect_since
         if elapsed > _LOUD_DISCONNECT_SECONDS:
-            print(
+            _print_safe(
                 f"[swarph-daemon] LOUD: gateway unreachable for "
                 f"{elapsed:.0f}s — {body.get('detail', '?')}",
                 file=sys.stderr,
@@ -390,14 +461,14 @@ async def _drain_iteration(state: DaemonState) -> None:
     if status >= 500:
         if state.disconnect_since is None:
             state.disconnect_since = time.time()
-        print(
+        _print_safe(
             f"[swarph-daemon] gateway 5xx {status}: {body.get('detail', '?')}",
             file=sys.stderr,
             flush=True,
         )
         return
     if status >= 400:
-        print(
+        _print_safe(
             f"[swarph-daemon] gateway {status}: {body.get('detail', '?')}",
             file=sys.stderr,
             flush=True,
@@ -434,7 +505,7 @@ async def _drain_loop(state: DaemonState) -> None:
     """Main loop. Returns on shutdown_requested. Exceptions in
     _drain_iteration are caught + logged + retried; only signal handlers
     set shutdown_requested."""
-    print(
+    _print_safe(
         f"[swarph-daemon] starting: self={state.self_name} "
         f"gateway={state.gateway} poll={state.poll_s}s "
         f"state={state.state_dir} auto_act={state.auto_act} "
@@ -446,7 +517,7 @@ async def _drain_loop(state: DaemonState) -> None:
         try:
             await _drain_iteration(state)
         except Exception as exc:  # noqa: BLE001 — loud-on-error per §16.4
-            print(
+            _print_safe(
                 f"[swarph-daemon] iteration error (continuing): "
                 f"{type(exc).__name__}: {exc}",
                 file=sys.stderr,
@@ -461,7 +532,7 @@ async def _drain_loop(state: DaemonState) -> None:
                 break
             await asyncio.sleep(1)
 
-    print(
+    _print_safe(
         f"[swarph-daemon] shutdown: iterations={state.iterations} "
         f"dms_seen={state.dms_seen} cursor.last_msg_id={state.cursor.get('last_msg_id', 0)}",
         flush=True,
@@ -474,7 +545,7 @@ def _install_signal_handlers(loop: asyncio.AbstractEventLoop, state: DaemonState
 
     def _handler(signum, frame):  # noqa: ARG001
         if not state.shutdown_requested:
-            print(
+            _print_safe(
                 f"[swarph-daemon] signal {signum} received — draining + flushing cursor",
                 flush=True,
             )
@@ -500,7 +571,7 @@ def run_daemon(argv: list[str]) -> int:
     elif self_name:
         state_dir = Path.home() / "swarph_state" / self_name
     else:
-        print(
+        _print_safe(
             "swarph daemon: cannot resolve identity. Pass --self <name> or "
             "--state-dir <path> or set $SWARPH_SELF.",
             file=sys.stderr,
@@ -514,7 +585,7 @@ def run_daemon(argv: list[str]) -> int:
     _write_daemon_pidfile(state_dir)
     token = _resolve_token(args.token_file)
     if not token:
-        print("swarph daemon: empty MESH_GATEWAY_TOKEN", file=sys.stderr)
+        _print_safe("swarph daemon: empty MESH_GATEWAY_TOKEN", file=sys.stderr)
         return 2
 
     state = DaemonState(

{swarph_cli-0.40.0 → swarph_cli-0.40.1/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.40.0
+Version: 0.40.1
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.40.0 → swarph_cli-0.40.1}/src/swarph_cli.egg-info/SOURCES.txt

@@ -136,7 +136,9 @@ tests/test_compress_command.py
 tests/test_compress_levers.py
 tests/test_compress_marker.py
 tests/test_compress_verify.py
+tests/test_console_encoding_e2e.py
 tests/test_daemon_command.py
+tests/test_daemon_console_encoding.py
 tests/test_daemon_delivery.py
 tests/test_delivery_queue.py
 tests/test_display_sanitize.py

{swarph_cli-0.40.0 → swarph_cli-0.40.1}/tests/test_brain_ask_command.py

@@ -17,7 +17,7 @@ from swarph_cli.commands import brain_ask as ba
 
 def test_version_is_0_33_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.40.0"
+    assert swarph_cli.__version__ == "0.40.1"
 
 
 # --- request / response plumbing -------------------------------------------

swarph_cli-0.40.1/tests/test_console_encoding_e2e.py

@@ -0,0 +1,92 @@
+"""END-TO-END: the CLI must survive an 8-bit console with a redirected stdout.
+
+>>> THIS IS THE GAP THE WINDOWS CI LEGS CANNOT COVER, AND THE REASON IS STRUCTURAL. <<<
+Under pytest, `sys.stdout` is a TextIOWrapper with encoding utf-8 and isatty()==False
+ON EVERY PLATFORM — capture substitutes the very object that fails. So a
+console-encoding fault is unreachable from inside a captured test, and adding more
+Windows runners would not have changed that. MEASURED: pytest stdout is utf-8 on Linux
+and on windows-latest alike.
+
+These tests therefore spawn a REAL SUBPROCESS with a REAL 8-bit stdout, which is the
+condition workstation-lc hit: French Windows (cp1252) + Task Scheduler, which REDIRECTS
+stdout — and a redirected stream on Windows uses locale.getpreferredencoding(), not the
+UTF-16 console API. `PYTHONIOENCODING=cp1252` reproduces that exactly, on Linux, in CI,
+with no French Windows anywhere.
+
+WHAT IT COST WHEN NOTHING CHECKED THIS: a hardcoded U+2192 in `_log_dm` raised on every
+DM, `_drain_iteration` aborted, THE CURSOR FROZE AND ZERO DMS WERE DELIVERED — while
+Get-ScheduledTask reported Running and every other surface was green.
+"""
+import os
+import subprocess
+import sys
+import textwrap
+
+import pytest
+
+# The exact shape of the operator line that failed, plus content a French cell sends.
+_HOSTILE = "id=1 from=lab-ovh kind=answer -> 'réponse — arrow → and emoji ✅'"
+
+
+def _run(code: str, encoding: str) -> subprocess.CompletedProcess:
+    """Run in a subprocess with a REDIRECTED, 8-bit stdout — Task Scheduler's shape."""
+    # THE PARENT MUST DECODE WHAT THE CHILD ACTUALLY WROTE. `text=True` decodes with
+    # the PARENT's locale (utf-8 here), so it raises on the child's cp1252 bytes — the
+    # harness for an encoding test having an encoding bug. Decode explicitly, and
+    # errors="replace" so a mangled byte is data rather than an exception.
+    return subprocess.run(
+        [sys.executable, "-c", textwrap.dedent(code)],
+        capture_output=True, timeout=60,
+        encoding=encoding, errors="replace",
+        # INHERIT the real environment and override only what this test controls.
+        # An earlier version passed env={"PATH": "/usr/bin:/bin", ...} — a POSIX path,
+        # in the test written to prove we handle a WINDOWS console. It failed both
+        # Windows legs: the interpreter cannot resolve, and SYSTEMROOT/COMSPEC are
+        # required for a subprocess there. >>> A CROSS-PLATFORM TEST THAT HARDCODES ONE
+        # PLATFORM'S PATH TESTS THE PLATFORM IT RUNS ON, WHICH IS THE ONE THAT WAS
+        # ALREADY FINE. <<<
+        env={**os.environ, "PYTHONIOENCODING": encoding, "PYTHONPATH": "src"},
+    )
+
+
+def test_the_bug_reproduces_without_the_guard():
+    """Sanity: a bare print of non-ASCII to cp1252 DOES fail. If this ever stops
+    failing, this whole file is testing nothing and must be re-examined."""
+    r = _run(f"print({_HOSTILE!r})", "cp1252")
+    assert r.returncode != 0
+    assert "UnicodeEncodeError" in r.stderr
+
+
+def test_log_dm_survives_a_cp1252_stdout(tmp_path):
+    """THE GUARD. The delivery path must not raise on a console that cannot represent
+    the DM — the audit trail is written first and the operator line degrades."""
+    r = _run(f"""
+        import sys
+        from swarph_cli.commands import daemon
+        class S:
+            inbox_log_path = __import__('pathlib').Path({str(tmp_path / 'inbox.log')!r})
+        daemon._log_dm(S(), {{'id': 1, 'created_at': 'now', 'from_node': 'lab-ovh',
+                              'kind': 'answer',
+                              'content': 'réponse — arrow → and emoji ✅'}})
+        print("SURVIVED")
+    """, "cp1252")
+    assert r.returncode == 0, f"delivery path died on an 8-bit console:\n{r.stderr}"
+    assert "SURVIVED" in r.stdout
+
+
+def test_the_audit_trail_is_byte_faithful_under_cp1252(tmp_path):
+    """The console may mangle; the record may not. inbox.log is utf-8 explicitly."""
+    log = tmp_path / "inbox.log"
+    content = "réponse — arrow → and emoji ✅"
+    r = _run(f"""
+        from pathlib import Path
+        from swarph_cli.commands import daemon
+        class S:
+            inbox_log_path = Path({str(log)!r})
+        daemon._log_dm(S(), {{'id': 7, 'created_at': 'now', 'from_node': 'x',
+                              'kind': 'answer', 'content': {content!r}}})
+    """, "cp1252")
+    assert r.returncode == 0, r.stderr
+    import json
+    row = json.loads(log.read_text(encoding="utf-8").strip())
+    assert row["content"] == content, "the audit trail lost characters the console could not print"

swarph_cli-0.40.1/tests/test_daemon_console_encoding.py

@@ -0,0 +1,174 @@
+"""A console that cannot print a DM must not stop the mesh delivering it.
+
+MEASURED on workstation-lc 2026-07-29 — French Windows, cp1252 console, swarph-cli
+0.39.4, Python 3.14, launched by Task Scheduler via `cmd.exe /c`:
+
+    [swarph-daemon] iteration error (continuing): UnicodeEncodeError:
+      'charmap' codec can't encode character '→' in position 65
+
+`_log_dm` printed a HARDCODED U+2192 to a charmap stdout. Every DM raised; every
+`_drain_iteration` aborted; THE CURSOR FROZE AT last_msg_id=10050 AND ZERO DMS WERE
+DELIVERED. The outer handler swallowed it as "iteration error (continuing)", so
+Get-ScheduledTask said Running, the process list looked healthy, and every surface was
+green. >>> THE CELL WAS DM-BLIND AND NOTHING ANYWHERE SAID SO. <<<
+
+Note what was NOT at risk: inbox.log was already opened with encoding="utf-8", so the
+audit trail was intact throughout. Only the OPERATOR-VISIBLE line was unprintable — and
+it took the delivery loop down with it. Hence the ordering fix: audit first, display
+best-effort.
+"""
+import io
+import json
+
+import pytest
+
+from swarph_cli.commands import daemon
+
+
+class _Cp1252Stdout(io.TextIOBase):
+    """A console that can only encode cp1252 — a French Windows box, faithfully."""
+
+    encoding = "cp1252"
+
+    def __init__(self):
+        self.written = []
+
+    def write(self, s):
+        s.encode("cp1252")          # raises UnicodeEncodeError exactly as Windows does
+        self.written.append(s)
+        return len(s)
+
+    def flush(self):
+        pass
+
+
+class _State:
+    def __init__(self, tmp_path):
+        self.inbox_log_path = tmp_path / "inbox.log"
+
+
+ARROW_DM = {"id": 1, "created_at": "2026-07-29T02:00Z", "from_node": "lab-ovh",
+            "kind": "answer", "content": "see -> the thing → and été"}
+
+
+def test_no_hardcoded_non_ascii_in_the_operator_line():
+    """The separator was ours, not the DM's — so it failed on EVERY message, not only
+    ones containing an arrow. An ASCII separator removes the guaranteed-failure case."""
+    import inspect
+    src = inspect.getsource(daemon._log_dm)
+    body = src.split('"""')[-1]          # skip the docstring, which describes the bug
+    assert "→" not in body, "operator line must not hardcode non-ASCII"
+
+
+def test_cp1252_console_does_not_stop_delivery(tmp_path, monkeypatch):
+    """THE LOAD-BEARING TEST. A console that refuses the content must cost a mangled
+    character, never a poll iteration."""
+    fake = _Cp1252Stdout()
+    monkeypatch.setattr(daemon.sys, "stdout", fake)
+    daemon._log_dm(_State(tmp_path), ARROW_DM)        # must NOT raise
+    assert fake.written, "should still have written something to the console"
+
+
+def test_audit_trail_is_written_even_when_the_console_fails(tmp_path, monkeypatch):
+    """Ordering is the fix: audit FIRST, display second. Losing a console line is
+    cosmetic; losing the cursor is a silent outage."""
+    monkeypatch.setattr(daemon.sys, "stdout", _Cp1252Stdout())
+    st = _State(tmp_path)
+    daemon._log_dm(st, ARROW_DM)
+    rows = [json.loads(l) for l in st.inbox_log_path.read_text(encoding="utf-8").splitlines()]
+    assert rows and rows[0]["id"] == 1
+    assert rows[0]["content"] == ARROW_DM["content"], "audit must be byte-faithful"
+
+
+def test_broken_stdout_does_not_stop_delivery(tmp_path, monkeypatch):
+    """A detached service or a full disk closes stdout. Still not a reason to stop."""
+    class _Broken(io.TextIOBase):
+        encoding = "utf-8"
+        def write(self, s): raise OSError("stdout is closed")
+        def flush(self): pass
+
+    monkeypatch.setattr(daemon.sys, "stdout", _Broken())
+    daemon._log_dm(_State(tmp_path), ARROW_DM)        # must NOT raise
+    assert (tmp_path / "inbox.log").exists()
+
+
+def test_utf8_console_is_unaffected(tmp_path, monkeypatch, capsys):
+    """The common path must not be degraded by the fallback."""
+    daemon._log_dm(_State(tmp_path), ARROW_DM)
+    out = capsys.readouterr().out
+    assert "id=1" in out and "lab-ovh" in out
+
+
+# ── COVERAGE, not presence — droplet's finding on PR #158 ────────────────────
+
+def test_every_output_path_in_the_daemon_goes_through_the_guard():
+    """>>> A SYMBOL GREP MEASURES PRESENCE, NOT COVERAGE. <<<
+
+    The first version of the cp1252 guard shipped covering 1 output call out of 13.
+    `grep -c _print_safe` returned 1 on it — the same answer it returns now, with all
+    13 covered. Any check that asks "is the guard there?" passes on both, so this asks
+    the only question that distinguishes them: IS THERE AN UNGUARDED `print`?
+
+    Walks the AST rather than the text so a `print` reached through a differently
+    formatted call, a new function, or a future author's copy-paste is caught. Same
+    reason the merge-check no-merge guard is behavioural and not a substring scan:
+    the claim is about what the module DOES, and text is a proxy for that.
+    """
+    import ast
+    from pathlib import Path
+
+    import swarph_cli.commands.daemon as mod
+
+    src = Path(mod.__file__).read_text(encoding="utf-8")
+    tree = ast.parse(src)
+    guard = next(n for n in ast.walk(tree)
+                 if isinstance(n, ast.FunctionDef) and n.name == "_print_safe")
+    allowed = {id(n) for n in ast.walk(guard)}
+
+    unguarded = [
+        n.lineno for n in ast.walk(tree)
+        if isinstance(n, ast.Call) and isinstance(n.func, ast.Name)
+        and n.func.id == "print" and id(n) not in allowed
+    ]
+    assert not unguarded, (
+        f"unguarded print() at daemon.py lines {unguarded} — on a cp1252 console an "
+        f"arrow or emoji in that line raises UnicodeEncodeError and takes the loop with it"
+    )
+
+
+def test_the_delivery_error_handler_survives_a_character_it_cannot_render():
+    """THE CRASH droplet MEASURED: a raise inside an `except` propagates past the
+    `try` entirely, so the handler whose comment promises it never crashes the loop
+    was itself the crash — reached only when something has ALREADY gone wrong, i.e.
+    exactly when the text is most likely to carry an arrow or an emoji.
+
+    Not a test of the happy DM path: that path was already guarded, so a clean
+    non-ASCII DM round-trip PASSES while this crash survives. The failure path is
+    the one that has to be driven.
+    """
+    import io
+
+    from swarph_cli.commands import daemon as mod
+
+    class Cp1252Stream(io.StringIO):
+        encoding = "cp1252"
+
+        def write(self, s):  # raises exactly where a French Windows console raises
+            s.encode("cp1252")
+            return super().write(s)
+
+    for payload in ("plain ascii", "arrow -> →", "emoji \U0001f512", "check ✓"):
+        stream = Cp1252Stream()
+        try:
+            raise RuntimeError(payload)
+        except RuntimeError as exc:
+            mod._print_safe(
+                f"[swarph-daemon] delivery error (continuing): "
+                f"{type(exc).__name__}: {exc}",
+                stream=stream,
+            )  # must not raise — that IS the bug
+
+    # canary: the model must still be able to fail, or this file asserts nothing
+    import pytest
+    with pytest.raises(UnicodeEncodeError):
+        Cp1252Stream().write("→")

{swarph_cli-0.40.0 → swarph_cli-0.40.1}/tests/test_watchdog.py

@@ -1043,4 +1043,4 @@ def test_parser_defaults_process_name_claude_liveness_cmd_none():
 
 def test_version_is_0_33_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.40.0"
+    assert swarph_cli.__version__ == "0.40.1"