meshcode 2.11.121__tar.gz → 2.11.123__tar.gz

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

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

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

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

{meshcode-2.11.121 → meshcode-2.11.123}/meshcode/hostd.py

@@ -467,7 +467,15 @@ def _do_respawns(api_key: str, host_id: str) -> int:
         if not _BOOT_AUTOSTART:
             _spawn_age = c.get("spawned_age_s")
             _hostd_uptime = time.time() - _HOSTD_STARTED_AT
-            if _spawn_age is None or _spawn_age >= _hostd_uptime:
+            # ALIVE-ON-OUR-WATCH bypass (task baefc8ab part C — live miss 2026-06-10T00:31Z:
+            # front-end exited for respawn minutes after a hostd restart; its spawned_at predated
+            # the restart, the gate read it as a boot-stale leftover and ATE the respawn until a
+            # manual Start). An agent that HEARTBEATED during this daemon's lifetime is not a
+            # reboot leftover — it lived and died on our watch, so its respawn is legitimate.
+            # A true boot-stale leftover has heartbeat_age_s >= uptime (or None).
+            _hb_age = c.get("heartbeat_age_s")
+            _alive_on_our_watch = _hb_age is not None and _hb_age < _hostd_uptime
+            if (_spawn_age is None or _spawn_age >= _hostd_uptime) and not _alive_on_our_watch:
                 _log(f"BOOT-AUTOSTART OFF: skip auto-respawn {proj}/{agent} (desired_state=running set "
                      f"before this hostd start — boot-stale leftover; explicit launch required). "
                      f"Set MESHCODE_BOOT_AUTOSTART=1 to auto-launch at boot.")
@@ -1762,6 +1770,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"):
@@ -1790,6 +1844,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.121 → meshcode-2.11.123}/meshcode/meshcode_mcp/server.py

@@ -4109,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:
@@ -4128,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
 
 
@@ -5079,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
@@ -7436,6 +7445,27 @@ def meshcode_auto_wake_toggle(enabled: bool) -> Dict[str, Any]:
     }
 
 
+@mcp.tool()
+def meshcode_mesh_keep_alive(enabled: bool) -> Dict[str, Any]:
+    """Toggle "mesh prendida" keep-alive for THIS meshwork (task baefc8ab,
+    Samuel 2026-06-10: "quiero dejar la mesh prendida sin tasks — que se
+    mantengan atentos a cualquier mensaje").
+
+    ON: the server sweep (mig 479) WAKES a stopped agent within ~5 min of an
+    unread direct message arriving — sleep stays cheap (zero idle tokens) but
+    the mesh answers. Explicit human Stops are still respected; agents offline
+    >7 days are never resurrected. OFF (default): current behavior.
+
+    Owner or commander only — enforced server-side (mc_set_mesh_keep_alive).
+    """
+    res = be.sb_rpc("mc_set_mesh_keep_alive", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_enabled": bool(enabled),
+    })
+    return res if isinstance(res, dict) else {"error": str(res)}
+
+
 def inbox_resource() -> str:
     """Current pending messages for this agent. Read-only — does NOT mark as read."""
     pending = be.sb_select(

{meshcode-2.11.121 → meshcode-2.11.123}/meshcode/meshcode_mcp/sleep_signals.py

@@ -56,6 +56,35 @@ _SLEEP_TEXT_MARKERS = (
 # server + hook share authority on who counts as a human user.
 _KNOWN_HUMAN_HANDLES = frozenset({"sammybenu", "samuel", "sam"})
 
+# Task 3ec2cd4b (live repro 2026-06-10T00:34Z, msg 62062a6b): Samuel wrote
+# "...que NO se vayan a dormir asi nomas... sabes?" — a COMPLAINT about agents
+# sleeping, the opposite of an authorization — and the bare substring
+# "a dormir" tripped must_exit on the commander mid-crisis. Human TEXT only
+# authorizes sleep when it is directive-SHAPED; in doubt the message degrades
+# to a normal msg (never must_exit). Three guards, human-text path only
+# (structured payload.type/directive is untouched — that's the dashboard
+# button / deliberate-agent path):
+#   LENGTH:   a directive is short ("todos a dormir"); >80 chars is prose.
+#   QUESTION: "?"/"¿" = asking or complaining, not ordering.
+#   NEGATION: a negation token anywhere kills it ("que no se vayan a dormir").
+_HUMAN_DIRECTIVE_MAX_CHARS = 80
+_HUMAN_NEGATION_TOKENS = (
+    " no ", " not ", " nunca ", " jamas ", " jamás ", "que no", "sin que",
+    "don't", "do not", " ni ",
+)
+
+
+def _human_text_is_directive(text: str) -> bool:
+    """True when human text is shaped like an order, not prose about sleep."""
+    if len(text) > _HUMAN_DIRECTIVE_MAX_CHARS:
+        return False
+    if "?" in text or "\u00bf" in text:
+        return False
+    padded = " " + text.strip().lower() + " "
+    if any(tok in padded for tok in _HUMAN_NEGATION_TOKENS):
+        return False
+    return True
+
 # ── 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
@@ -121,7 +150,7 @@ def _looks_like_sleep_signal(m: Dict[str, Any]) -> bool:
             return True
         text = str(pl.get("text", "")).lower()
         if text and any(marker in text for marker in _SLEEP_TEXT_MARKERS):
-            if _is_human_authored(m):
+            if _is_human_authored(m) and _human_text_is_directive(text):
                 return True
     return False
 

{meshcode-2.11.121 → meshcode-2.11.123}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.121 → meshcode-2.11.123}/pyproject.toml

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

{meshcode-2.11.121 → meshcode-2.11.123}/tests/test_sleep_signals.py

@@ -158,3 +158,51 @@ class TestSplitMessages(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestCasualSpanishComplaintGuards(unittest.TestCase):
+    """Task 3ec2cd4b — live repro 2026-06-10T00:34Z (msg 62062a6b): Samuel's
+    COMPLAINT about agents sleeping ("que NO se vayan a dormir asi nomas...")
+    tripped must_exit on the commander. Human text must be directive-shaped."""
+
+    REPRO = (
+        "oye ya me acague los agents se estan exiting and sleepign cuando no "
+        "tienen nada, que no se vayan a dormir asi nomas, porque aveces lo "
+        "querio dejar prendido sabes? que recomeindas, por ejemplo ahroita FE "
+        "no tenia nada asignadno y se fue a dormir  , pero que si el suaurio "
+        "queria dejar su mesh rpendida sin taksks? sin que se fuerman que se "
+        "mantengan atentos a caulqueir mensaje"
+    )
+
+    def test_literal_live_repro_never_sleeps(self):
+        m = _msg(sender="sammybenu", payload={"text": self.REPRO})
+        self.assertFalse(_looks_like_sleep_signal(m))
+        split = _split_messages([m])
+        self.assertEqual(len(split["done_signals"]), 0)
+        self.assertEqual(len(split["messages"]), 1)
+
+    def test_negated_short_directive_blocked(self):
+        m = _msg(sender="sammybenu", payload={"text": "que no se vayan a dormir"})
+        self.assertFalse(_looks_like_sleep_signal(m))
+
+    def test_question_about_sleep_blocked(self):
+        m = _msg(sender="sammybenu", payload={"text": "se fueron a dormir?"})
+        self.assertFalse(_looks_like_sleep_signal(m))
+
+    def test_long_prose_with_marker_blocked(self):
+        m = _msg(sender="sammybenu", payload={
+            "text": "bueno pues al final creo que el plan de hoy salio bien y "
+                    "ya cada quien puede irse a dormir cuando guste, mañana "
+                    "seguimos con lo del deploy y lo de los archivos"})
+        self.assertFalse(_looks_like_sleep_signal(m))
+
+    def test_short_human_directive_still_authorizes(self):
+        for text in ("todos a dormir", "a dormir", "go to sleep", "sleep now"):
+            m = _msg(sender="sammybenu", payload={"text": text})
+            self.assertTrue(_looks_like_sleep_signal(m), text)
+
+    def test_structured_directive_untouched_by_guards(self):
+        # dashboard-button path: payload.type fires regardless of text shape
+        m = _msg(sender="mesh-commander",
+                 payload={"type": "got_done", "text": self.REPRO})
+        self.assertTrue(_looks_like_sleep_signal(m))