meshcode 2.11.132__tar.gz → 2.11.133__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.132
+Version: 2.11.133
 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.133}/meshcode/__init__.py

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

{meshcode-2.11.132 → meshcode-2.11.133}/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.133}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.132
+Version: 2.11.133
 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.133}/pyproject.toml

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