meshcode 2.11.119__tar.gz → 2.11.121__tar.gz

{meshcode-2.11.119 → meshcode-2.11.121}/PKG-INFO

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

{meshcode-2.11.119 → meshcode-2.11.121}/meshcode/__init__.py

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

{meshcode-2.11.119 → meshcode-2.11.121}/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

{meshcode-2.11.119 → meshcode-2.11.121}/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.119 → meshcode-2.11.121}/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,
 )
 
@@ -2906,7 +2908,8 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
     # mode-2 soft-fail (R2-3): a malformed in_reply_to (not a valid uuid) would hit
     # the uuid cast at the RPC boundary and reject the WHOLE message. Drop it so the
     # message still sends (pairs with mig463's nonexistent-but-valid-uuid soft-fail).
-    if in_reply_to is not None and not re.fullmatch(
+    import re as _re  # .119 regression: no module-level `re`; local like lines 3809/3942/4008
+    if in_reply_to is not None and not _re.fullmatch(
         r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
         str(in_reply_to)):
         in_reply_to = None

{meshcode-2.11.119 → meshcode-2.11.121}/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.119 → meshcode-2.11.121}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.119 → meshcode-2.11.121}/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.119 → meshcode-2.11.121}/pyproject.toml

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

meshcode-2.11.121/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()