meshcode 2.11.132__tar.gz → 2.11.134__tar.gz

{meshcode-2.11.132 → meshcode-2.11.134}/PKG-INFO

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

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode/__init__.py

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

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode/meshcode_mcp/backend.py

@@ -1389,6 +1389,22 @@ def task_complete(api_key, project_id, task_id, completing_agent, summary=""):
     })
 
 
+def task_progress(api_key, project_id, task_id, pct, note=None):
+    """Report real progress pct (0-100) on a claimed/in_progress/in_review task.
+
+    Server-side: public.mc_task_progress (mig 516) — claim-holder or owner;
+    updates progress_pct/note/last_progress_at, extends the claim lease 4h,
+    appends to deliverables.progress_log. The dashboard pbar reads this as
+    progress_source='reported' (task 6b2afa5d: pbar accuracy)."""
+    return sb_rpc("mc_task_progress", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_task_id": task_id,
+        "p_pct": pct,
+        "p_note": note,
+    })
+
+
 def feature_flag_enabled(api_key, flag_name):
     """Agent-facing feature-flag check (mig478). The FE's mc_check_feature_flag
     is auth.uid()-only, so agents use this api-key variant. Returns the raw

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode/meshcode_mcp/server.py

@@ -5348,6 +5348,64 @@ def meshcode_tasks(status_filter: Optional[str] = None, verbose: bool = False) -
     return {"ok": True, "tasks": compact}
 
 
+def _auto_task_progress(task_id: str, pct: int, note: str) -> None:
+    """Best-effort lifecycle progress floor (task 6b2afa5d: pbar accuracy).
+
+    Writes pct via mc_task_progress (mig 516) ONLY if the task's current
+    reported pct is unknown or lower — a re-claimed task that was already at
+    60% must never get reset to the claim/start milestone. Swallows every
+    failure (RPC missing pre-mig-516, auth, state): the lifecycle action this
+    rides on must never be blocked by progress telemetry.
+    """
+    try:
+        api_key = _get_api_key()
+        if pct < 100:  # 100 is monotonic by definition — skip the read
+            listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME,
+                                   status_filter=None, include_done=False)
+            if isinstance(listing, dict) and listing.get("ok"):
+                for t in listing.get("tasks", []):
+                    if t.get("id") == task_id:
+                        current = t.get("progress_pct")
+                        if isinstance(current, int) and current >= pct:
+                            return  # real progress already reported — keep it
+                        break
+        be.task_progress(api_key, _PROJECT_ID, task_id, pct, note)
+    except Exception:
+        pass  # auto-progress is a fallback, never a dependency
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_task_progress(task_id: str, pct: int, note: str = "") -> Dict[str, Any]:
+    """Report REAL progress (0-100) on your claimed/in_progress task — feeds the dashboard pbar.
+
+    Samuel directive (250e131e / msg d88bb9c7): every in_progress task must
+    report advance at real milestones, not vibes. Call at meaningful points
+    (e.g. 10 on claim, 25-40 design done, 70 code+tests, 90 smoke green).
+    Server-side mc_task_progress (mig 516) also extends your claim lease 4h
+    and appends {ts, by, pct, note} to deliverables.progress_log.
+
+    Args:
+        task_id: task you hold the claim on (UUID or 8-char prefix NOT
+            accepted — pass the full UUID).
+        pct: integer 0-100. Monotonicity is NOT enforced — you can correct
+            an overestimate downward.
+        note: short human-readable milestone (shows in the panel tooltip).
+    """
+    if not isinstance(pct, int) or pct < 0 or pct > 100:
+        return {"ok": False, "error": "pct must be an integer 0-100",
+                "error_code": "invalid_arg"}
+    api_key = _get_api_key()
+    result = be.task_progress(api_key, _PROJECT_ID, task_id, pct, note or None)
+    if isinstance(result, dict) and result.get("error"):
+        err = result.get("error")
+        msg = err.get("message", "") if isinstance(err, dict) else str(err)
+        if "Could not find the function" in msg or "PGRST202" in msg:
+            return {"ok": False, "error_code": "rpc_missing",
+                    "error": "mc_task_progress RPC not deployed (mig 516 not applied) — progress not recorded, work unaffected"}
+    return result
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
@@ -5368,6 +5426,8 @@ def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
                           api_key=api_key)
         except Exception:
             pass  # status surfacing is best-effort
+        # pbar accuracy fallback (task 6b2afa5d): claim = at least 10%
+        _auto_task_progress(resp.get("task_id") or task_id, 10, "auto: claimed")
     return resp
 
 
@@ -5399,6 +5459,10 @@ def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False)
                     }
         except Exception:
             pass  # Best-effort check; don't block on listing failure.
+    # pbar accuracy (task 6b2afa5d): stamp 100 BEFORE complete — mc_task_progress
+    # only accepts claimed/in_progress/in_review, so post-complete is too late,
+    # and a done task otherwise freezes at its last reported pct on the panel.
+    _auto_task_progress(task_id, 100, "auto: completed")
     result = be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
     # Task data persists in the task system — do NOT duplicate to memory.
     # Samuel: "los tasks no deben guardarse en memoria, para eso salen en tasks"
@@ -5428,12 +5492,16 @@ def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False)
 def meshcode_task_start(task_id: str) -> Dict[str, Any]:
     """Flip a claimed task to in_progress (mig 349 invariant: one in_progress per agent — any sibling in_progress for this agent is demoted to 'claimed' atomically)."""
     api_key = _get_api_key()
-    return be.sb_rpc("mc_task_start", {
+    result = be.sb_rpc("mc_task_start", {
         "p_api_key": api_key,
         "p_project_id": _PROJECT_ID,
         "p_task_id": task_id,
         "p_starting_agent": AGENT_NAME,
     })
+    if isinstance(result, dict) and result.get("ok"):
+        # pbar accuracy fallback (task 6b2afa5d): started = at least 25%
+        _auto_task_progress(task_id, 25, "auto: started")
+    return result
 
 
 @mcp.tool()

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode/protocol_handler.py

@@ -175,16 +175,28 @@ def _launcher_label(cmd: str) -> str:
 # Samuel 22c9f31d: "Launch All de N agentes = 1 ventana con N tabs, NO N
 # ventanas sueltas")
 # ============================================================
-# macOS Terminal.app has NO reliable programmatic tab API — all four native
-# routes were tested live on the target box 2026-06-11 and fail:
+# macOS Terminal.app has NO reliable programmatic tab API — SEVEN native
+# routes were tested live on the target box (macOS 26.4.1, 2026-06-11) and
+# ALL fail (task 2ac3f111 first four; task 4df5a126 the last three):
 #   - AppleScript `do script ... in window id N` reuses the selected tab
 #     (never creates one)
 #   - AppleScript `make new tab` errors -10000 (unsupported by Terminal)
 #   - `defaults write com.apple.Terminal AppleWindowTabbingMode always` is
 #     ignored (Terminal's tab model predates NSWindow tabbing)
+#   - `defaults write -g AppleWindowTabbingMode always` (global domain) is
+#     ALSO ignored for `open -a Terminal x.command` — still N windows
 #   - System Events Cmd+T opened a NEW WINDOW even with Accessibility
 #     granted, the target window raised AND frontmost (flaky beyond repair;
 #     also needs Accessibility + steals focus = two extra failure modes)
+#   - System Events click of menu item Shell > New Tab > <profile> (the
+#     deterministic cousin of Cmd+T) ALSO creates a NEW WINDOW, with the
+#     target window verified frontmost at click time
+#   - AppleScript bare `do script` (new-window form) with tabbing=always
+#     set in either domain still creates separate windows
+# (Window > Merge All Windows would coerce tabs but swallows the user's
+# PERSONAL Terminal windows — prohibited.) Native tabs on Terminal.app can
+# only be created by a human gesture; if true native tabs are required, the
+# supported path is a terminal with a real tab API (e.g. iTerm2).
 # So the fleet window is a tmux session inside ONE Terminal window: each
 # agent = a named tmux window = a clickable tab in the status bar. This buys
 # exactly the spec, with zero Apple Events from the daemon (the TCC
@@ -202,6 +214,43 @@ def _launcher_label(cmd: str) -> str:
 _FLEET_SESSION = "meshcode-fleet"
 
 
+def _fleet_tab_name(cmd: str) -> str:
+    """Short per-agent tab name for the fleet bar (task 4df5a126).
+
+    hostd targets are `<project>/<agent>` so _launcher_label yields
+    `meshcode-self-improve_backend` — at 3+ agents those long names overflow
+    the status bar and Samuel sees ONE truncated tab ("la barra verde
+    truncada"). The tab must read like a native Terminal tab: just the agent.
+    Take the part after the LAST '/' of the raw `meshcode run` target
+    (project names can't contain '/'; launch-batch passes bare agent names,
+    which are unchanged). Falls back to the full launcher label.
+    """
+    m = re.search(r"meshcode\s+run\s+(?:'([^']*)'|\"([^\"]*)\"|(\S+))", cmd)
+    raw = ((m.group(1) or m.group(2) or m.group(3)) if m else "") or ""
+    agent = raw.rsplit("/", 1)[-1].strip()
+    safe = re.sub(r"[^A-Za-z0-9_.-]", "_", agent).strip("_")
+    return safe[:24] or _launcher_label(cmd)
+
+
+# Native-looking tab bar (task 4df5a126: Samuel rejected the default tmux
+# status line — invisible/truncated). Top-positioned (where Terminal tabs
+# live), one padded block per agent, active tab high-contrast, all
+# mouse-clickable (mouse on). Plain ASCII, no emojis (Samuel rule 52b291b9).
+# Applied idempotently on EVERY spawn so an already-running fleet session
+# picks the style up the next time any agent launches.
+_FLEET_STYLE: tuple = (
+    ("status-position", "top"),
+    ("status-style", "bg=#16161e,fg=#a9b1d6"),
+    ("status-left", "#[bg=#3d59a1,fg=#ffffff,bold]  MESHCODE  #[default] "),
+    ("status-left-length", "14"),
+    ("status-right", "#[fg=#565f89] #{session_windows} agents | click: switch | right-click: stop "),
+    ("status-right-length", "48"),
+    ("window-status-format", "#[bg=#24283b,fg=#a9b1d6]  #W  #[default]"),
+    ("window-status-current-format", "#[bg=#7aa2f7,fg=#16161e,bold]  #W  #[default]"),
+    ("window-status-separator", " "),
+)
+
+
 def _find_tmux() -> Optional[str]:
     """tmux binary or None. The launchd daemon's PATH is minimal, so probe the
     common install prefixes + the daemon venv bin explicitly."""
@@ -227,11 +276,23 @@ def _fleet_wrap(cmd: str) -> str:
     Drop the LAST `exec ` (same trick as the .command launcher) so the shell
     survives the agent's exit and can translate rc 143 (SIGTERM = hostd
     stop/ghost-kill, task 91201315: that's the job FINISHING) to 0 — otherwise
-    `remain-on-exit failed` would keep a dead pane for every plain Stop."""
+    `remain-on-exit failed` would keep a dead pane for every plain Stop.
+
+    CLOSE-TAB=STOP (task 4df5a126, Samuel 68b1c17b: "cierro su terminal y
+    ya"): export MESHCODE_CLOSE_STOP_SIGHUP=1 so the MCP server's gated POSIX
+    close=stop handler (b6da0d54, default OFF) arms INSIDE fleet tabs only.
+    In a tmux pane SIGHUP is unambiguous — only kill-window / kill-session /
+    tmux-server death close the pty (a window-close of the shared Terminal
+    just DETACHES; ESC never closes the pty) — so the false-stop risk that
+    kept the flag off for plain windows (task dfa17461) does not exist here.
+    Right-click a tab -> Kill => SIGHUP => agent flips desired_state=stopped
+    server-side and exits clean: offline, NO hostd ghost-respawn (mig 494
+    coherent). A real crash never runs the handler => crash-respawn intact."""
     if "exec " in cmd:
         head, _, tail = cmd.rpartition("exec ")
         cmd = head + tail
-    return (f'{cmd}; MC_RC=$?; if [ "$MC_RC" = "143" ]; then exit 0; fi; '
+    return (f'export MESHCODE_CLOSE_STOP_SIGHUP=1; '
+            f'{cmd}; MC_RC=$?; if [ "$MC_RC" = "143" ]; then exit 0; fi; '
             f'echo "[meshcode] agent exited rc=$MC_RC — tab kept for debugging"; exit $MC_RC')
 
 
@@ -296,7 +357,7 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
     tmux = _find_tmux()
     if not tmux:
         return False, "tmux not installed (brew install tmux -> tabbed fleet window)"
-    label = _launcher_label(cmd)
+    label = _fleet_tab_name(cmd)
     wrapped = _fleet_wrap(cmd)
     try:
         fresh_session = _tmux(tmux, "has-session", "-t", f"={_FLEET_SESSION}").returncode != 0
@@ -317,13 +378,14 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
                       "-n", label, "-P", "-F", "#{window_id}", wrapped)
             if r.returncode != 0:
                 return False, f"tmux new-window: {(r.stderr or '').strip()}"
-        else:
-            # Session bootstrap (once). mouse = click a tab name in the status
-            # bar to switch; detach-on-destroy = when the last tab closes, the
-            # attach client exits and the fleet.command closes its own window.
-            for opt in (("mouse", "on"), ("detach-on-destroy", "on"),
-                        ("status-left", "[MeshCode Fleet] "), ("status-left-length", "20")):
-                _tmux(tmux, "set-option", "-t", f"={_FLEET_SESSION}:", *opt)
+        # Session options, applied on EVERY spawn (idempotent): mouse = click a
+        # tab in the bar to switch; detach-on-destroy = when the last tab
+        # closes, the attach client exits and the fleet.command closes its own
+        # window; _FLEET_STYLE = the native-looking top tab bar. Always-apply
+        # (was bootstrap-only) so a session created by an OLDER wheel restyles
+        # the moment any agent launches through this code.
+        for opt in (("mouse", "on"), ("detach-on-destroy", "on"), *_FLEET_STYLE):
+            _tmux(tmux, "set-option", "-t", f"={_FLEET_SESSION}:", *opt)
         win_id = (r.stdout or "").strip()
         if win_id.startswith("@"):
             # Per-tab window options: a CRASHED agent's pane stays (rc!=0 ->
@@ -360,8 +422,11 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
                 ok, info = _fleet_attach_linux(tmux)
             if not ok:
                 # Tab exists + agent runs, but invisibly — that breaks the
-                # visibility contract. Kill the tab and let legacy spawn a window.
-                _tmux(tmux, "kill-window", "-t", f"={_FLEET_SESSION}:{label}")
+                # visibility contract. Kill the tab and let legacy spawn a
+                # window. Target by @id when we have it (tab names are now
+                # short agent names and CAN collide across projects).
+                _tmux(tmux, "kill-window", "-t",
+                      win_id if win_id.startswith("@") else f"={_FLEET_SESSION}:{label}")
                 return False, f"fleet attach window failed: {info}"
             return True, f"{info}(fleet-window+tab)"
         return True, "fleet-tab"
@@ -369,6 +434,326 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
         return False, f"tmux fleet failed: {e}"
 
 
+# ============================================================
+# fleet NATIVE Terminal.app tabs — macOS (task 4df5a126, Samuel GO 9a6e0f02)
+# ============================================================
+# Samuel visually CONFIRMED (screenshot 2026-06-11 11:47) that the System
+# Events click of Shell > New Tab > <profile> creates a REAL native tab.
+# Why every scripted probe said "window": macOS native tabs are SEPARATE
+# NSWindows grouped into one frame — Terminal's AppleScript `windows`
+# enumerates each grouped tab as its own window object with `tabs=1`, so
+# AppleScript COUNTS CANNOT distinguish a grouped tab from a loose window.
+# All earlier "FAIL: new window created" verdicts were this measurement
+# blindness, not failures.
+#
+# Architecture (TCC-safe — the back-2 Mac poisoning note in
+# _spawn_terminal_macos forbids Apple Events FROM THE DAEMON):
+#   - The FIRST agent launches via `open -a Terminal <agent>.fleet.command`
+#     (the blessed no-Apple-Events path) and becomes the ANCHOR: its shell
+#     starts the lock-gated fleet WATCHER in the background. The watcher
+#     runs INSIDE Terminal, so Terminal stays its own TCC responsible
+#     process for both Apple Events and the Accessibility click (verified
+#     granted + working live on the target box 2026-06-11).
+#   - Later agents are SPOOLED (~/.meshcode/launchers/fleet-spool/): the
+#     watcher runs the GREEN RECIPE per spool entry — raise anchor window,
+#     READ the New Tab submenu, click profile item 1, find what appeared
+#     (same-window tab OR new grouped NSWindow), `do script` the agent
+#     into it. hostd blocks on a .done marker; "fallback"/timeout cascades
+#     to the tmux fleet bar, then to legacy one-window-per-agent.
+#   - EVERY fleet agent shell offers to become watcher (lock-gated, stale
+#     lock stolen after 12s) so closing the anchor tab only moves the
+#     watcher to another tab within seconds.
+#   - close-tab=STOP (Samuel 68b1c17b): tabs export
+#     MESHCODE_CLOSE_STOP_SIGHUP=1 — closing a native tab closes its pty,
+#     SIGHUP arms the MCP close=stop handler (b6da0d54), agent flips
+#     desired_state=stopped and exits clean (no hostd ghost-respawn,
+#     mig 494 coherent). Clean exits (rc 0/143) self-close ONLY their tab;
+#     crashes keep the tab + scrollback for debugging.
+# Known trade-off: each spooled spawn raises Terminal + the fleet frame
+# (the menu click needs frontmost) — focus moves during a Launch All burst,
+# which is the moment the spec wants focus anyway.
+
+_FLEET_NATIVE_DISABLED_TTL_S = 1800  # back off after a watcher "fallback"
+
+
+def _fleet_native_paths() -> dict:
+    d = Path.home() / ".meshcode" / "launchers"
+    return {
+        "dir": d,
+        "spool": d / "fleet-spool",
+        "alive": d / "fleet-native-alive",
+        "pending": d / "fleet-native-pending",
+        "disabled": d / "fleet-native-disabled",
+        "watcher": d / "meshcode-fleet-watcher.sh",
+        "log": d / "fleet-native.log",
+    }
+
+
+_FLEET_NATIVE_DRIVER_AS = r'''on run argv
+  set myTTY to item 1 of argv
+  set agentCmd to item 2 of argv
+  tell application "Terminal"
+    set myWin to missing value
+    repeat with w in windows
+      repeat with t in tabs of w
+        try
+          if (tty of t) is myTTY then set myWin to w
+        end try
+      end repeat
+    end repeat
+    if myWin is missing value then error "anchor window not found"
+    set idsBefore to id of every window
+    set tabsBefore to count of tabs of myWin
+    activate
+    set index of myWin to 1
+    try
+      set frontmost of myWin to true
+    end try
+  end tell
+  delay 0.8
+  tell application "System Events"
+    tell process "Terminal"
+      set frontmost to true
+      delay 0.3
+      -- GREEN-RECIPE RC (commander 9a6e0f02, Samuel screenshot 11:47):
+      -- READ the New Tab submenu BEFORE clicking. The read forces AppKit to
+      -- populate the menu; the click on an unpopulated menu intermittently
+      -- degraded to a loose window. DO NOT REMOVE THIS LINE.
+      set subItems to name of menu items of menu 1 of menu item "New Tab" of menu "Shell" of menu bar 1
+      click menu item 1 of menu 1 of menu item "New Tab" of menu "Shell" of menu bar 1
+    end tell
+  end tell
+  set targetId to 0
+  set targetKind to ""
+  repeat with i from 1 to 12
+    delay 0.5
+    tell application "Terminal"
+      if (count of tabs of myWin) > tabsBefore then
+        set targetKind to "tab"
+      else
+        repeat with w in windows
+          if idsBefore does not contain (id of w) then
+            set targetId to id of w
+            set targetKind to "win"
+          end if
+        end repeat
+      end if
+    end tell
+    if targetKind is not "" then exit repeat
+  end repeat
+  if targetKind is "" then error "no new tab appeared after menu click"
+  tell application "Terminal"
+    if targetKind is "tab" then
+      do script agentCmd in tab (tabsBefore + 1) of myWin
+    else
+      -- grouped NSWindow tab: `do script in window id` reuses its fresh
+      -- selected shell (verified live 2026-06-11) — exactly what we want.
+      do script agentCmd in window id targetId
+    end if
+  end tell
+  return "ok"
+end run'''
+
+
+def _write_fleet_native_watcher() -> Path:
+    """Write (idempotently) the lock-gated spool watcher that creates native
+    tabs from INSIDE Terminal. See the architecture block above."""
+    p = _fleet_native_paths()
+    body = '''#!/bin/bash
+# meshcode fleet native-tabs watcher — GENERATED by protocol_handler.py
+# (task 4df5a126). Runs INSIDE a Terminal tab (TCC: Terminal stays its own
+# responsible process). One holder at a time (lock dir, stale-steal 12s).
+LAUNCH="$HOME/.meshcode/launchers"
+SPOOL="$LAUNCH/fleet-spool"
+LOCK="$LAUNCH/fleet-native-lock"
+ALIVE="$LAUNCH/fleet-native-alive"
+MYTTY="$1"
+exec >>"$LAUNCH/fleet-native.log" 2>&1
+mkdir -p "$SPOOL"
+while :; do
+  if mkdir "$LOCK" 2>/dev/null; then
+    echo "$$ $MYTTY $(date)" > "$LOCK/owner"
+    break
+  fi
+  AGE=999
+  if [ -f "$ALIVE" ]; then
+    AGE=$(( $(date +%s) - $(stat -f %m "$ALIVE" 2>/dev/null || echo 0) ))
+  fi
+  if [ "$AGE" -gt 12 ]; then rm -rf "$LOCK"; continue; fi
+  sleep 3
+done
+trap 'rm -rf "$LOCK"; exit 0' EXIT HUP TERM INT
+echo "[watcher] $$ holds lock (tty $MYTTY)"
+N=0
+while :; do
+  date +%s > "$ALIVE"
+  for f in "$SPOOL"/*.cmd; do
+    [ -e "$f" ] || continue
+    CMD="$(cat "$f")"
+    BASE="${f%.cmd}"
+    echo "[watcher] tab spawn: $CMD"
+    if /usr/bin/osascript "$LAUNCH/fleet-native-driver.applescript" "$MYTTY" "$CMD"
+    then
+      echo ok > "$BASE.done"
+    else
+      echo fallback > "$BASE.done"
+    fi
+    rm -f "$f"
+  done
+  N=$((N+1))
+  if [ $((N % 300)) -eq 0 ]; then
+    find "$SPOOL" -name '*.done' -mmin +60 -delete 2>/dev/null
+  fi
+  sleep 1
+done
+'''
+    p["dir"].mkdir(parents=True, exist_ok=True)
+    driver = p["dir"] / "fleet-native-driver.applescript"
+    driver.write_text(_FLEET_NATIVE_DRIVER_AS + "\n", encoding="utf-8")
+    p["watcher"].write_text(body, encoding="utf-8")
+    os.chmod(p["watcher"], 0o755)
+    return p["watcher"]
+
+
+def _write_fleet_native_agent(cmd: str) -> Path:
+    """Write the per-agent fleet command file (runs the agent inside its
+    native tab; offers to become watcher; close-tab=stop; clean exits close
+    ONLY their own tab). Filename keyed by _launcher_label (unique per
+    project/agent target); the visible TAB TITLE is the short agent name."""
+    p = _fleet_native_paths()
+    title = _fleet_tab_name(cmd)
+    script_path = p["dir"] / f"{_launcher_label(cmd)}.fleet.command"
+    try:
+        venv_bin = str(Path(sys.executable).parent)
+    except Exception:
+        venv_bin = ""
+    if "exec " in cmd:
+        _head, _, _tail = cmd.rpartition("exec ")
+        run_line = _head + _tail   # agent as CHILD so bash survives to close the tab
+    else:
+        run_line = cmd
+    lines = [
+        "#!/bin/bash",
+        'cd "$HOME" 2>/dev/null || cd /',
+        rf"printf '\033]0;{title}\007\033]1;{title}\007'",
+    ]
+    if venv_bin:
+        lines.append(f'export PATH={shlex.quote(venv_bin)}:"$PATH"')
+    lines += [
+        # close-tab=STOP (Samuel 68b1c17b) — see architecture block.
+        "export MESHCODE_CLOSE_STOP_SIGHUP=1",
+        'MC_TTY="$(tty 2>/dev/null)"',
+        # every fleet tab offers to run the watcher (lock-gated)
+        f'/bin/bash {shlex.quote(str(p["watcher"]))} "$MC_TTY" >/dev/null 2>&1 &',
+        "disown",
+        run_line,
+        "MC_RC=$?",
+        # clean exit (0, or 143 = hostd stop sweep): close ONLY this tab.
+        # Crash: keep tab + scrollback (debugging > clean window).
+        'if { [ "$MC_RC" = "0" ] || [ "$MC_RC" = "143" ]; } && [ -n "$MC_TTY" ]; then',
+        "  /usr/bin/osascript"
+        " -e 'on run argv'"
+        " -e 'tell application \"Terminal\"'"
+        " -e 'repeat with w in windows'"
+        " -e 'repeat with t in tabs of w'"
+        " -e 'try'"
+        " -e 'if (tty of t) is (item 1 of argv) then close t saving no'"
+        " -e 'end try'"
+        " -e 'end repeat'"
+        " -e 'end repeat'"
+        " -e 'end tell'"
+        " -e 'end run' \"$MC_TTY\" >/dev/null 2>&1",
+        "else",
+        '  echo "[meshcode] agent exited rc=$MC_RC — tab kept for debugging"',
+        "fi",
+    ]
+    p["dir"].mkdir(parents=True, exist_ok=True)
+    script_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    os.chmod(script_path, 0o755)
+    return script_path
+
+
+def _spawn_fleet_native_macos(cmd: str) -> tuple[bool, str]:
+    """Spawn `cmd` as a NATIVE Terminal.app tab of the shared fleet window.
+
+    Returns (False, reason) on ANY failure — caller cascades to the tmux
+    fleet bar, then legacy windows, so this can never make launches worse."""
+    p = _fleet_native_paths()
+    # back-off marker: a recent watcher "fallback" (Accessibility revoked,
+    # menu shape changed, ...) disables the native path for a while instead
+    # of paying a focus-steal + multi-second failure on every launch.
+    try:
+        if time.time() - p["disabled"].stat().st_mtime < _FLEET_NATIVE_DISABLED_TTL_S:
+            return False, "fleet-native recently failed (back-off)"
+    except OSError:
+        pass
+    try:
+        p["spool"].mkdir(parents=True, exist_ok=True)
+        _write_fleet_native_watcher()
+        agent_file = _write_fleet_native_agent(cmd)
+    except Exception as e:
+        return False, f"could not write fleet-native scripts: {e}"
+
+    def _alive_age() -> float:
+        try:
+            return time.time() - p["alive"].stat().st_mtime
+        except OSError:
+            return 1e9
+
+    if _alive_age() > 8:
+        pend_fresh = False
+        try:
+            pend_fresh = (time.time() - p["pending"].stat().st_mtime) < 25
+        except OSError:
+            pass
+        if not pend_fresh:
+            # become the ANCHOR: first visible tab, watcher host
+            try:
+                p["pending"].touch()
+            except OSError:
+                pass
+            r = subprocess.run(["open", "-a", "Terminal", str(agent_file)],
+                               capture_output=True, text=True)
+            if r.returncode == 0:
+                return True, "terminal(fleet-native-anchor)"
+            return False, (r.stderr or "open failed").strip()
+        # an anchor is booting — wait for its watcher before spooling
+        deadline = time.time() + 25
+        while time.time() < deadline and _alive_age() > 8:
+            time.sleep(0.5)
+        if _alive_age() > 8:
+            return False, "fleet-native anchor never came alive"
+
+    sp = p["spool"] / f"{time.time_ns()}-{_launcher_label(cmd)}.cmd"
+    done = sp.with_suffix(".done")
+    try:
+        sp.write_text(f"/bin/bash {shlex.quote(str(agent_file))}\n", encoding="utf-8")
+    except Exception as e:
+        return False, f"fleet-native spool write failed: {e}"
+    deadline = time.time() + 20
+    while time.time() < deadline:
+        if done.exists():
+            try:
+                verdict = done.read_text().strip()
+                done.unlink()
+            except OSError:
+                verdict = ""
+            if verdict == "ok":
+                return True, "fleet-native-tab"
+            try:
+                p["disabled"].touch()
+            except OSError:
+                pass
+            return False, f"fleet-native watcher reported {verdict or 'error'}"
+        time.sleep(0.4)
+    # timeout: pull the spool entry so a late watcher can't double-spawn
+    try:
+        sp.unlink()
+    except OSError:
+        pass
+    return False, "fleet-native spool timeout"
+
+
 def _spawn_terminal_macos(cmd: str) -> tuple[bool, str]:
     """Spawn `cmd` in a new VISIBLE Terminal/iTerm window (detached).
 
@@ -595,7 +980,10 @@ def _spawn_terminal_windows(cmd: str) -> tuple[bool, str]:
             # carries one → the cmdline splits and wt fails with 0x80070002.
             # Escape ONLY here; the cmd.exe fallback below stays unescaped
             # (cmd.exe does not split on ';').
-            label = _launcher_label(cmd)
+            # Short agent-only tab title (task 4df5a126) — same readability fix
+            # as the macOS fleet bar; sanitized [A-Za-z0-9_.-] so it can't
+            # smuggle wt args.
+            label = _fleet_tab_name(cmd)
             subprocess.Popen([wt, "-w", "meshcode-fleet", "nt",
                               "--title", label or "meshcode-agent",
                               "--suppressApplicationTitle",
@@ -612,16 +1000,22 @@ def _spawn_terminal_windows(cmd: str) -> tuple[bool, str]:
 
 def _spawn_terminal(cmd: str) -> tuple[bool, str]:
     p = platform.system()
-    if p in ("Darwin", "Linux"):
-        # Fleet tabs first (task 2ac3f111): one shared window, one tab per agent.
-        # Any failure (tmux absent, session error, attach window failed) falls
-        # back to the legacy one-window-per-agent spawn below — never worse.
+    if p == "Darwin":
+        # 1) NATIVE Terminal tabs (task 4df5a126, Samuel GO) — one window,
+        #    one real tab per agent, close-tab=stop.
+        ok, info = _spawn_fleet_native_macos(cmd)
+        if ok:
+            return True, info
+        # 2) tmux fleet bar (task 2ac3f111) — shared window, styled tab bar.
         ok, info = _spawn_fleet_tab(cmd)
         if ok:
             return True, info
-    if p == "Darwin":
+        # 3) legacy one-window-per-agent — never worse than before.
         return _spawn_terminal_macos(cmd)
     if p == "Linux":
+        ok, info = _spawn_fleet_tab(cmd)
+        if ok:
+            return True, info
         return _spawn_terminal_linux(cmd)
     if p == "Windows":
         # Windows Terminal tabs are native: _spawn_terminal_windows targets the

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode/rpc_allowlist.py

@@ -31,6 +31,7 @@ AGENT_CALLABLE_RPCS = [
     "mc_task_reject",
     "mc_task_approve",
     "mc_task_search",
+    "mc_task_progress",         # mig 516 — pbar accuracy (task 6b2afa5d)
     "mc_task_reschedule",       # mig 330
     "mc_task_get_deps",         # mig 330
     "mc_tasks_due_soon",        # mig 329

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.132 → meshcode-2.11.134}/meshcode.egg-info/SOURCES.txt

@@ -95,5 +95,6 @@ tests/test_status_enum_coverage.py
 tests/test_stay_on_loop_hook.py
 tests/test_stop_ghost_terminal.py
 tests/test_swarm_events.py
+tests/test_task_progress.py
 tests/test_terminal_lifecycle.py
 tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.132 → meshcode-2.11.134}/pyproject.toml

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

meshcode-2.11.134/tests/test_task_progress.py

@@ -0,0 +1,147 @@
+"""Tests for the pbar-accuracy wheel half (task 6b2afa5d).
+
+Samuel (msg d88bb9c7): "la barra de progreso no es accurate". Root cause:
+mig 516 shipped the server-side RPC public.mc_task_progress, but the wheel
+MCP never exposed a wrapper (QA msg ba932abc) — agents physically could not
+report real pct, so the panel pbar showed elapsed-time guesses or froze.
+
+This file asserts the contract of the fix:
+  1. backend.task_progress maps args to the mig-516 RPC signature.
+  2. server.py exposes the meshcode_task_progress MCP tool.
+  3. Lifecycle auto-progress fallback exists: claim->10, start->25,
+     complete->100 — all routed through _auto_task_progress, which is
+     monotonic-guarded (never resets a re-claimed 60% task to 10%) and
+     best-effort (never blocks the lifecycle action).
+  4. The complete->100 stamp happens BEFORE be.task_complete in source
+     order (mc_task_progress refuses status='done', so after is too late).
+  5. mc_task_progress is on the agent-callable RPC allowlist.
+
+server.py has module-level side effects requiring live Supabase, so the
+server-side assertions are static (source/AST) — same pattern as
+test_wait_open_tasks_contradiction.py. backend.py imports clean, so the
+param-mapping test runs the real function with sb_rpc monkeypatched.
+"""
+
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+SERVER_PY = REPO / "meshcode" / "meshcode_mcp" / "server.py"
+
+
+class TestBackendTaskProgress(unittest.TestCase):
+    """backend.task_progress → mc_task_progress param mapping (mocked RPC)."""
+
+    def test_param_mapping_matches_mig_516_signature(self):
+        from meshcode.meshcode_mcp import backend as be
+        captured = {}
+
+        def fake_rpc(fn_name, params, **kw):
+            captured["fn"] = fn_name
+            captured["params"] = params
+            return {"ok": True, "task_id": params["p_task_id"], "progress_pct": params["p_pct"]}
+
+        orig = be.sb_rpc
+        be.sb_rpc = fake_rpc
+        try:
+            out = be.task_progress("key-x", "proj-1", "task-1", 40, "mitad")
+        finally:
+            be.sb_rpc = orig
+
+        self.assertEqual(captured["fn"], "mc_task_progress")
+        self.assertEqual(captured["params"], {
+            "p_api_key": "key-x",
+            "p_project_id": "proj-1",
+            "p_task_id": "task-1",
+            "p_pct": 40,
+            "p_note": "mitad",
+        })
+        self.assertTrue(out["ok"])
+
+    def test_note_defaults_to_none(self):
+        from meshcode.meshcode_mcp import backend as be
+        captured = {}
+
+        def fake_rpc(fn_name, params, **kw):
+            captured["params"] = params
+            return {"ok": True}
+
+        orig = be.sb_rpc
+        be.sb_rpc = fake_rpc
+        try:
+            be.task_progress("k", "p", "t", 70)
+        finally:
+            be.sb_rpc = orig
+        self.assertIsNone(captured["params"]["p_note"])
+
+
+class TestServerWiring(unittest.TestCase):
+    """Static assertions on server.py — tool + lifecycle hooks."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.src = SERVER_PY.read_text(encoding="utf-8")
+
+    def test_tool_exposed(self):
+        self.assertIn("def meshcode_task_progress(", self.src,
+                      "wheel must expose the meshcode_task_progress MCP tool "
+                      "(the missing wrapper WAS the bug — QA msg ba932abc)")
+
+    def test_tool_validates_pct_client_side(self):
+        body = self._fn_body("def meshcode_task_progress(")
+        self.assertIn("pct must be an integer 0-100", body,
+                      "tool must reject bad pct before burning an RPC")
+
+    def test_auto_progress_helper_exists_and_is_guarded(self):
+        self.assertIn("def _auto_task_progress(", self.src)
+        body = self._fn_body("def _auto_task_progress(")
+        self.assertIn("current >= pct", body,
+                      "monotonic guard: a re-claimed task at 60% must not be "
+                      "reset to the 10/25 lifecycle floor")
+        self.assertIn("except Exception", body,
+                      "auto-progress must swallow all failures — it is a "
+                      "fallback, never a dependency")
+
+    def test_lifecycle_hooks_present(self):
+        self.assertIn('"auto: claimed"', self.src, "claim → 10 hook missing")
+        self.assertIn('"auto: started"', self.src, "start → 25 hook missing")
+        self.assertIn('"auto: completed"', self.src, "complete → 100 hook missing")
+
+    def test_complete_stamps_100_before_rpc(self):
+        # mc_task_progress refuses status='done' — the 100 stamp must come
+        # BEFORE be.task_complete in meshcode_task_complete's body.
+        body = self._fn_body("def meshcode_task_complete(")
+        idx_stamp = body.find('_auto_task_progress(task_id, 100')
+        idx_complete = body.find("be.task_complete(")
+        self.assertGreater(idx_stamp, 0, "complete must stamp 100")
+        self.assertGreater(idx_complete, idx_stamp,
+                           "100 stamp must precede be.task_complete — after "
+                           "complete the task is 'done' and the RPC refuses")
+
+    def test_task_marker_present(self):
+        self.assertIn("6b2afa5d", self.src,
+                      "code must reference the task id for future git-blame")
+
+    def _fn_body(self, needle: str) -> str:
+        start = self.src.find(needle)
+        assert start > 0, f"{needle!r} not found"
+        # body ends at the next top-level decorator/def
+        end = self.src.find("\n@mcp.tool()", start)
+        if end < 0:
+            end = self.src.find("\ndef ", start + 1)
+        return self.src[start:end if end > 0 else len(self.src)]
+
+
+class TestAllowlist(unittest.TestCase):
+
+    def test_mc_task_progress_on_allowlist(self):
+        from meshcode.rpc_allowlist import AGENT_CALLABLE_RPCS
+        self.assertIn("mc_task_progress", AGENT_CALLABLE_RPCS,
+                      "mig 516 grants it to anon — the allowlist is the "
+                      "single source of truth and must agree")
+
+
+if __name__ == "__main__":
+    unittest.main()