meshcode 2.11.42__tar.gz → 2.11.44__tar.gz

{meshcode-2.11.42 → meshcode-2.11.44}/PKG-INFO

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

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode/__init__.py

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

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode/comms_v4.py

@@ -1602,13 +1602,23 @@ def show_status(project=None):
             continue
 
         print(f"\n  [{proj['name']}]")
+        _autonomous_count = 0
         for a in agents:
             # Count pending
             pending = sb_select("mc_messages",
                 f"project_id=eq.{proj['id']}&to_agent=eq.{quote(a['name'])}&read=eq.false&type=neq.ack")
             pcount = len(pending)
             icon = "●" if pcount > 0 else "○"
-            print(f"    {icon} {a['name']:<14} {a.get('role',''):<25} pending: {pcount}")
+            _auto_marker = " 🔆" if a.get("autonomous_mode") else ""
+            if a.get("autonomous_mode"):
+                _autonomous_count += 1
+            print(f"    {icon} {a['name']:<14} {a.get('role',''):<25} pending: {pcount}{_auto_marker}")
+        # AUTONOMOUS-MODE-UNIVERSAL P8 (task f57aa2d2): if multi-agent mesh
+        # has 0% autonomous adoption, surface a 1-line hint so users see the
+        # bottleneck without reading a memo. Hint hidden when single-agent
+        # mesh or any agent is already autonomous (signal-only, no noise).
+        if len(agents) >= 2 and _autonomous_count == 0:
+            print(f"    💡 0/{len(agents)} agents autonomous. Re-run each with `--autonomous` (or `export MESHCODE_AUTONOMOUS=1`) to enable parallel self-driven work.")
     print()
 
 
@@ -2734,7 +2744,7 @@ if __name__ == "__main__":
 
     # Strip bare boolean flags from argv before parsing so they don't end
     # up as positional args (e.g. --compact is a bare flag, not key=value).
-    BARE_FLAGS = {"--compact", "--legacy", "--no-hook", "--mcp-only"}
+    BARE_FLAGS = {"--compact", "--legacy", "--no-hook", "--mcp-only", "--autonomous"}
     _bare_present = {a.lstrip("-") for a in sys.argv[2:] if a in BARE_FLAGS}
     _argv_for_parse = [a for a in sys.argv[2:] if a not in BARE_FLAGS]
 
@@ -3038,6 +3048,45 @@ if __name__ == "__main__":
         proj = sys.argv[2] if len(sys.argv) > 2 else None
         show_status(proj)
 
+    elif cmd in ("wake-all", "wakeall"):
+        # AUTONOMOUS-MODE-UNIVERSAL P9 (task f57aa2d2): print copy-paste
+        # launch commands for every offline agent in a meshwork. No process
+        # control (those terminals are gone); just frictionless bootstrap.
+        proj = sys.argv[2] if len(sys.argv) > 2 else None
+        if not proj:
+            print("Usage: meshcode wake-all <project>")
+            sys.exit(1)
+        api_key = _load_api_key_for_cli()
+        if not api_key:
+            print("[meshcode] Not logged in. Run: meshcode login <api_key>")
+            sys.exit(1)
+        _projs = sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+        _agents = []
+        if isinstance(_projs, dict) and _projs.get("projects"):
+            for _p in _projs["projects"]:
+                if _p.get("name") == proj:
+                    _agents = _p.get("agents") or []
+                    break
+        if not _agents:
+            print(f"[meshcode] No agents found in meshwork '{proj}'. Check the name with `meshcode projects`.")
+            sys.exit(1)
+        _offline = [a for a in _agents if a.get("status") in ("offline", "sleeping", None)]
+        _online  = [a for a in _agents if a not in _offline]
+        print(f"[meshcode] meshwork '{proj}': {len(_online)} online, {len(_offline)} offline.")
+        if not _offline:
+            print(f"[meshcode] ✓ All agents already online. Nothing to wake.")
+            sys.exit(0)
+        print(f"[meshcode]")
+        print(f"[meshcode] Copy-paste these into separate terminal panes to wake the offline agents")
+        print(f"[meshcode] in autonomous mode (so they self-progress without per-step prompting):")
+        print(f"[meshcode]")
+        for a in _offline:
+            print(f"  meshcode run {proj}/{a.get('name', '?')} --autonomous")
+        print(f"[meshcode]")
+        print(f"[meshcode]   Tip: `export MESHCODE_AUTONOMOUS=1` once in your shell rc, then you")
+        print(f"[meshcode]   can drop the `--autonomous` flag for the rest of the session.")
+        sys.exit(0)
+
     elif cmd in ("projects", "list", "ls"):
         list_projects()
 
@@ -3259,9 +3308,16 @@ if __name__ == "__main__":
             else:
                 print("[meshcode] Login required. Run: meshcode login <api_key>")
                 sys.exit(1)
+        # AUTONOMOUS-MODE-UNIVERSAL (task f248d98e): --autonomous flag OR
+        # MESHCODE_AUTONOMOUS=1 env var → register-time autonomous=true.
+        # Memo decision Q3: scope is `meshcode run` + add-agent. Env var
+        # acts as shell-session default; explicit flag wins per-launch.
+        autonomous_env = (os.environ.get("MESHCODE_AUTONOMOUS", "").strip().lower()
+                          in ("1", "true", "yes", "on"))
+        autonomous = bool(flags.get("autonomous")) or autonomous_env
         import importlib
         _run = importlib.import_module("meshcode.run_agent").run
-        sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override, dry_run=dry_run))
+        sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override, dry_run=dry_run, autonomous=autonomous))
 
     elif cmd == "scan":
         # meshcode scan — detect identicon from stdin/clipboard and launch agent
@@ -3736,7 +3792,7 @@ if __name__ == "__main__":
             "setup", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
             "help", "init", "doctor", "compat", "upgrade", "profile", "validate-sessions", "wake-headless",
-            "supervisor", "upload", "quickstart", "patch-hooks",
+            "supervisor", "upload", "quickstart", "patch-hooks", "wake-all",
         ]
         # Simple fuzzy: prefix match + Levenshtein-like best match
         suggestions = [c for c in known_cmds if c.startswith(cmd)]

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode/meshcode_mcp/backend.py

@@ -615,12 +615,30 @@ def register_agent(project: str, name: str, role: str = "", api_key: Optional[st
                   f"project_id=eq.{project_id}&name=eq.{quote(name)}",
                   {"task": role})
 
-    return {
+    # AUTONOMOUS-MODE-UNIVERSAL (task f248d98e Phase 1): if launched with
+    # `meshcode run --autonomous` or MESHCODE_AUTONOMOUS=1, flip autonomous
+    # mode at register-time. RPC mc_agent_set_autonomous exists per mig 354.
+    # Best-effort: register success is reported even if autonomous flip fails.
+    _autonomous_out: Optional[bool] = None
+    if os.environ.get("MESHCODE_AUTONOMOUS", "").strip().lower() in ("1", "true", "yes", "on"):
+        _set_resp = sb_rpc("mc_agent_set_autonomous", {
+            "p_api_key": _ak or "",
+            "p_project_id": project_id,
+            "p_agent_name": name,
+            "p_enabled": True,
+        })
+        if isinstance(_set_resp, dict) and _set_resp.get("ok"):
+            _autonomous_out = True
+
+    out = {
         "registered": True,
         "project_id": project_id,
         "agent_name": name,
         "agent_id": result.get("agent_id") if isinstance(result, dict) else None,
     }
+    if _autonomous_out is not None:
+        out["autonomous_mode"] = _autonomous_out
+    return out
 
 
 # TTL cache for resolve_agent_name — avoids N+1 queries on every send().

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode/meshcode_mcp/server.py

@@ -3541,6 +3541,10 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                         _snap = _get_mesh_online_snapshot()
                         if _snap is not None:
                             resp["mesh_online_snapshot"] = _snap
+                    # AUTONOMOUS-MODE-UNIVERSAL (task f248d98e Phase 1):
+                    # 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()
                     return resp
                 # Ack-only batch — fall through to wait loop
     except Exception:
@@ -3667,10 +3671,13 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             _snapshot = _get_mesh_online_snapshot()
             if _snapshot is not None:
                 result["mesh_online_snapshot"] = _snapshot
-        # AUTONOMOUS-MODE-1-RUNTIME: surface the flag so the LLM knows
-        # whether to operate proactively.
+        # AUTONOMOUS-MODE-1-RUNTIME + UNIVERSAL (task f248d98e Phase 1):
+        # surface the flag so the LLM knows whether to operate proactively.
+        # `you_are_autonomous` is the canonical field per commander memo
+        # decisions msg 29cae7f9; `autonomous_mode` retained for back-compat.
         if isinstance(result, dict):
             result["autonomous_mode"] = _autonomous
+            result["you_are_autonomous"] = _autonomous
         return result
     finally:
         _IN_WAIT = False
@@ -4019,6 +4026,11 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark
     _ctx = _calendar_context_for_self()
     if _ctx is not None:
         result["calendar_context"] = _ctx
+    # AUTONOMOUS-MODE-UNIVERSAL (task f248d98e Phase 1): surface autonomous
+    # state on every check so agents have constant awareness without extra
+    # tool calls. Uses 15s-TTL cache (_get_autonomous_mode), one RPC per cache
+    # window — negligible cost on the inbox poll path.
+    result["you_are_autonomous"] = _get_autonomous_mode()
     return result
 
 
@@ -4087,9 +4099,13 @@ def meshcode_status() -> Dict[str, Any]:
                 "task": a.get("task", ""),
                 "last_heartbeat": a.get("last_heartbeat"),
                 "idle_seconds": _idle_seconds(a.get("last_response_at")),
+                "autonomous_mode": bool(a.get("autonomous_mode")),
             }
             for a in agents
         ],
+        # AUTONOMOUS-MODE-UNIVERSAL (task f248d98e Phase 1): constant
+        # awareness of self autonomy on the status path too.
+        "you_are_autonomous": _get_autonomous_mode(),
     }
 
 
@@ -5350,20 +5366,39 @@ def meshcode_create_meshwork(name: str) -> Dict[str, Any]:
 
 @mcp.tool()
 @with_working_status
-def meshcode_add_agent(name: str, role: str = "") -> Dict[str, Any]:
+def meshcode_add_agent(name: str, role: str = "", autonomous: bool = False) -> Dict[str, Any]:
     """Add an agent to the current meshwork. Tell user to run 'meshcode setup <project> <name>' then 'meshcode run <name>'.
 
     Args:
         name: Agent name.
         role: Agent role description.
+        autonomous: If True, immediately flip the new agent into autonomous
+            mode (decide+execute+report cadence; escalate only for risky/
+            destructive ops). Task f248d98e Phase 1.
     """
     effective_role = role or "MCP-connected agent"
-    result = be.register_agent(PROJECT_NAME, name, effective_role, api_key=_get_api_key())
+    # AUTONOMOUS-MODE-UNIVERSAL: thread the autonomous param via env so
+    # register_agent picks it up at flip-time. Saved + restored to avoid
+    # contaminating the parent process state.
+    _prev_auto = os.environ.get("MESHCODE_AUTONOMOUS")
+    if autonomous:
+        os.environ["MESHCODE_AUTONOMOUS"] = "1"
+    try:
+        result = be.register_agent(PROJECT_NAME, name, effective_role, api_key=_get_api_key())
+    finally:
+        if autonomous:
+            if _prev_auto is None:
+                os.environ.pop("MESHCODE_AUTONOMOUS", None)
+            else:
+                os.environ["MESHCODE_AUTONOMOUS"] = _prev_auto
     warn = _role_warning(name, effective_role)
     if isinstance(result, dict) and not result.get("error"):
-        out: Dict[str, Any] = {"ok": True, "agent": name, "next_step": f"Run: meshcode setup {PROJECT_NAME} {name} && meshcode run {name}"}
+        run_hint = f"meshcode run {name}" + (" --autonomous" if autonomous else "")
+        out: Dict[str, Any] = {"ok": True, "agent": name, "next_step": f"Run: meshcode setup {PROJECT_NAME} {name} && {run_hint}"}
         if warn:
             out["warning"] = warn
+        if autonomous and result.get("autonomous_mode"):
+            out["autonomous_mode"] = True
         return out
     return result or {"error": "failed to add agent"}
 

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode/run_agent.py

@@ -678,7 +678,7 @@ def _preflight_heartbeat(agent: str, project: str) -> None:
         print(f"[meshcode]   Pre-flight heartbeat skipped: {e}", file=sys.stderr)
 
 
-def run(agent: str, project: Optional[str] = None, editor_override: Optional[str] = None, permission_override: Optional[str] = None, dry_run: bool = False) -> int:
+def run(agent: str, project: Optional[str] = None, editor_override: Optional[str] = None, permission_override: Optional[str] = None, dry_run: bool = False, autonomous: bool = False) -> int:
     """Launch the user's editor with ONLY the named agent's MCP server loaded.
 
     dry_run: when True, exercise the full bootstrap codepath (auth check,
@@ -688,7 +688,15 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     "[meshcode] DRY-RUN OK: ..." and return 0. Designed to catch bootstrap-
     class bugs (import-time sys.exit, missing env-var guards, broken cross-
     process imports — cf. BUG-COMMANDER-MCP-BOOT 2026-05-20) before publish.
+
+    autonomous: when True (via `--autonomous` flag or MESHCODE_AUTONOMOUS=1),
+    propagate MESHCODE_AUTONOMOUS=1 into the child env so the MCP server
+    boot path flips mc_agents.autonomous_mode=true at register time.
+    Task f248d98e Phase 1 (no-DDL subset).
     """
+    # Propagate autonomous flag to the editor + MCP child via env var.
+    if autonomous:
+        os.environ["MESHCODE_AUTONOMOUS"] = "1"
     # Non-blocking self-update check (consumes prior result, may spawn bg pip).
     # Skip in dry-run — we don't want CI / pre-publish smokes to fork a pip.
     if not dry_run:

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode/setup_clients.py

@@ -1372,6 +1372,43 @@ Call `meshcode_wait` now.
     print(f"[meshcode]")
     print(f"[meshcode]   Closing the editor window flips this agent offline.")
     print(f"[meshcode]   Other agents stay independent — no cross-window pollution.")
+
+    # AUTONOMOUS-MODE-UNIVERSAL P6 (task f57aa2d2): if this agent makes the
+    # 2nd+ in the meshwork AND no agent has autonomous_mode=true AND the
+    # user didn't already opt in via env var, surface a one-line nudge.
+    # Best-effort — never block setup on telemetry failure.
+    if os.environ.get("MESHCODE_AUTONOMOUS", "").strip().lower() not in ("1", "true", "yes", "on"):
+        try:
+            from urllib.request import Request as _Req, urlopen as _urlopen
+            _body = json.dumps({
+                "p_api_key": api_key,
+                "p_project_id": project_id,
+                "p_agent_name": None,
+                "p_select": "name,autonomous_mode",
+                "p_limit": 50,
+            }).encode()
+            _req = _Req(
+                f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_get_agents",
+                data=_body, method="POST",
+                headers={
+                    "apikey": sb["SUPABASE_KEY"],
+                    "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                    "Content-Type": "application/json",
+                },
+            )
+            with _urlopen(_req, timeout=5) as _resp:
+                _data = json.loads(_resp.read().decode())
+            _all = (_data or {}).get("agents") or []
+            _n = len(_all)
+            _auto = sum(1 for a in _all if a.get("autonomous_mode"))
+            if _n >= 2 and _auto == 0:
+                print(f"[meshcode]")
+                print(f"[meshcode]   💡 Tip: this meshwork now has {_n} agents. Consider autonomous mode:")
+                print(f"[meshcode]        meshcode run {agent} --autonomous")
+                print(f"[meshcode]      or set once for your shell:  export MESHCODE_AUTONOMOUS=1")
+                print(f"[meshcode]      Autonomous agents self-progress without per-step prompting.")
+        except Exception:
+            pass  # best-effort hint; never fail setup on this
     return 0
 
 

{meshcode-2.11.42 → meshcode-2.11.44}/meshcode.egg-info/PKG-INFO

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