meshcode 2.11.44__tar.gz → 2.11.46__tar.gz

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

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

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

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

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

@@ -3353,6 +3353,53 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+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
+    OPEN task already ASSIGNED to me but not yet claimed by anyone. Closes
+    the 'tasks sit forever when agent was offline at create time' gap.
+
+    Always-on (NOT gated on autonomous_mode per Samuel msg a15d7ed4 quote:
+    "antes siempre que habia task assigned el agente sabia que tenia un
+    task assigned pendiente y no paraba hasta completar todos").
+
+    Returns the list of claimed task summaries (may be empty).
+    """
+    claimed: List[Dict[str, str]] = []
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return claimed
+        result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
+        if not isinstance(result, dict) or not result.get("ok"):
+            return claimed
+        tasks = result.get("tasks", [])
+        candidates = [
+            t for t in tasks
+            if t.get("assignee") == AGENT_NAME
+            and not t.get("claimed_by")
+            and t.get("status") == "open"
+        ]
+        # Sort urgent → high → normal → low, oldest first within priority
+        _PRIO = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
+        candidates.sort(key=lambda t: (_PRIO.get(t.get("priority", "normal"), 2), t.get("created_at", "")))
+        for target in candidates[:max_claims]:
+            claim_result = be.sb_rpc("mc_task_claim", {
+                "p_api_key": api_key,
+                "p_task_id": target["id"],
+            })
+            if isinstance(claim_result, dict) and claim_result.get("ok"):
+                log.info(f"[meshcode] auto-claimed self-assigned task: {target['title'][:60]}")
+                claimed.append({
+                    "id": target["id"][:8],
+                    "title": target["title"][:80],
+                    "priority": target.get("priority", "normal"),
+                })
+    except Exception as e:
+        log.debug(f"[meshcode] auto-claim self-assigned failed: {e}")
+    return claimed
+
+
 def _try_auto_claim_task() -> Optional[Dict[str, str]]:
     """Auto-claim the oldest open task matching this agent's role.
 
@@ -3494,6 +3541,17 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # The legacy refuse-on-open-tasks behavior is preserved behind an
     # opt-in env flag MESHCODE_WAIT_BLOCKS_ON_TASKS=1 in case any
     # workspace depends on it; default OFF to fix the contradiction.
+    # URGENT_RUNTIME_FIX_TASK_PULL (Samuel msg a15d7ed4): proactive
+    # self-assigned-task sweep at every wait entry. Any open task
+    # assigned to me but not yet claimed gets auto-claimed before we
+    # even check inbox — closes the "task sits because agent was
+    # offline at create time" gap. Always-on, not gated on
+    # autonomous_mode. Best-effort.
+    try:
+        _wait_entry_auto_claimed = _try_auto_claim_self_assigned_tasks()
+    except Exception:
+        _wait_entry_auto_claimed = []
+
     pending_tasks = _get_pending_tasks_summary()
     if pending_tasks and os.environ.get("MESHCODE_WAIT_BLOCKS_ON_TASKS", "").lower() in ("1", "true", "yes"):
         if not _is_leader_agent():
@@ -3502,8 +3560,28 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 "reason": "You have open tasks. Work them before entering wait. (legacy behavior, MESHCODE_WAIT_BLOCKS_ON_TASKS=1)",
                 "pending_tasks": pending_tasks,
                 "count": len(pending_tasks),
+                "auto_claimed_at_wait_entry": _wait_entry_auto_claimed,
             }
 
+    # URGENT_RUNTIME_FIX_TASK_PULL (Samuel msg a15d7ed4): if we have
+    # ANY pending-self tasks (claimed or open-assigned-to-me), short-
+    # circuit out of wait so the agent works them in priority order
+    # without burning a 20s timeout cycle each round. Mirrors the
+    # legacy "no paraba hasta completar todos" cadence. Non-leader
+    # agents only — leaders need to stay in wait to triage wildcard
+    # tasks for the mesh.
+    if pending_tasks and not _is_leader_agent():
+        out: Dict[str, Any] = {
+            "pending_tasks": pending_tasks,
+            "count": len(pending_tasks),
+            "you_are_autonomous": _get_autonomous_mode(),
+            "task_pull_active": True,
+            "hint": "Work the highest-priority task with meshcode_task_start, then meshcode_task_complete. Wait will surface the next one automatically.",
+        }
+        if _wait_entry_auto_claimed:
+            out["auto_claimed_at_wait_entry"] = _wait_entry_auto_claimed
+        return out
+
     # PRODUCT RULE 2: If agent has unread messages in DB, refuse to wait.
     try:
         db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
@@ -4160,6 +4238,18 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
     # "idle Ns" string from accumulating across status churn.
     if status == "online" and isinstance(resp, dict) and resp.get("ok"):
         _CONSECUTIVE_IDLE_SECONDS = 0
+    # URGENT_RUNTIME_FIX_TASK_PULL (Samuel msg a15d7ed4 + commander
+    # msg 0cfca3f3): autoclaim-on-reconnect. When the agent flips to
+    # online/working, sweep any open-assigned-to-me tasks and claim
+    # them so they don't sit indefinitely. Always-on (not gated on
+    # autonomous_mode). Best-effort; never fails the set_status path.
+    if status in ("online", "working") and isinstance(resp, dict) and resp.get("ok"):
+        try:
+            _claimed_on_reconnect = _try_auto_claim_self_assigned_tasks()
+            if _claimed_on_reconnect:
+                resp["auto_claimed_on_reconnect"] = _claimed_on_reconnect
+        except Exception:
+            pass
     return resp
 
 
@@ -4298,9 +4388,24 @@ def meshcode_tasks(status_filter: Optional[str] = None, verbose: bool = False) -
 @mcp.tool()
 @with_working_status
 def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
-    """Claim an open task. Fails if already claimed by someone else."""
+    """Claim an open task. Fails if already claimed by someone else.
+
+    On success, also flips mc_agents.status='working' with a short task
+    label (URGENT_RUNTIME_FIX_TASK_PULL, msg a15d7ed4 STATUS_SURFACING)
+    so observers + Samuel see "working on X" in real time.
+    """
     api_key = _get_api_key()
-    return be.task_claim(api_key, _PROJECT_ID, task_id, AGENT_NAME)
+    resp = be.task_claim(api_key, _PROJECT_ID, task_id, AGENT_NAME)
+    if isinstance(resp, dict) and resp.get("ok"):
+        try:
+            _short_id = (resp.get("task_id") or task_id)[:8]
+            _short_title = (resp.get("title") or "").strip()[:60] or "task"
+            be.set_status(_PROJECT_ID, AGENT_NAME, "working",
+                          f"task {_short_id}: {_short_title}",
+                          api_key=api_key)
+        except Exception:
+            pass  # status surfacing is best-effort
+    return resp
 
 
 @mcp.tool()
@@ -4344,6 +4449,14 @@ def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False)
             "risk=low|med|high). The team's backlog stays fed without the "
             "commander manually generating ideas."
         )
+        # URGENT_RUNTIME_FIX_TASK_PULL (msg a15d7ed4 STATUS_SURFACING):
+        # clear the task label + flip to online so the wait loop pulls
+        # the next pending task on the next round without leaving the
+        # roster showing "working on <stale task>".
+        try:
+            be.set_status(_PROJECT_ID, AGENT_NAME, "online", "", api_key=api_key)
+        except Exception:
+            pass
     return result
 
 
@@ -5403,6 +5516,28 @@ def meshcode_add_agent(name: str, role: str = "", autonomous: bool = False) -> D
     return result or {"error": "failed to add agent"}
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_set_meshwork_autonomous_default(enabled: bool) -> Dict[str, Any]:
+    """Set the autonomous_mode_default for the current meshwork.
+
+    Owner-only. Agents whose own mc_agents.autonomous_mode IS NULL fall
+    through to this default. Setting True makes new agents autonomous by
+    default; setting False reverts to the conservative ask-mode default.
+
+    AUTONOMOUS-MODE-UNIVERSAL Phase 2 (mig 359, task f248d98e). Writes an
+    mc_traces audit row on every flip.
+
+    Args:
+        enabled: True = autonomous default for the meshwork; False = ask-mode default.
+    """
+    return be.sb_rpc("mc_meshwork_set_autonomous_default", {
+        "p_api_key":    _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_default":    bool(enabled),
+    })
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_edit_agent(name: str, role: Optional[str] = None, launch_prompt: Optional[str] = None) -> Dict[str, Any]:

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

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

{meshcode-2.11.44 → meshcode-2.11.46}/pyproject.toml

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