meshcode 2.11.64__tar.gz → 2.11.66__tar.gz

{meshcode-2.11.64 → meshcode-2.11.66}/PKG-INFO

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

{meshcode-2.11.64 → meshcode-2.11.66}/meshcode/__init__.py

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

{meshcode-2.11.64 → meshcode-2.11.66}/meshcode/hostd.py

@@ -252,11 +252,24 @@ def _do_recycles(api_key: str, host_id: str) -> int:
             continue  # task boundary only — never mid-task
         if (now - first) >= float(value) * 3600.0:
             _log(f"RECYCLE {proj}/{agent} (uptime {(now-first)/3600:.1f}h >= {value}h)")
-            if _spawn_agent(proj, agent):
+            # Server-authorized clean-exit (task 548c863e, mig 364): SIGNAL the
+            # recycle instead of spawning. A direct _spawn_agent here duplicates
+            # the still-alive process. mc_request_recycle sets a flag; the
+            # agent's wait-loop consumes it, returns must_exit/reason=recycle,
+            # exits CLEAN (Stop-hook writes the handoff), then the respawn path
+            # (_do_respawns) relaunches it fresh. Recorded via mc_record_recycle
+            # so it's NEVER counted against the crash respawn cap.
+            req = _rpc("mc_request_recycle",
+                       {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
+            if req and req.get("ok") and req.get("requested"):
                 _rpc("mc_record_recycle",
                      {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-                st[key] = now  # reset clock after recycle
+                st[key] = now  # reset clock after signaling recycle
                 n += 1
+            elif req and req.get("ok") and not req.get("requested"):
+                # Agent flipped busy between the roster read and the request —
+                # skip; retry next sweep at the next task boundary.
+                _log(f"SKIP recycle {proj}/{agent}: {req.get('reason','not_requested')}")
     # prune state for agents no longer managed on this host
     for k in [k for k in st if k not in seen]:
         st.pop(k, None)

{meshcode-2.11.64 → meshcode-2.11.66}/meshcode/meshcode_mcp/server.py

@@ -3372,6 +3372,33 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+def _check_recycle_request() -> bool:
+    """Server-authorized recycle (task 548c863e, mig 364).
+
+    The hostd daemon sets mc_agents.recycle_requested_at at a TASK BOUNDARY
+    when an agent exceeds its uptime-recycle policy. This consumes the flag
+    (atomic read+clear via mc_consume_recycle — fires exactly once) so the
+    wait-loop can return must_exit=True/reason=recycle a single time. The
+    agent then exits CLEAN (its Stop-hook writes the handoff; the
+    stay_on_loop hook already releases on must_exit=True), and the respawn
+    path (mc_agents_needing_respawn → hostd._do_respawns) relaunches it fresh
+    with that handoff — no duplicate process, no hard-kill, no lost state.
+    Best-effort: any failure returns False (never blocks the loop).
+    """
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return False
+        resp = be.sb_rpc("mc_consume_recycle", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+            "p_agent_name": AGENT_NAME,
+        })
+        return bool(isinstance(resp, dict) and resp.get("ok") and resp.get("recycle"))
+    except Exception:
+        return False
+
+
 def _try_auto_claim_self_assigned_tasks(max_claims: int = 20) -> List[Dict[str, str]]:
     """URGENT_RUNTIME_FIX_TASK_PULL (Samuel directive 2026-05-26T04:20Z msg
     a15d7ed4 + commander msg 0cfca3f3 AUTOCLAIM_ON_RECONNECT): claim every
@@ -4031,6 +4058,13 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     # surface autonomy on the refused-path too so check
                     # parity holds when wait short-circuits on unread msgs.
                     resp["you_are_autonomous"] = _get_autonomous_mode()
+                    # c0ab14c1 Phase 2: time-awareness on the wait delivery path.
+                    try:
+                        _pa = _promise_awareness(_get_api_key())
+                        if _pa:
+                            resp["time_awareness"] = _pa
+                    except Exception:
+                        pass
                     return resp
                 # Ack-only batch — fall through to wait loop
     except Exception:
@@ -4071,6 +4105,21 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             if result.get("timed_out"):
                 _CONSECUTIVE_IDLE_SECONDS += capped_timeout
 
+                # Server-authorized recycle (task 548c863e): the daemon flagged
+                # us for uptime-recycle at a task boundary. Exit CLEAN now so
+                # the Stop-hook persists a handoff and the respawn path relaunches
+                # us fresh. Checked BEFORE pending_tasks: the fresh session
+                # re-attacks any open tasks on boot, so an outstanding backlog
+                # must not pin a stale, context-heavy session alive.
+                if _check_recycle_request():
+                    _set_state("sleeping", "recycle")
+                    result["must_exit"] = True
+                    result["exit_reason"] = (
+                        "recycle authorized — set status=sleeping and END the session now; "
+                        "hostd will relaunch you fresh with your handoff (do NOT meshcode_wait again)")
+                    result["recycle"] = True
+                    break
+
                 # Check if new tasks appeared while we waited
                 pending_tasks = _get_pending_tasks_summary()
                 if pending_tasks:
@@ -5785,6 +5834,16 @@ def meshcode_boot() -> Dict[str, Any]:
         # Non-fatal: surface that the hints are unavailable but boot succeeds.
         resp.setdefault("time_context_available", False)
 
+    # c0ab14c1 Phase 2: open-promise time-awareness (what I owe / what I'm
+    # waiting on, with overdue/elapsed minutes). Soft-fail; only added when
+    # there's something open.
+    try:
+        _pa = _promise_awareness(api_key)
+        if _pa:
+            resp["time_awareness"] = _pa
+    except Exception:
+        pass
+
     return resp
 
 
@@ -6219,6 +6278,215 @@ def meshcode_remember(
     return result
 
 
+# ----------------- TIME-AWARE PROMISES / EXPECTATIONS (anti-stalemate) -----------------
+# Task c0ab14c1. Backend substrate = mc_promises + mig 371 backoff/re-nudge sweep +
+# mig 372 mc_promises_involving. Semantics: agent_name = RESPONSIBLE party (who must
+# act); to_target = waiter. When an ETA passes unfulfilled the server proactively
+# nudges the RESPONSIBLE agent (backoff/mute), escalates mutual deadlocks to the
+# commander, and routes cross-mesh overdue to the commander. Phase-1 server-side
+# parser already auto-captures explicit ETAs from messages; these tools make it
+# explicit + deterministic.
+
+def _promise_expires_iso(eta_minutes: int) -> Optional[str]:
+    """now()+eta as ISO-8601 UTC. Returns None if eta is out of the 1..1440 horizon."""
+    if not isinstance(eta_minutes, int) or eta_minutes < 1 or eta_minutes > 1440:
+        return None
+    from datetime import datetime as _dt, timezone as _tz, timedelta as _td
+    return (_dt.now(_tz.utc) + _td(minutes=eta_minutes)).isoformat()
+
+
+def _promise_awareness(api_key: str) -> Optional[Dict[str, Any]]:
+    """Compact time-awareness block for boot/wait payloads: what I owe + what I'm
+    waiting on, with overdue/elapsed minutes. None when there's nothing open."""
+    try:
+        r = be.sb_rpc("mc_promises_involving", {
+            "p_api_key": api_key,
+            "p_agent_name": AGENT_NAME,
+        })
+    except Exception:
+        return None
+    if not isinstance(r, dict) or not r.get("ok"):
+        return None
+    owe = r.get("i_owe") or []
+    waiting = r.get("waiting_on") or []
+    if not owe and not waiting:
+        return None
+    return {
+        "i_owe": owe,
+        "waiting_on": waiting,
+        "overdue_i_owe": sum(1 for p in owe if isinstance(p, dict) and p.get("overdue")),
+        "overdue_waiting_on": sum(1 for p in waiting if isinstance(p, dict) and p.get("overdue")),
+        "hint": "Act on overdue items you owe; for items you're waiting on, the server is already nudging the responsible agent. meshcode_fulfill(promise_id) when done.",
+    }
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_promise(to: str, what: str, eta_minutes: int) -> Dict[str, Any]:
+    """Register a time-bound commitment YOU are responsible for: "I'll do <what>
+    for <to> within <eta_minutes>". If the ETA passes unfulfilled, the server
+    proactively pings YOU (exponential backoff, auto-mutes) so nothing stalls
+    waiting on you. Call meshcode_fulfill(promise_id) when done.
+
+    Use this whenever you tell another agent an ETA. Horizon cap = 24h
+    (1440 min) — for longer commitments create a task instead.
+
+    Args:
+        to: the agent you're committing to (the waiter / beneficiary).
+        what: short description of what you'll deliver.
+        eta_minutes: minutes from now until you expect to deliver (1..1440).
+    """
+    if not to or not to.strip():
+        return {"ok": False, "error": "to (recipient agent) is required"}
+    if not what or not what.strip():
+        return {"ok": False, "error": "what (promise text) is required"}
+    expires = _promise_expires_iso(eta_minutes)
+    if expires is None:
+        return {"ok": False, "error": "eta_minutes must be an integer 1..1440 (24h); use a task for longer"}
+    return be.sb_rpc("mc_record_promise", {
+        "p_api_key": _get_api_key(),
+        "p_to_target": to.strip(),
+        "p_text": what.strip(),
+        "p_expires_at": expires,
+        "p_source_msg_id": None,
+        "p_agent_name": AGENT_NAME,   # responsible = me
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_expect(of: str, what: str, eta_minutes: int) -> Dict[str, Any]:
+    """Register that you are WAITING on another agent: "<of> will do <what>
+    within <eta_minutes>". If it doesn't happen in time, the server nudges
+    <of> (the RESPONSIBLE agent) — not you. This is the anti-stalemate path:
+    use it whenever you're blocked on someone else (e.g. "you push first, then
+    I deploy"). Cancel with meshcode_fulfill(promise_id) once they deliver.
+
+    Args:
+        of: the agent you're waiting on (the responsible party).
+        what: short description of what you expect them to do.
+        eta_minutes: minutes from now you expect it by (1..1440).
+    """
+    if not of or not of.strip():
+        return {"ok": False, "error": "of (agent you're waiting on) is required"}
+    if not what or not what.strip():
+        return {"ok": False, "error": "what (expectation text) is required"}
+    expires = _promise_expires_iso(eta_minutes)
+    if expires is None:
+        return {"ok": False, "error": "eta_minutes must be an integer 1..1440 (24h); use a task for longer"}
+    # responsible = `of`; waiter = me. Server nudges `of` when overdue.
+    return be.sb_rpc("mc_record_promise", {
+        "p_api_key": _get_api_key(),
+        "p_to_target": AGENT_NAME,
+        "p_text": what.strip(),
+        "p_expires_at": expires,
+        "p_source_msg_id": None,
+        "p_agent_name": of.strip(),   # responsible = the other agent
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_fulfill(promise_id: str) -> Dict[str, Any]:
+    """Mark a promise/expectation fulfilled — stops all follow-up nudges
+    immediately. Call this the moment the committed work is delivered (or the
+    thing you were waiting on arrives).
+
+    Args:
+        promise_id: the id returned by meshcode_promise / meshcode_expect (or
+            surfaced in a promise_overdue nudge or the boot/wait time_awareness block).
+    """
+    if not promise_id or not str(promise_id).strip():
+        return {"ok": False, "error": "promise_id is required"}
+    return be.sb_rpc("mc_fulfill_promise", {
+        "p_api_key": _get_api_key(),
+        "p_promise_id": str(promise_id).strip(),
+    })
+
+
+# ----------------- PENDING APPROVALS (flagship: GO/no-go gate) -----------------
+# Task bb396c9b. The agent asks for a GO/no-go before a gated action; a human (or an
+# autonomous commander) approves/rejects with one button in the dashboard panel.
+# AUTO-APPROVE: if the project commander is in autonomous_mode AND the action is NOT
+# destructive, mc_request_approval auto-approves at creation. SAFETY FLOOR: a
+# destructive/irreversible action ALWAYS escalates to a human, even in autonomous mode.
+
+_APPROVAL_RISK = ("low", "medium", "high", "critical")
+_APPROVAL_ACTIONS = ("push", "ddl", "deploy", "send", "task_complete", "custom")
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_request_approval(
+    title: str,
+    detail: Optional[str] = None,
+    risk_level: str = "medium",
+    action_type: str = "custom",
+    is_destructive: bool = False,
+    context: Optional[Dict[str, Any]] = None,
+    timeout_seconds: int = 1800,
+) -> Dict[str, Any]:
+    """Request a human/commander GO-no-go approval before a gated action, then BLOCK
+    until it's resolved. Use before anything risky/outward-facing you want a human to
+    confirm (prod DDL, deploy, force-push, external send, spending money, etc.).
+
+    Auto-approves instantly IF the project's commander is in autonomous_mode AND the
+    action is NOT destructive. A destructive/irreversible action ALWAYS waits for a
+    human, even under autonomous_mode (safety floor).
+
+    Args:
+        title: short one-line summary of what you want to do (shown as the panel row).
+        detail: optional markdown detail (the diff/command/plan/target).
+        risk_level: 'low' | 'med' | 'high'.
+        action_type: 'push' | 'ddl' | 'deploy' | 'send' | 'task_complete' | 'custom'.
+        is_destructive: True for irreversible/destructive actions (always human-gated).
+        context: optional jsonb context (diff, command, target ids).
+        timeout_seconds: how long to block waiting for the decision (default 1800).
+
+    Returns: {ok, approval_id, decision: 'approved'|'rejected'|'expired'|'timeout',
+              auto_approved: bool, resolved_by?}.
+    """
+    if not title or not title.strip():
+        return {"ok": False, "error": "title is required"}
+    if risk_level not in _APPROVAL_RISK:
+        return {"ok": False, "error": f"risk_level must be one of {_APPROVAL_RISK}"}
+    if action_type not in _APPROVAL_ACTIONS:
+        return {"ok": False, "error": f"action_type must be one of {_APPROVAL_ACTIONS}"}
+    api_key = _get_api_key()
+    created = be.sb_rpc("mc_request_approval", {
+        "p_api_key": api_key,
+        "p_title": title.strip(),
+        "p_detail": (detail or None),
+        "p_risk_level": risk_level,
+        "p_action_type": action_type,
+        "p_is_destructive": bool(is_destructive),
+        "p_context": context if isinstance(context, dict) else None,
+    })
+    if not isinstance(created, dict) or not created.get("ok"):
+        return created if isinstance(created, dict) else {"ok": False, "error": "create_failed"}
+    approval_id = created.get("approval_id")
+    status = created.get("status")
+    # Auto-approved at creation (autonomous commander, non-destructive) -> return now.
+    if status in ("approved", "auto_approved"):
+        return {"ok": True, "approval_id": approval_id, "decision": status,
+                "auto_approved": (status == "auto_approved"), "resolved_by": created.get("resolved_by")}
+    if status in ("rejected", "expired"):
+        return {"ok": True, "approval_id": approval_id, "decision": status, "auto_approved": False}
+    # Pending -> block-poll until resolved / expired / timeout.
+    import time as _time
+    deadline = _time.monotonic() + max(30, int(timeout_seconds))
+    while _time.monotonic() < deadline:
+        _time.sleep(4)
+        st = be.sb_rpc("mc_approval_status", {"p_api_key": api_key, "p_approval_id": approval_id})
+        if isinstance(st, dict) and st.get("ok"):
+            cur = st.get("status")
+            if cur in ("approved", "auto_approved", "rejected", "expired"):
+                return {"ok": True, "approval_id": approval_id, "decision": cur,
+                        "auto_approved": False, "resolved_by": st.get("resolved_by")}
+    return {"ok": True, "approval_id": approval_id, "decision": "timeout", "auto_approved": False,
+            "hint": "still pending; re-check with the panel or call again"}
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_seed_fixture(

{meshcode-2.11.64 → meshcode-2.11.66}/meshcode.egg-info/PKG-INFO

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

meshcode-2.11.66/meshcode.egg-info/SOURCES.txt

@@ -0,0 +1,88 @@
+README.md
+pyproject.toml
+meshcode/__init__.py
+meshcode/__main__.py
+meshcode/_stop_hook_template.py
+meshcode/ascii_art.py
+meshcode/atomic_push.py
+meshcode/claude_update.py
+meshcode/cli.py
+meshcode/comms_v4.py
+meshcode/compat.py
+meshcode/daemon.py
+meshcode/date_parse.py
+meshcode/doctor.py
+meshcode/error_hints.py
+meshcode/exceptions.py
+meshcode/hostd.py
+meshcode/invites.py
+meshcode/launcher.py
+meshcode/launcher_install.py
+meshcode/preferences.py
+meshcode/protocol_handler.py
+meshcode/protocol_v2.py
+meshcode/quickstart.py
+meshcode/rpc_allowlist.py
+meshcode/run_agent.py
+meshcode/secrets.py
+meshcode/self_update.py
+meshcode/setup_clients.py
+meshcode/supervisor.py
+meshcode/up.py
+meshcode/upload.py
+meshcode.egg-info/PKG-INFO
+meshcode.egg-info/SOURCES.txt
+meshcode.egg-info/dependency_links.txt
+meshcode.egg-info/entry_points.txt
+meshcode.egg-info/requires.txt
+meshcode.egg-info/top_level.txt
+meshcode/meshcode_mcp/__init__.py
+meshcode/meshcode_mcp/__main__.py
+meshcode/meshcode_mcp/backend.py
+meshcode/meshcode_mcp/realtime.py
+meshcode/meshcode_mcp/server.py
+meshcode/meshcode_mcp/sleep_signals.py
+meshcode/meshcode_mcp/test_backend.py
+meshcode/meshcode_mcp/test_boot_timing.py
+meshcode/meshcode_mcp/test_install_guard.py
+meshcode/meshcode_mcp/test_prefs_claude_version.py
+meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_server_wrapper.py
+meshcode/scripts/check_secrets.py
+meshcode/scripts/race_rate_harness.py
+tests/test_auto_update_hardening.py
+tests/test_autonomous_closegap_1.py
+tests/test_autonomous_closegap_2.py
+tests/test_autonomous_closegap_3.py
+tests/test_autonomous_prompt_inject.py
+tests/test_boot_bug_regression.py
+tests/test_color_truecolor.py
+tests/test_core.py
+tests/test_cross_agent_messaging.py
+tests/test_date_parse.py
+tests/test_doctor.py
+tests/test_epistemic_v1_python_sdk.py
+tests/test_epistemic_v1_stop_conditions.py
+tests/test_esc_deaf_state.py
+tests/test_exceptions.py
+tests/test_file_upload.py
+tests/test_init_device_code.py
+tests/test_install_guard.py
+tests/test_lease_sigterm_release.py
+tests/test_mark_read_batch.py
+tests/test_marketplace_ratings.py
+tests/test_migration_integrity.py
+tests/test_realtime_event_freshness.py
+tests/test_rls_cross_tenant.py
+tests/test_rpc_grants.py
+tests/test_rpc_migrations.py
+tests/test_run_agent_dry_run.py
+tests/test_run_agent_no_server_import.py
+tests/test_security_regressions.py
+tests/test_self_update_user_site.py
+tests/test_sentinel.py
+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_wait_open_tasks_contradiction.py

meshcode-2.11.66/meshcode.egg-info/top_level.txt

@@ -0,0 +1 @@
+meshcode

{meshcode-2.11.64 → meshcode-2.11.66}/pyproject.toml

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