swarph-cli 0.69.9__tar.gz → 0.70.0__tar.gz

{swarph_cli-0.69.9/src/swarph_cli.egg-info → swarph_cli-0.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.9
+Version: 0.70.0
 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`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.69.9"
+version = "0.70.0"
 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`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/src/swarph_cli/__init__.py

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

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/src/swarph_cli/commands/mesh.py

@@ -2136,6 +2136,33 @@ _COMPOSER_PLACEHOLDERS = ("Add a follow-up", "Ask Codex to do anything")
 #: running agent into an idle one forever.
 _CURSOR_RUN_HINT = "ctrl+c to stop"
 
+#: A live cursor turn draws a braille spinner and then ``Thinking``,
+#: ``Running``, or ``Working`` on the row directly above the Tip/composer
+#: block. A quote of that row anywhere else, including a code echo, is not
+#: a turn. The match is anchored: stripped text has to start with the glyph.
+_CURSOR_SPINNER_ROW = re.compile(
+    r"^[\u2800-\u28FF]+\s*(?:Thinking|Running|Working)\b"
+)
+
+#: How many non-empty rows at the bottom can hold the cursor composer.
+#: Measured on cursor-lin 2026-09-30: the composer is the 4th non-empty row
+#: from the bottom (composer, task count, model footer, tilde). A quote of
+#: that row higher in the pane is scrollback, not the composer. Blank rows
+#: between those chrome lines do not count: a raw tail of N lines drops the
+#: composer off the window when the screen interleaves blanks.
+_CURSOR_COMPOSER_TAIL = 6
+
+#: The 1.18.33 permission dialog draws ``△ Permission required`` above a
+#: stack of option rows. On the measured screen that row is the 10th
+#: non-empty row from the bottom, outside the composer tail.
+_OPENCODE_PERMISSION_TAIL = 12
+
+
+def _nonempty_tail(lines: list[str], n: int) -> list[str]:
+    """The last ``n`` rows that contain text. Blank rows are not rows."""
+    filled = [ln for ln in lines if ln.strip()]
+    return filled[-n:]
+
 
 def _only_wake_text(content: str) -> bool:
     """True when the composer holds wake text and nothing else.
@@ -2172,19 +2199,21 @@ def _opencode_permission_row(line: str) -> bool:
     return s.startswith("┃") and "△" in s and "Permission required" in s
 
 
+def _is_opencode_composer_row(line: str) -> bool:
+    """One row of the opencode box: the mode row, the ``╹▀`` border, or the
+    permission dialog. A quote of ``┃ Build ·`` above the tail is not this."""
+    s = line.strip()
+    return s.startswith("╹▀") or _opencode_mode_row(line) or _opencode_permission_row(line)
+
+
 def _is_opencode_pane(lines: list[str]) -> bool:
     """The opencode composer box, measured on 1.18.33.
 
-    The input row is a ``┃`` line. The mode row under it names Build or
-    Plan and a ``·``. The bottom of the box is ``╹▀``. The permission
-    dialog keeps the ``┃`` row and drops the mode row and the border.
-    Cursor and claude do not draw any of these.
+    Decided by ``_bottom_tui``: the mode row, the ``╹▀`` border, or the
+    permission dialog has to be the bottom-most composer in the non-empty
+    tail. A cursor pane that merely quotes ``┃ Build ·`` is not opencode.
     """
-    for ln in lines:
-        s = ln.strip()
-        if s.startswith("╹▀") or _opencode_mode_row(ln) or _opencode_permission_row(ln):
-            return True
-    return False
+    return bool(lines) and _bottom_tui(lines) == "opencode"
 
 
 def _opencode_running(lines: list[str]) -> bool:
@@ -2281,29 +2310,115 @@ def _opencode_composer_state(lines: list[str]) -> Optional[str]:
     return "busy"
 
 
-def _is_grok_pane(lines: list[str]) -> bool:
-    """Grok Build composer, measured on sacrificial 1.0.41 and 0.2.51 TUIs.
+def _is_grok_composer_row(lines: list[str], index: int) -> bool:
+    """A grok composer starts at a ``│ ❯`` row. Continuation rows that also
+    start with ``│`` may sit between it and the ``╰`` footer, which is how
+    a wrapped draft is drawn. A cursor diff hunk (``▎``) never counts."""
+    row = lines[index].strip()
+    if row.startswith("▎") or not (row.startswith("│") and "❯" in row):
+        return False
+    j = index + 1
+    while j < len(lines):
+        nxt = lines[j].strip()
+        if nxt.startswith("▎"):
+            return False
+        if nxt.startswith("╰"):
+            return True
+        if nxt.startswith("│"):
+            j += 1
+            continue
+        return False
+    return False
 
-    The footer names ``Grok 4.`` inside the box, or the splash prints
-    ``Grok Build``. History also draws a ``❯`` for the submitted prompt;
-    that row has no box bar, so it is not the composer. A usage-limit
-    modal drops both of those and is recognized by ``_grok_block_reason``.
-    """
-    return any("Grok 4." in ln or ln.strip().startswith("Grok Build") for ln in lines)
 
+def _is_cursor_composer_row(line: str) -> bool:
+    """Any cursor composer row, including a human draft. The empty one
+    reads ``→ Add a follow-up``. A ``▎`` hunk never counts."""
+    row = line.strip()
+    return row.startswith("→") and not row.startswith("▎")
 
-def _grok_input(lines: list[str]) -> Optional[str]:
-    """Text in the live ``│ ❯`` box, '' when empty, None if no box."""
-    row = None
-    for ln in lines:
-        if "❯" in ln and "│" in ln:
-            row = ln
-    if row is None:
+
+def _bottom_tui(lines: list[str]) -> "str | None":
+    """Who owns the bottom-most composer row in the non-empty tail.
+
+    ``"cursor"``, ``"grok"``, or ``"opencode"``. A match above that tail
+    is scrollback. The lower composer wins, so a quoted grok box or a
+    quoted ``┃ Build ·`` row above the cursor composer does not take the pane.
+    """
+    tail = _nonempty_tail(lines, _CURSOR_COMPOSER_TAIL)
+    for i in range(len(tail) - 1, -1, -1):
+        if _is_cursor_composer_row(tail[i]):
+            return "cursor"
+        if _is_grok_composer_row(tail, i):
+            return "grok"
+        if _is_opencode_composer_row(tail[i]):
+            return "opencode"
+    # A permission dialog is taller than the composer tail. Look further
+    # for that one row. A mode row or a cursor/grok composer in the same
+    # stretch is a quote, not a reason to take the pane.
+    wider = _nonempty_tail(lines, _OPENCODE_PERMISSION_TAIL)
+    for i in range(len(wider) - 1, -1, -1):
+        if _is_cursor_composer_row(wider[i]) or _is_grok_composer_row(wider, i):
+            return None
+        if not _is_opencode_composer_row(wider[i]):
+            continue
+        if _opencode_permission_row(wider[i]):
+            return "opencode"
         return None
-    after = row.split("❯", 1)[1]
+    return None
+
+
+def _is_cursor_composer(lines: list[str]) -> bool:
+    """The cursor composer ROW, not a quote of its placeholder.
+
+    The row is the bottom-most composer inside the non-empty tail, the
+    same row ``_composer_state`` reads. Its stripped text has to start
+    with ``→ Add a follow-up``. A mention of that placeholder anywhere
+    else in the pane is not the composer.
+    """
+    return bool(lines) and _bottom_tui(lines) == "cursor"
+
+
+def _is_grok_pane(lines: list[str]) -> bool:
+    """The grok TUI, by the composer row at the bottom of the pane.
+
+    Cursor's footer can read ``Grok 4.7``. That string is not the test.
+    A grok composer is a ``│ ❯`` row immediately followed by ``╰``, and
+    only when that pair is the bottom-most composer in the non-empty tail.
+    A ``│``/``❯`` pair or a ``╰`` / ``always-approve`` pair anywhere else,
+    including a cursor diff hunk that starts with ``▎``, is not a grok pane.
+    A history ``❯`` without the box bar is not the composer. A usage-limit
+    modal drops the box and is recognized by ``_grok_block_reason``.
+    """
+    return bool(lines) and _bottom_tui(lines) == "grok"
+
+
+def _grok_box_text(lines: list[str], index: int) -> str:
+    """The draft inside a grok box, including ``│`` continuation rows."""
+    after = lines[index].split("❯", 1)[1]
     if "│" in after:
         after = after.split("│", 1)[0]
-    return after.strip()
+    parts = [after.strip()]
+    j = index + 1
+    while j < len(lines) and lines[j].strip().startswith("│"):
+        body = lines[j].strip()[1:]
+        if "│" in body:
+            body = body.split("│", 1)[0]
+        parts.append(body.strip())
+        j += 1
+    return " ".join(p for p in parts if p)
+
+
+def _grok_input(lines: list[str]) -> Optional[str]:
+    """Text in the live grok box, '' when empty, None if that box is not
+    the bottom composer. Continuation rows count as part of the draft."""
+    tail = _nonempty_tail(lines, _CURSOR_COMPOSER_TAIL)
+    for i in range(len(tail) - 1, -1, -1):
+        if _is_cursor_composer_row(tail[i]) or _is_opencode_composer_row(tail[i]):
+            return None
+        if _is_grok_composer_row(tail, i):
+            return _grok_box_text(tail, i)
+    return None
 
 
 # One grok screen, measured on the live 0.2.51 pane (52 rows). Lines above
@@ -2421,10 +2536,28 @@ def _agent_running(target: str) -> Optional[bool]:
         return _opencode_running(lines)
     if _is_grok_pane(lines):
         return _grok_running(lines)
-    composer = _composer_line(lines)
-    if composer is None:
+    tail = _nonempty_tail(lines, _CURSOR_COMPOSER_TAIL)
+    composer = _composer_line(tail)
+    if composer is None or not composer.startswith("→"):
         return None
-    return _CURSOR_RUN_HINT in composer
+    if _CURSOR_RUN_HINT in composer:
+        return True
+    # The spinner is the non-empty row directly above the Tip/composer
+    # block: the Tip row when it is present, otherwise the composer.
+    # No other row in the tail can make the pane read as running.
+    idx = None
+    for i in range(len(tail) - 1, -1, -1):
+        if _is_cursor_composer_row(tail[i]):
+            idx = i
+            break
+    if idx is None or idx == 0:
+        return False
+    anchor = idx - 1
+    if tail[anchor].strip().startswith("Tip:"):
+        if anchor == 0:
+            return False
+        anchor -= 1
+    return bool(_CURSOR_SPINNER_ROW.match(tail[anchor].strip()))
 
 
 def _composer_state(target: str) -> Optional[str]:
@@ -2452,6 +2585,12 @@ def _composer_state(target: str) -> Optional[str]:
     if _is_grok_pane(lines):
         return _grok_composer_state(lines)
     composer = _composer_line(lines)
+    if composer is not None and composer.startswith("→"):
+        # A cursor marker above the bottom tail is a quoted row. The
+        # composer itself is off-screen, so this pane is not readable.
+        composer = _composer_line(_nonempty_tail(lines, _CURSOR_COMPOSER_TAIL))
+        if composer is None or not composer.startswith("→"):
+            return None
     if composer is None:
         return None
     content = composer[1:].strip()
@@ -2976,8 +3115,11 @@ def _monitor_loop(state: MonitorState) -> int:
         try:
             _monitor_iteration(state)
         except KeyboardInterrupt:
+            # An interrupt during an iteration is not a clean return. Swallowing
+            # it and returning 0 made _run_pinned delete monitor.pid, so the
+            # watchdog then reported the cell unsupervised.
             state.shutdown_requested = True
-            break
+            raise
         except Exception as exc:
             print(f"{state.log_prefix} iteration error: {type(exc).__name__}: {exc}",
                   file=sys.stderr)

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/src/swarph_cli/commands/monitor.py

@@ -345,13 +345,17 @@ def _service_leaf(text: "str | None") -> "str | None":
 def _supervisor_for_pidfile(explicit: "str | None") -> "str | None":
     """What start writes into monitor.pid.
 
-    An explicit claim wins. Otherwise read this process's own cgroup now,
-    while the pid is still ours. A later status must not open /proc/<pid>
-    for a dead monitor: that pid may have been reused.
+    An explicit claim wins over the cgroup. Otherwise record a unit only
+    when its name says it supervises a monitor (swarph-monitor*.service).
+    A foreign leaf such as claude-tmux@X.service is not a monitor supervisor.
+    The read is this process's own cgroup, taken now, while the pid is ours.
     """
     if explicit:
         return explicit
-    return _service_leaf(_read_cgroup(os.getpid()))
+    leaf = _service_leaf(_read_cgroup(os.getpid()))
+    if leaf and leaf.startswith("swarph-monitor"):
+        return leaf
+    return None
 
 
 def _derive_systemd_unit(pid: "int | None") -> "str | None":
@@ -641,12 +645,16 @@ def _run_pinned(state, pidfile: Path, self_name: str, sinks: list, poll_s: int,
                 supervisor: "str | None" = None) -> int:
     mesh.write_pidfile(pidfile, self_name=self_name, sinks=sinks, poll_s=poll_s,
                        supervisor=supervisor)
+    clean = False
     try:
-        return mesh._monitor_loop(state)
+        result = mesh._monitor_loop(state)
+        clean = True
+        return result
     finally:
-        # Only clear the pidfile if it is still OURS — a racing `start` may have
-        # legitimately reclaimed it, and deleting its record would strand it.
-        if mesh.pidfile_status(pidfile)[0] == "live_ours":
+        # A clean return can drop the file. SIGINT and any other unwind must
+        # not: the recorded supervisor is what the watchdog names after the
+        # process is gone. `monitor stop` still deletes the file itself.
+        if clean and mesh.pidfile_status(pidfile)[0] == "live_ours":
             pidfile.unlink(missing_ok=True)
 
 

{swarph_cli-0.69.9 → swarph_cli-0.70.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.9
+Version: 0.70.0
 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`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -256,6 +256,7 @@ tests/test_957_auth_http.py
 tests/test_959_venv_interpreter.py
 tests/test_960_channel.py
 tests/test_960_ensure_monitor_heartbeat.py
+tests/test_961_cursor_grok_footer.py
 tests/test_963_plugin_manifest.py
 tests/test_964_channel_cell.py
 tests/test_965_mesh_wait.py

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/tests/test_644_monitor_supervision.py

@@ -76,23 +76,98 @@ def test_pidfile_records_supervisor_when_given(tmp_path):
     assert rec["supervisor"] == "task:Swarph cursor-win Monitor"
 
 
-def test_start_records_the_cgroup_unit_and_keeps_it_after_the_process(monkeypatch, tmp_path):
-    """A scratch transient unit is written at start from this process's cgroup.
+def _start_once(monkeypatch, tmp_path, cgroup, extra=()):
+    _env(monkeypatch)
+    monkeypatch.setattr(monitor, "_verify_self_is_registered",
+                        lambda *a, **k: (True, "registered"))
+    monkeypatch.setattr(mesh, "_monitor_iteration", lambda state: None)
+    monkeypatch.setattr(monitor, "_read_cgroup", lambda pid: cgroup)
+    assert _run(["start", "--once", *extra], tmp_path) == 0
+    return json.loads((tmp_path / "monitor.pid").read_text(encoding="utf-8"))
 
-    The pidfile is what a later watchdog reads. The key stays when the
-    process is gone; this test does not open another process's listing.
+
+def test_a_swarph_monitor_cgroup_is_recorded_and_a_foreign_one_is_not(monkeypatch, tmp_path):
+    """Only a swarph-monitor*.service leaf is a monitor supervisor.
+
+    claude-tmux@X.service and any other foreign unit are not recorded.
+    An explicit --supervisor still wins over the cgroup leaf; if it stops
+    winning, the recorded value is the leaf and this assertion fails.
     """
+    for unit in (
+        "swarph-monitor.service",
+        "swarph-monitor-gemini-researcher.service",
+        "swarph-monitor@fixture-cell.service",
+    ):
+        rec = _start_once(monkeypatch, tmp_path, f"0::/system.slice/{unit}\n")
+        assert rec["supervisor"] == unit
+        (tmp_path / "monitor.pid").unlink()
+    rec = _start_once(
+        monkeypatch, tmp_path, "0::/user.slice/claude-tmux@123.service\n")
+    assert "supervisor" not in rec
+    (tmp_path / "monitor.pid").unlink()
+    rec = _start_once(
+        monkeypatch, tmp_path, "0::/system.slice/swarph-monitor.service\n",
+        extra=("--supervisor", "task:Named"))
+    assert rec["supervisor"] == "task:Named"
+
+
+def test_interrupt_inside_the_real_loop_keeps_the_supervisor(monkeypatch, tmp_path):
+    """Fails at 8b4d11f on an assertion.
+
+    KeyboardInterrupt raised inside the real iteration used to be swallowed,
+    the loop returned 0, and _run_pinned deleted monitor.pid. The loop itself
+    is not patched.
+    """
+    def raise_inside(_state):
+        raise KeyboardInterrupt
+
+    monkeypatch.setattr(mesh, "_monitor_iteration", raise_inside)
+    state = mesh.MonitorState(
+        self_name="fixture-cell", state_dir=tmp_path,
+        gateway="http://gateway.test", token="tok", sinks=[])
+    pidfile = tmp_path / "monitor.pid"
+    with pytest.raises(KeyboardInterrupt):
+        monitor._run_pinned(state, pidfile, "fixture-cell", [], 30,
+                            supervisor="swarph-monitor.service")
+    assert pidfile.exists()
+    rec = json.loads(pidfile.read_text(encoding="utf-8"))
+    assert rec["supervisor"] == "swarph-monitor.service"
+
+    rec["pid"] = 4000000
+    pidfile.write_text(json.dumps(rec), encoding="utf-8")
     _env(monkeypatch)
+    monkeypatch.setattr(mesh, "_monitor_iteration", lambda _state: None)
     monkeypatch.setattr(monitor, "_verify_self_is_registered",
                         lambda *a, **k: (True, "registered"))
-    monkeypatch.setattr(mesh, "_monitor_iteration", lambda state: None)
-    monkeypatch.setattr(
-        monitor, "_read_cgroup",
-        lambda pid: "0::/user.slice/scratch-761.service\n")
     assert _run(["start", "--once"], tmp_path) == 0
-    rec = json.loads((tmp_path / "monitor.pid").read_text(encoding="utf-8"))
-    assert rec["supervisor"] == "scratch-761.service"
-    assert rec["pid"] == os.getpid()
+    reclaimed = json.loads(pidfile.read_text(encoding="utf-8"))
+    assert reclaimed["pid"] == os.getpid()
+
+
+def test_sigint_and_an_exception_leave_the_recorded_supervisor(monkeypatch, tmp_path):
+    """Unwinding used to unlink monitor.pid, so the watchdog then said unsupervised."""
+    pidfile = tmp_path / "monitor.pid"
+
+    def raise_kbd(_state):
+        raise KeyboardInterrupt
+
+    monkeypatch.setattr(mesh, "_monitor_loop", raise_kbd)
+    with pytest.raises(KeyboardInterrupt):
+        monitor._run_pinned(object(), pidfile, "fixture-cell", [], 30,
+                            supervisor="swarph-monitor.service")
+    assert json.loads(pidfile.read_text(encoding="utf-8"))["supervisor"] == (
+        "swarph-monitor.service")
+
+    def raise_exc(_state):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(mesh, "_monitor_loop", raise_exc)
+    pidfile.unlink()
+    with pytest.raises(RuntimeError):
+        monitor._run_pinned(object(), pidfile, "fixture-cell", [], 30,
+                            supervisor="swarph-monitor-gemini-researcher.service")
+    assert json.loads(pidfile.read_text(encoding="utf-8"))["supervisor"] == (
+        "swarph-monitor-gemini-researcher.service")
 
 
 def test_start_does_not_record_the_session_manager(monkeypatch, tmp_path):

{swarph_cli-0.69.9 → swarph_cli-0.70.0}/tests/test_739_wake_writer.py

@@ -429,3 +429,51 @@ def test_main_sends_one_writer_down_dm_and_does_not_start(tmp_path):
     assert "token-file" not in text
     assert "monitor start" not in text
     assert "gridiron" not in text
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="Windows cannot execute the POSIX swarph stub as argv0",
+)
+def test_main_names_the_recorded_supervisor_not_the_ownership_fallback(tmp_path):
+    """Fails if main() passes None instead of recorded_supervisor.
+
+    Ownership would then name the template unit. The pidfile names the
+    non-template unit, and that is the string the send must carry.
+    """
+    from swarph_cli.commands.mesh import write_pidfile
+
+    root = tmp_path / "state"
+    _cell(root, "fixture-cell", fresh=True)
+    write_pidfile(
+        root / "fixture-cell" / "mesh-sidecar" / "monitor.pid",
+        self_name="fixture-cell", sinks=[], poll_s=30,
+        supervisor="swarph-monitor.service")
+    stub = tmp_path / "swarph"
+    log = tmp_path / "calls.log"
+    stub.write_text(textwrap.dedent("""\
+        #!/bin/sh
+        echo "$@" >> "$STUB_LOG"
+        case "$1 $2" in
+          "monitor status") exit 2 ;;
+          *) exit 0 ;;
+        esac
+    """), encoding="utf-8")
+    stub.chmod(0o755)
+    env = {
+        **os.environ,
+        "PYTHONPATH": os.path.abspath("src"),
+        "SWARPH_STATE_ROOT": str(root),
+        "WAKE_WATCHDOG_STATE": str(tmp_path / "wake.json"),
+        "SWARPH_BIN": str(stub),
+        "STUB_LOG": str(log),
+    }
+    env.pop("SWARPH_SELF", None)
+    proc = subprocess.run(
+        [sys.executable, "-m", "swarph_cli.scripts.wake_watchdog",
+         "--as", "lab-ovh", "--escalate", "drop-on-meta-edge"],
+        env=env, capture_output=True, text=True)
+    assert proc.returncode == 0
+    text = log.read_text(encoding="utf-8")
+    assert "supervised by swarph-monitor.service" in text
+    assert "swarph-monitor@fixture-cell.service" not in text