meshcode 2.11.120__tar.gz → 2.11.122__tar.gz

{meshcode-2.11.120 → meshcode-2.11.122}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.120
+Version: 2.11.122
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.120"
+__version__ = "2.11.122"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode/hostd.py

@@ -548,10 +548,21 @@ def _do_respawns(api_key: str, host_id: str) -> int:
         # q1: never touch the fresh terminal). Every recycle is visible now (headless
         # removed, task cba01de5), so this always runs for a recycle.
         _old_vis_pids = _discover_agent_pids(_target) if _is_recycle else []
+        # DEAD-WINDOW REAP (task 70ac6d25, Samuel hit it twice 2026-06-09): an
+        # exit-for-respawn rotation takes THIS plain-respawn path, and the old
+        # window — whose launch script predates the .119 in-script self-closer,
+        # or whose agent died without rc=0 — lingers as "[Process completed]".
+        # Snapshot the target's ALREADY-DEAD launcher windows BEFORE spawning;
+        # close them only after the fresh spawn succeeds. The new window can
+        # never be in the set: it's busy AND post-snapshot. Live windows
+        # (busy=true) are never matched, so a healthy agent is untouchable.
+        _dead_wins = _list_dead_terminal_windows(_target)
         _log(f"{'RECYCLE-RESPAWN' if _is_recycle else 'RESPAWN'} {proj}/{agent} "
              f"(stale {c.get('heartbeat_age_s')}s, count={c.get('respawn_count')})")
         if _spawn_agent(proj, agent, repo_path=c.get("repo_path")):
             _record_spawn(_target)  # count the terminal we just opened, against the breaker
+            if _dead_wins:
+                _close_dead_terminal_windows(_target, _dead_wins)
             if _is_recycle:
                 if _old_vis_pids:
                     _close_old_visible_recycle(_target, _old_vis_pids)  # close old window (DRY-RUN first)
@@ -719,6 +730,71 @@ def _close_old_visible_recycle(target: str, old_pids) -> int:
     return n
 
 
+def _terminal_window_marker(target: str) -> str:
+    """Title marker of `target`'s launcher windows. protocol_handler spawns via
+    ~/.meshcode/launchers/<label>.command (label = _launcher_label's sanitized
+    'proj/agent'), and macOS Terminal keeps that filename in the window title
+    for the window's whole life — verified live 2026-06-10 (running:
+    '… ◂ meshcode-self-improve_backend.command — 80×24'; dead windows keep it
+    too). Mirrors _launcher_label's sanitization so the marker can't drift."""
+    safe = re.sub(r"[^A-Za-z0-9_.-]", "_", target.strip()).strip("_")
+    return (safe[:80] + ".command") if safe else ""
+
+
+def _list_dead_terminal_windows(target: str) -> list:
+    """macOS: ids of Terminal windows that belonged to `target`'s launcher and
+    whose tab is NO LONGER BUSY — the '[Process completed]' orphans a rotation
+    leaves behind (task 70ac6d25). busy=false means no process runs in the tab,
+    so a live agent can never match; the marker filter keeps every non-meshcode
+    window (user shells, other apps' tabs) out of reach. The marker is built
+    from a sanitized charset ([A-Za-z0-9_.-]) so it can't inject AppleScript.
+    Returns [] on non-macOS, no Automation permission, or any error."""
+    if sys.platform != "darwin":
+        return []
+    marker = _terminal_window_marker(target)
+    if not marker:
+        return []
+    script = (
+        'set out to ""\n'
+        'tell application "Terminal"\n'
+        '  repeat with w in (every window)\n'
+        '    try\n'
+        f'      if (busy of selected tab of w) is false and (name of w contains "{marker}") then\n'
+        '        set out to out & (id of w) & linefeed\n'
+        '      end if\n'
+        '    end try\n'
+        '  end repeat\n'
+        'end tell\n'
+        'return out')
+    try:
+        out = subprocess.run(["/usr/bin/osascript", "-e", script],
+                             capture_output=True, text=True, timeout=10).stdout or ""
+        return [int(x) for x in out.split() if x.strip().isdigit()]
+    except Exception:
+        return []
+
+
+def _close_dead_terminal_windows(target: str, window_ids) -> int:
+    """Close (saving no) a pre-collected set of dead launcher windows. The ids
+    come from _list_dead_terminal_windows BEFORE the fresh spawn, so the new
+    window is excluded by construction (same snapshot discipline as
+    _close_old_visible_recycle). 'every window whose id is N' no-ops harmlessly
+    if the user already closed it. Best-effort; returns count closed."""
+    n = 0
+    for wid in window_ids:
+        try:
+            r = subprocess.run(
+                ["/usr/bin/osascript", "-e",
+                 f'tell application "Terminal" to close (every window whose id is {int(wid)}) saving no'],
+                capture_output=True, text=True, timeout=10)
+            if r.returncode == 0:
+                _log(f"DEAD-WINDOW-REAP {target}: closed dead terminal window id {wid} (rotation orphan)")
+                n += 1
+        except Exception:
+            pass
+    return n
+
+
 def _spawn_rate_ok(target: str):
     """Anti-spam circuit breaker. Returns (ok, tripped_burst, reason).
 
@@ -1016,6 +1092,16 @@ def _do_force_kills(api_key: str, host_id: str) -> int:
                 pids.pop(target, None)
                 n += 1
                 _log(f"FORCE-KILL {target}: killed visible pid {pid} (explicit human stop)")
+                # DEAD-WINDOW REAP (task 70ac6d25): the kill leaves the window as
+                # "[Process completed]" — the human pressed Stop, so finish the job.
+                # Brief settle so the process tree exits and busy flips false.
+                try:
+                    time.sleep(1.5)
+                    _wins = _list_dead_terminal_windows(target)
+                    if _wins:
+                        _close_dead_terminal_windows(target, _wins)
+                except Exception:
+                    pass
     st["headless_pids"] = pids
     _save_state(st)
     return n
@@ -1676,6 +1762,52 @@ def _do_version_recycles(api_key: str, host_id: str) -> int:
     return n
 
 
+# c301be69: hold the singleton lock handle for the daemon's lifetime — module
+# global so it's never GC'd (GC would close the fd and release the lock).
+_HOSTD_LOCK_FH = None
+
+
+def _acquire_hostd_singleton():
+    """One hostd per machine (task c301be69 — duplicate-daemon race observed
+    live 2026-06-09: a manual `nohup meshcode hostd run` raced auto-bootstrap,
+    TWO daemons ran ~30s = double respawn/recycle sweeps = storm class).
+
+    Exclusive flock on ~/.meshcode/hostd.lock, held for the process lifetime.
+    The OS releases it on ANY death (crash, kill -9), so there is no
+    stale-pidfile problem; the pid written inside is informational only.
+    Python opens fds CLOEXEC (PEP 446), so the self-reexec-on-version-drift
+    path releases the lock at exec time and the fresh image re-acquires it.
+
+    Returns (fh, status): status in 'acquired' | 'held' | 'error'.
+    'error' means the lock could not be evaluated — callers FAIL OPEN
+    (one possibly-duplicate daemon beats no daemon at all)."""
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        fh = open(STATE_DIR / "hostd.lock", "a+")
+        try:
+            if sys.platform == "win32":
+                import msvcrt
+                fh.seek(0)
+                msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            fh.close()
+            return (None, "held")
+        try:
+            fh.seek(0)
+            fh.truncate()
+            fh.write(str(os.getpid()))
+            fh.flush()
+        except Exception:
+            pass
+        return (fh, "acquired")
+    except Exception as e:
+        _log(f"WARN singleton lock unavailable ({e}) — proceeding unlocked (fail-open)")
+        return (None, "error")
+
+
 def cmd_hostd(args: list) -> int:
     """Entry point for `meshcode hostd ...`."""
     if not args or args[0] in ("-h", "--help"):
@@ -1704,6 +1836,15 @@ def cmd_hostd(args: list) -> int:
         if not api_key:
             _log("FATAL: no api key — run `meshcode login` (key is read from the keychain)")
             return 1
+        # SINGLETON (task c301be69): second instance exits 0 with one log line.
+        # Covers the manual-run vs auto-bootstrap race; _hostd_bootstrap_if_needed
+        # honors it implicitly — its spawned `hostd run` hits this gate and exits.
+        global _HOSTD_LOCK_FH
+        _lk, _lk_status = _acquire_hostd_singleton()
+        if _lk_status == "held":
+            _log("hostd already running on this machine (hostd.lock held) — exiting (singleton c301be69)")
+            return 0
+        _HOSTD_LOCK_FH = _lk  # may be None on 'error' (fail-open)
         # P1 hostd_CRASH_LOOP: the detached Windows daemon has NO console, so crashes (incl hard
         # faults / uncaught exceptions) went to INVISIBLE stderr — hostd.log showed nothing. Capture
         # stderr + faulthandler tracebacks to a file + install an excepthook so the NEXT crash is

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode/meshcode_mcp/realtime.py

@@ -347,7 +347,19 @@ class RealtimeListener:
                         self.message_event.set()
                     except Exception:
                         pass
-                    log.info(f"new message from {enriched['from']}")
+                    # ENJAMBRE G3 (task 3b0e4129): the swarm barrier trigger
+                    # (mig 471) delivers via this same mc_messages INSERT path
+                    # (the runtime has no PG conn for LISTEN mc_swarm_events).
+                    # Log it explicitly so "did the parent wake instantly on
+                    # drain?" is answerable from the agent log alone.
+                    _pl = enriched.get("payload")
+                    if isinstance(_pl, dict) and _pl.get("type") == "swarm_barrier_complete":
+                        log.info(
+                            f"swarm_barrier_complete (swarm={_pl.get('swarm_id')}, "
+                            f"parent_task={_pl.get('parent_task_id')}) — instant wake for {self.agent_name}"
+                        )
+                    else:
+                        log.info(f"new message from {enriched['from']}")
                     if self.notify_callback:
                         try:
                             await self.notify_callback(enriched)

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode/meshcode_mcp/server.py

@@ -590,9 +590,11 @@ def _filter_and_mark(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
 from .sleep_signals import (  # noqa: F401
     _SLEEP_PAYLOAD_TYPES,
     _SLEEP_TEXT_MARKERS,
+    _SWARM_EVENT_TYPES,
     _KNOWN_HUMAN_HANDLES,
     _is_human_authored,
     _looks_like_sleep_signal,
+    _looks_like_swarm_event,
     _split_messages,
 )
 
@@ -4107,11 +4109,14 @@ def _try_auto_complete_on_ship(payload: Dict[str, Any]) -> Optional[Dict[str, An
         return None
 
 
-def _try_auto_complete_on_done_status(task_hint: str) -> Optional[Dict[str, Any]]:
-    """CLOSEGAP-3 sibling: when set_status='done', complete the single
-    in_progress task if there's exactly one. No-op for 0 or >1 active.
-    Summary built from the task_hint + a fallback note.
-    """
+def _try_auto_park_on_done_status(task_hint: str, status: str = "done") -> Optional[Dict[str, Any]]:
+    """CLOSEGAP-3 v2 (task 53767993): when set_status='done'/'sleeping' with
+    exactly ONE in_progress claim, PARK it — roll back to 'claimed' with a
+    checkpoint note (mc_task_checkpoint_park, mig 476) — NEVER complete it.
+    Live incident 2026-06-09T23:30Z: the old auto-COMPLETE closed 250b7c1e as
+    done with zero work at an ordered exit-for-respawn (board lied to Samuel;
+    re-opened as 7a467894). status='done' may now ONLY come from an explicit
+    meshcode_task_complete. No-op for 0 or >1 active claims."""
     try:
         api_key = _get_api_key()
         if not api_key:
@@ -4126,24 +4131,30 @@ def _try_auto_complete_on_done_status(task_hint: str) -> Optional[Dict[str, Any]
         if len(active) != 1:
             return None
         target = active[0]
-        summary = (
-            f"AUTO-CHECKPOINT (CLOSEGAP-3): agent flipped set_status='done'. "
-            f"Task hint: {(task_hint or '(none)')[:200]}. "
-            f"No ship-report content captured — set_status payload-only."
+        note = (
+            f"CHECKPOINT (CLOSEGAP-3 park): agent flipped set_status='{status}' "
+            f"mid-claim (rotation/sleep). Task hint: {(task_hint or '(none)')[:200]}. "
+            f"Work NOT verified complete — resuming agent must task_complete explicitly."
         )
-        result = be.task_complete(api_key, _PROJECT_ID, target["id"], AGENT_NAME, summary=summary)
+        result = be.sb_rpc("mc_task_checkpoint_park", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+            "p_task_id": target["id"],
+            "p_agent": AGENT_NAME,
+            "p_note": note,
+        })
         if not (isinstance(result, dict) and result.get("ok")):
             return None
         try:
             _log_activity_bg(
                 "auto_checkpoint",
-                f"{AGENT_NAME} auto-completed task {target['id'][:8]} on set_status=done",
+                f"{AGENT_NAME} PARKED task {target['id'][:8]} on set_status={status} (claimed again, NOT done)",
             )
         except Exception:
             pass
-        return {"task_id": target["id"][:8], "title": str(target.get("title") or "")[:80]}
+        return {"task_id": target["id"][:8], "title": str(target.get("title") or "")[:80], "parked": True}
     except Exception as e:
-        log.debug(f"[meshcode] auto-checkpoint on done-status failed: {e}")
+        log.debug(f"[meshcode] auto-park on done-status failed: {e}")
         return None
 
 
@@ -5077,15 +5088,15 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
                     }
         except Exception:
             pass  # best-effort; never block set_status
-    # CLOSEGAP-3 (task 69dc5a62, Samuel reframe ce506e0d): when the
-    # agent flips set_status='done' with exactly one active in_progress
-    # claim, auto-complete that claim with a status-driven summary.
+    # CLOSEGAP-3 v2 (task 53767993, was 69dc5a62): when the agent flips
+    # set_status='done'/'sleeping' with exactly one active in_progress claim,
+    # PARK that claim (back to 'claimed' + checkpoint note) — never complete.
     # Baseline (NOT autonomous-gated). Best-effort.
-    if status == "done" and isinstance(resp, dict) and resp.get("ok"):
+    if status in ("done", "sleeping") and isinstance(resp, dict) and resp.get("ok"):
         try:
-            _cp = _try_auto_complete_on_done_status(task)
+            _cp = _try_auto_park_on_done_status(task, status)
             if _cp:
-                resp["auto_checkpointed_task"] = _cp
+                resp["auto_parked_task"] = _cp
         except Exception:
             pass
     return resp

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode/meshcode_mcp/sleep_signals.py

@@ -56,6 +56,38 @@ _SLEEP_TEXT_MARKERS = (
 # server + hook share authority on who counts as a human user.
 _KNOWN_HUMAN_HANDLES = frozenset({"sammybenu", "samuel", "sam"})
 
+# ── ENJAMBRE G3 (task 3b0e4129) — swarm barrier events ──────────────────────
+# The mc_swarm_barrier_check trigger (mig 471) fires when a swarm's tray
+# drains. The runtime has NO raw Postgres connection (PostgREST + Realtime
+# websocket only), so a literal LISTEN on the 'mc_swarm_events' pg_notify
+# channel is impossible — which is why the emitter ALSO inserts an
+# mc_messages row to the parent (mig 471 R4). That row already rides the
+# existing wait transport: Realtime postgres_changes INSERT → message_event
+# wake → instant delivery (DB-poll fallback covers the no-websocket case).
+#
+# This layer adds the SEMANTIC half: classify those payloads into a
+# first-class `swarm_events` field (plus an actionable hint) so the parent
+# agent unambiguously sees "barrier complete → aggregate + close parent"
+# instead of a generic system message. Events stay in `messages` too —
+# every existing wake/refuse/count consumer keeps identical behavior.
+_SWARM_EVENT_TYPES = frozenset({"swarm_barrier_complete"})
+
+_SWARM_HINT = (
+    "swarm barrier complete — the tray is drained. Read each child task's "
+    "completion_summary/deliverables (+ scratchpad rollup if used), aggregate, "
+    "then meshcode_task_complete the parent task."
+)
+
+
+def _looks_like_swarm_event(m: Dict[str, Any]) -> bool:
+    """True when a message is a structured swarm lifecycle event (server-emitted
+    by the barrier trigger). Matches payload.type only — deliberately shaped,
+    sender-independent (the emitter writes from_agent='system')."""
+    pl = m.get("payload") or {}
+    if isinstance(pl, dict):
+        return str(pl.get("type", "")).lower() in _SWARM_EVENT_TYPES
+    return False
+
 
 def _is_human_authored(m: Dict[str, Any]) -> bool:
     """True when the message carries explicit human-user authorship.
@@ -128,6 +160,7 @@ def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
     real: List[Dict[str, Any]] = []
     acks: List[Dict[str, Any]] = []
     dones: List[Dict[str, Any]] = []
+    swarm: List[Dict[str, Any]] = []
     for m in messages:
         t = m.get("type", "msg")
         if t == "ack":
@@ -136,9 +169,19 @@ def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
             dones.append(m)
         else:
             real.append(m)
-    return {
+            # ENJAMBRE G3: ALSO surface barrier events first-class. Additive —
+            # the event stays in `messages` so wake/refuse/count semantics are
+            # byte-identical for every existing consumer; `swarm_events` rides
+            # the **split spreads in server.py into every wait/check envelope.
+            if _looks_like_swarm_event(m):
+                swarm.append(m)
+    out = {
         "messages": real,
         "acks": acks,
         "done_signals": dones,
         "count": len(real),
     }
+    if swarm:
+        out["swarm_events"] = swarm
+        out["swarm_hint"] = _SWARM_HINT
+    return out

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.120
+Version: 2.11.122
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.120 → meshcode-2.11.122}/meshcode.egg-info/SOURCES.txt

@@ -88,4 +88,5 @@ tests/test_setup_path.py
 tests/test_sleep_signals.py
 tests/test_status_enum_coverage.py
 tests/test_stay_on_loop_hook.py
+tests/test_swarm_events.py
 tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.120 → meshcode-2.11.122}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.120"
+version = "2.11.122"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}

meshcode-2.11.122/tests/test_swarm_events.py

@@ -0,0 +1,115 @@
+"""ENJAMBRE G3 runtime (task 3b0e4129) — swarm_barrier_complete delivery.
+
+The mc_swarm_barrier_check trigger (mig 471) emits pg_notify('mc_swarm_events')
+AND inserts an mc_messages row to the parent agent (R4 transport — the runtime
+has no raw PG connection, so the inbox row IS the LISTEN-equivalent; Realtime
+postgres_changes on mc_messages wakes meshcode_wait instantly).
+
+This suite locks in the semantic layer: _split_messages classifies those
+payloads into a first-class `swarm_events` field + `swarm_hint`, WITHOUT
+changing any existing wake/refuse/count semantics (events stay in `messages`).
+"""
+from __future__ import annotations
+
+import unittest
+
+from meshcode.meshcode_mcp.sleep_signals import (
+    _looks_like_swarm_event,
+    _split_messages,
+)
+
+
+def _barrier_msg(swarm_id="11111111-2222-3333-4444-555555555555",
+                 parent_task_id="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+                 sender="system", mtype="system"):
+    return {
+        "from": sender,
+        "type": mtype,
+        "payload": {
+            "type": "swarm_barrier_complete",
+            "swarm_id": swarm_id,
+            "parent_task_id": parent_task_id,
+        },
+    }
+
+
+def _msg(sender="ai-agent", payload=None, mtype="msg"):
+    return {"from": sender, "type": mtype, "payload": payload or {}}
+
+
+class TestLooksLikeSwarmEvent(unittest.TestCase):
+
+    def test_barrier_payload_detected(self):
+        self.assertTrue(_looks_like_swarm_event(_barrier_msg()))
+
+    def test_sender_independent(self):
+        # The emitter writes from_agent='system', but classification is
+        # payload-shaped, not sender-shaped.
+        self.assertTrue(_looks_like_swarm_event(_barrier_msg(sender="anything")))
+
+    def test_plain_system_message_is_not_swarm(self):
+        m = _msg(payload={"type": "task_assigned", "task_id": "x"}, mtype="system")
+        self.assertFalse(_looks_like_swarm_event(m))
+
+    def test_text_mention_is_not_swarm(self):
+        # Prose ABOUT the barrier is not the event.
+        m = _msg(payload={"text": "the swarm_barrier_complete fired earlier"})
+        self.assertFalse(_looks_like_swarm_event(m))
+
+    def test_payload_not_dict(self):
+        self.assertFalse(_looks_like_swarm_event({"from": "x", "payload": "swarm_barrier_complete"}))
+
+    def test_empty_payload(self):
+        self.assertFalse(_looks_like_swarm_event(_msg(payload={})))
+
+
+class TestSplitMessagesSwarmField(unittest.TestCase):
+
+    def test_barrier_lands_in_swarm_events_and_messages(self):
+        out = _split_messages([_barrier_msg()])
+        self.assertEqual(len(out["swarm_events"]), 1)
+        # Back-compat invariant: the event ALSO stays a real message so every
+        # existing wake/refuse path (which checks split["messages"]) still fires.
+        self.assertEqual(len(out["messages"]), 1)
+        self.assertEqual(out["count"], 1)
+        self.assertEqual(len(out["done_signals"]), 0)
+
+    def test_hint_present_only_with_events(self):
+        out = _split_messages([_barrier_msg()])
+        self.assertIn("swarm_hint", out)
+        self.assertIn("task_complete the parent task", out["swarm_hint"])
+
+    def test_no_swarm_keys_on_plain_batch(self):
+        # Additive contract: envelopes without barrier events are byte-identical
+        # to the pre-G3 shape (no empty keys polluting every wait response).
+        out = _split_messages([_msg(payload={"text": "normal chatter"})])
+        self.assertNotIn("swarm_events", out)
+        self.assertNotIn("swarm_hint", out)
+
+    def test_mixed_batch_classification(self):
+        msgs = [
+            _msg(sender="other", payload={"text": "normal chatter"}),
+            _barrier_msg(),
+            _msg(mtype="ack", payload={}),
+            _msg(sender="commander", mtype="broadcast", payload={"type": "got_done"}),
+        ]
+        out = _split_messages(msgs)
+        self.assertEqual(len(out["swarm_events"]), 1)
+        self.assertEqual(len(out["messages"]), 2)   # chatter + barrier
+        self.assertEqual(len(out["acks"]), 1)
+        self.assertEqual(len(out["done_signals"]), 1)
+
+    def test_barrier_does_not_trip_must_exit_path(self):
+        # A barrier completing must NEVER be confused with a sleep signal.
+        out = _split_messages([_barrier_msg()])
+        self.assertEqual(len(out["done_signals"]), 0)
+
+    def test_payload_fields_preserved(self):
+        out = _split_messages([_barrier_msg(swarm_id="s-1", parent_task_id="p-1")])
+        ev = out["swarm_events"][0]["payload"]
+        self.assertEqual(ev["swarm_id"], "s-1")
+        self.assertEqual(ev["parent_task_id"], "p-1")
+
+
+if __name__ == "__main__":
+    unittest.main()