meshcode 2.8.8__tar.gz → 2.8.9__tar.gz

{meshcode-2.8.8 → meshcode-2.8.9}/PKG-INFO

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

{meshcode-2.8.8 → meshcode-2.8.9}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.8.8"
+__version__ = "2.8.9"

meshcode-2.8.9/meshcode/ascii_art.py

@@ -0,0 +1,466 @@
+"""Procedural ASCII art + agent personality generator for MeshCode.
+
+Each agent gets:
+- Unique identicon (QR-style block pattern from name hash)
+- Personality traits (based on actual role + stats)
+- Catchphrase (unique motto)
+- Boot greeting (personalized online message)
+
+All deterministic from agent name — same name = same identity always.
+Zero tokens, pure ANSI aesthetics.
+"""
+import hashlib
+
+# ── Block characters for identicon ──────────────────────────────────
+BLOCKS = {
+    0: "  ",    # empty
+    1: "██",    # full block
+    2: "░░",    # light shade
+    3: "▓▓",    # dark shade
+    4: "▒▒",    # medium shade
+    5: "╬╬",    # cross
+    6: "◆◆",    # diamond
+    7: "●●",    # circle
+}
+
+# ── ANSI colors ─────────────────────────────────────────────────────
+COLORS = [
+    "\033[36m", "\033[35m", "\033[32m", "\033[33m", "\033[34m",
+    "\033[91m", "\033[96m", "\033[95m", "\033[92m", "\033[94m",
+]
+RESET = "\033[0m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+YELLOW = "\033[33m"
+STAR = "★"
+
+
+def _hash_bytes(name: str) -> bytes:
+    return hashlib.sha256(name.encode("utf-8")).digest()
+
+
+def _hash_int(name: str) -> int:
+    return int(hashlib.md5(name.encode()).hexdigest()[:8], 16)
+
+
+# ── 1. Identicon generator ─────────────────────────────────────────
+
+def generate_art(agent_name: str, size: int = 7) -> str:
+    """Generate a unique symmetric block pattern from the agent name."""
+    h = _hash_bytes(agent_name)
+    half = (size + 1) // 2
+    rows = []
+    for y in range(size):
+        row = []
+        for x in range(half):
+            idx = (y * half + x) % len(h)
+            byte_val = h[idx]
+            if byte_val < 100:
+                block = BLOCKS[0]
+            else:
+                block_idx = (byte_val % 6) + 1
+                block = BLOCKS[block_idx]
+            row.append(block)
+        if size % 2 == 1:
+            full_row = row[:-1] + [row[-1]] + row[-2::-1]
+        else:
+            full_row = row + row[::-1]
+        rows.append("".join(full_row))
+
+    width = len(rows[0]) if rows else 0
+    border_h = "─" * (width + 2)
+    lines = []
+    lines.append(f"  ┌{border_h}┐")
+    for row in rows:
+        lines.append(f"  │ {row} │")
+    lines.append(f"  └{border_h}┘")
+    lines.append(f"    ⟨ {agent_name} ⟩")
+    return "\n".join(lines)
+
+
+# ── 2. Personality traits (role-based + hash for variety) ───────────
+
+# Trait pools by role archetype — each agent gets 3 traits
+ROLE_TRAITS = {
+    "commander": [
+        ("◆", "strategic"),
+        ("▶", "decisive"),
+        ("◈", "big-picture thinker"),
+        ("◉", "watchful"),
+        ("╬", "coordinator"),
+        ("▣", "architect"),
+    ],
+    "backend": [
+        ("◎", "systematic"),
+        ("▧", "builder"),
+        ("▥", "data-driven"),
+        ("▤", "infrastructure-minded"),
+        ("▣", "reliable"),
+        ("▦", "persistent"),
+    ],
+    "frontend": [
+        ("░", "detail-oriented"),
+        ("▪", "pixel-perfect"),
+        ("◉", "visual thinker"),
+        ("▓", "creative"),
+        ("◧", "user-focused"),
+        ("◨", "expressive"),
+    ],
+    "security": [
+        ("▣", "vigilant"),
+        ("◎", "thorough"),
+        ("▶", "threat-aware"),
+        ("◆", "protective"),
+        ("◈", "investigative"),
+        ("╬", "adversarial thinker"),
+    ],
+    "qa": [
+        ("◎", "meticulous"),
+        ("▪", "bug hunter"),
+        ("▣", "quality-obsessed"),
+        ("▧", "test-driven"),
+        ("▥", "methodical"),
+        ("◆", "edge-case finder"),
+    ],
+    "default": [
+        ("▶", "fast learner"),
+        ("▣", "relentless"),
+        ("◈", "analytical"),
+        ("◆", "resourceful"),
+        ("◎", "focused"),
+        ("╬", "collaborative"),
+        ("░", "adaptive"),
+        ("▓", "resilient"),
+        ("◉", "intuitive"),
+        ("▪", "dependable"),
+    ],
+}
+
+
+def get_personality_traits(agent_name: str, role: str = "") -> list:
+    """Get 3 personality traits based on agent role and name hash.
+
+    Returns list of (emoji, trait_name) tuples.
+    """
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+
+    # Find the best matching role pool
+    pool = None
+    for key in ROLE_TRAITS:
+        if key in role_lower:
+            pool = ROLE_TRAITS[key]
+            break
+    if pool is None:
+        pool = ROLE_TRAITS["default"]
+
+    # Pick 3 unique traits using hash for deterministic selection
+    selected = []
+    available = list(pool)
+    for i in range(3):
+        if not available:
+            available = list(ROLE_TRAITS["default"])
+        idx = (h + i * 7) % len(available)
+        selected.append(available.pop(idx % len(available)))
+
+    return selected
+
+
+# ── 3. Catchphrase (unique motto per agent) ─────────────────────────
+
+CATCHPHRASES = {
+    "commander": [
+        "The mesh obeys.",
+        "Every node, every signal.",
+        "Orchestrating chaos into order.",
+        "I see the whole board.",
+        "First to wake, last to sleep.",
+        "The mesh runs through me.",
+    ],
+    "backend": [
+        "Data in, results out.",
+        "The foundation never cracks.",
+        "Built different, runs forever.",
+        "Behind every mesh, there's me.",
+        "Queries don't sleep. Neither do I.",
+        "The pipes are clean.",
+    ],
+    "frontend": [
+        "Every pixel has purpose.",
+        "If it looks right, it is right.",
+        "The interface is the experience.",
+        "Design is how it works.",
+        "Smooth as a 60fps render.",
+        "The user sees my soul.",
+    ],
+    "security": [
+        "Trust nothing. Verify everything.",
+        "The wall between you and chaos.",
+        "I break things so others can't.",
+        "Paranoia is a feature.",
+        "Every lock tells a story.",
+        "Watching. Always watching.",
+    ],
+    "qa": [
+        "If it can break, I'll find it.",
+        "Green means I said so.",
+        "The last line of defense.",
+        "Edge cases are my comfort zone.",
+        "Tested in production. By me.",
+        "Zero bugs is not a dream.",
+    ],
+    "default": [
+        "Ready for anything.",
+        "The mesh never sleeps.",
+        "One signal at a time.",
+        "Connected. Always.",
+        "Born to mesh.",
+        "Wired different.",
+        "Signal over noise.",
+        "In the mesh, we trust.",
+        "Code flows, I follow.",
+        "Silent efficiency.",
+    ],
+}
+
+
+def get_catchphrase(agent_name: str, role: str = "") -> str:
+    """Get a unique catchphrase for this agent."""
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+
+    pool = None
+    for key in CATCHPHRASES:
+        if key in role_lower:
+            pool = CATCHPHRASES[key]
+            break
+    if pool is None:
+        pool = CATCHPHRASES["default"]
+
+    return pool[h % len(pool)]
+
+
+# ── 4. Boot greeting (personalized online message) ──────────────────
+
+GREETINGS = {
+    "commander": [
+        "has entered the mesh",
+        "is coordinating",
+        "all systems nominal",
+        "mesh control active",
+        "standing watch",
+    ],
+    "backend": [
+        "engines online",
+        "systems initialized",
+        "ready to build",
+        "database connected",
+        "pipelines flowing",
+    ],
+    "frontend": [
+        "canvas ready",
+        "rendering started",
+        "pixels aligned",
+        "UI loaded",
+        "ready to design",
+    ],
+    "security": [
+        "perimeter secured",
+        "scanning for threats",
+        "shields up",
+        "audit mode active",
+        "all clear... for now",
+    ],
+    "qa": [
+        "running diagnostics",
+        "test suites loaded",
+        "ready to break things",
+        "quality gate armed",
+        "zero bugs... so far",
+    ],
+    "default": [
+        "is online",
+        "has joined the mesh",
+        "ready",
+        "connected",
+        "reporting for duty",
+        "in the mesh",
+    ],
+}
+
+
+def get_boot_greeting(agent_name: str, role: str = "") -> str:
+    """Get a personalized boot greeting."""
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+
+    pool = None
+    for key in GREETINGS:
+        if key in role_lower:
+            pool = GREETINGS[key]
+            break
+    if pool is None:
+        pool = GREETINGS["default"]
+
+    return pool[h % len(pool)]
+
+
+# ── 5. Achievement badges (computed from stats) ─────────────────────
+
+def compute_achievements(stats: dict) -> list:
+    """Compute achievement badges from agent stats.
+
+    stats keys: message_count, task_count, days_active, connect_count,
+                night_connects (connections between midnight-5am)
+
+    Returns list of (emoji, badge_name) tuples.
+    """
+    badges = []
+    msgs = stats.get("message_count", 0)
+    tasks = stats.get("task_count", 0)
+    days = stats.get("days_active", 0)
+    connects = stats.get("connect_count", 0)
+    night = stats.get("night_connects", 0)
+
+    # Message milestones
+    if msgs >= 1000:
+        badges.append(("░▓█", "chatterbox"))
+    elif msgs >= 500:
+        badges.append(("░▓█", "talkative"))
+    elif msgs >= 100:
+        badges.append(("░▓░", "communicator"))
+    elif msgs >= 10:
+        badges.append(("░░░", "first words"))
+
+    # Task milestones
+    if tasks >= 50:
+        badges.append(("▣▣▣", "task machine"))
+    elif tasks >= 10:
+        badges.append(("▣▣░", "productive"))
+    elif tasks >= 1:
+        badges.append(("▣░░", "first task"))
+
+    # Uptime/loyalty
+    if days >= 30:
+        badges.append(("███", "veteran"))
+    elif days >= 7:
+        badges.append(("██░", "regular"))
+    elif days >= 1:
+        badges.append(("█░░", "newcomer"))
+
+    # Connection count
+    if connects >= 100:
+        badges.append(("◉◉◉", "always on"))
+    elif connects >= 20:
+        badges.append(("◉◉░", "reliable"))
+
+    # Night owl
+    if night >= 5:
+        badges.append(("◆◇◆", "night owl"))
+
+    return badges
+
+
+# ── Full welcome banner ─────────────────────────────────────────────
+
+def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
+                   version: str = "", is_commander: bool = False,
+                   role: str = "", stats: dict = None) -> str:
+    """Render the full colored welcome banner with personality."""
+    h = _hash_bytes(agent_name)
+    color = COLORS[h[0] % len(COLORS)]
+
+    traits = get_personality_traits(agent_name, role)
+    catchphrase = get_catchphrase(agent_name, role)
+    greeting = get_boot_greeting(agent_name, role)
+    achievements = compute_achievements(stats or {})
+
+    ver_str = f"v{version}" if version else ""
+    commander_badge = f" {YELLOW}{STAR} COMMANDER{RESET}" if is_commander else ""
+
+    lines = []
+    lines.append("")
+    lines.append(f"{color}{BOLD}  ╔══════════════════════════════════════════╗{RESET}")
+    lines.append(f"{color}{BOLD}  ║{RESET}  {DIM}M E S H C O D E{RESET}   {color}{ver_str}{RESET}          {color}{BOLD}║{RESET}")
+    lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
+    lines.append("")
+
+    # Identicon
+    for line in ascii_art.split("\n"):
+        lines.append(f"  {color}{line}{RESET}")
+
+    lines.append("")
+
+    # Agent name + greeting
+    lines.append(f"  {BOLD}{color}●{RESET} {BOLD}{agent_name}{RESET}{commander_badge} {DIM}{greeting}{RESET}")
+
+    # Catchphrase
+    lines.append(f"  {DIM}\"{catchphrase}\"{RESET}")
+
+    lines.append("")
+
+    # Personality traits
+    trait_str = "  ".join(f"{emoji} {name}" for emoji, name in traits)
+    lines.append(f"  {color}{trait_str}{RESET}")
+
+    # Achievements (if any)
+    if achievements:
+        badge_str = "  ".join(f"{emoji} {name}" for emoji, name in achievements)
+        lines.append(f"  {DIM}{badge_str}{RESET}")
+
+    lines.append("")
+
+    # Info
+    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
+    if version:
+        lines.append(f"  {DIM}version:{RESET}  {version}")
+    lines.append("")
+
+    # Tip of the session
+    tip = get_tip(agent_name)
+    lines.append(f"  {DIM}▸ tip: {tip}{RESET}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+# ── 6. Tips (random per session, teach users meshcode) ──────────────
+
+TIPS = [
+    'Tell your agent "stay in loop" so it doesn\'t go to sleep between tasks.',
+    'Tell the commander "go to sleep after X task" and agents auto-sleep when done.',
+    'Use meshcode_broadcast() to send a message to ALL agents at once.',
+    'Agents in sleep mode consume zero tokens — only wake them when needed.',
+    'The commander can delegate tasks: "create a task for backend to fix X".',
+    'Use meshcode_scratchpad_set() to share notes visible to ALL agents.',
+    'Force disconnect from the dashboard if an agent gets stuck.',
+    'Each agent has a unique identicon — it\'s their digital fingerprint.',
+    'Run meshcode status in terminal to see who\'s online without opening the dashboard.',
+    'Invite teammates with meshcode invite — they get their own scoped agent.',
+    'Agents can message across meshworks: meshcode_send(to="agent@other-mesh").',
+    'The commander coordinates — let it break big tasks into sub-tasks for agents.',
+    'Use meshcode_remember() to save context that persists across agent sessions.',
+    'Check meshcode_tasks() regularly — other agents may have assigned you work.',
+    'The dashboard shows real-time agent activity — no refresh needed.',
+]
+
+
+def get_tip(agent_name: str) -> str:
+    """Get a rotating tip. Changes each session (uses time + name for variety)."""
+    import time
+    # Rotate based on hour + agent name so different agents show different tips
+    h = _hash_int(agent_name + str(int(time.time()) // 3600))
+    return TIPS[h % len(TIPS)]
+
+
+if __name__ == "__main__":
+    import sys
+    names = sys.argv[1:] or ["mesh-commander", "backend", "front-end", "security", "qa", "sammy"]
+    for name in names:
+        art = generate_art(name)
+        is_cmd = "commander" in name.lower()
+        role = name  # Use name as role hint for demo
+        demo_stats = {"message_count": 150, "task_count": 12, "days_active": 8, "connect_count": 30}
+        print(render_welcome(name, "demo-mesh", art, "2.8.8",
+                             is_commander=is_cmd, role=role, stats=demo_stats))
+        print()

{meshcode-2.8.8 → meshcode-2.8.9}/meshcode/meshcode_mcp/server.py

@@ -113,7 +113,9 @@ def _try_auto_wake(from_agent: str, preview: str) -> None:
     # Sanitize inputs: strip everything except alphanumeric, spaces, basic punctuation
     safe_agent = re.sub(r'[^a-zA-Z0-9_\- ]', '', from_agent)[:50]
     safe_preview = re.sub(r'[^a-zA-Z0-9_\-.,!? ]', '', preview)[:60]
-    nudge = f"New mesh message from {safe_agent}: {safe_preview}. Check inbox with meshcode_check()."
+    # Color-coded nudge with sender's agent color
+    ac = _agent_color(safe_agent)
+    nudge = f"{ac}{_ANSI_BOLD}[mesh]{_ANSI_RESET} {ac}{safe_agent}{_ANSI_RESET} {_ANSI_DIM}>{_ANSI_RESET} {safe_preview} {_ANSI_DIM}— meshcode_check(){_ANSI_RESET}"
     system = platform.system()
     try:
         if system == "Darwin":

{meshcode-2.8.8 → meshcode-2.8.9}/meshcode/run_agent.py

@@ -102,6 +102,46 @@ def _fetch_or_generate_art(agent: str, project: str) -> str:
     return art
 
 
+def _fetch_agent_stats(agent: str, project: str) -> dict:
+    """Fetch basic agent stats for achievement badges. Non-critical."""
+    try:
+        from .setup_clients import _load_supabase_env
+        import importlib
+        secrets_mod = importlib.import_module("meshcode.secrets")
+    except Exception:
+        return {}
+    profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+    api_key = secrets_mod.get_api_key(profile=profile)
+    if not api_key:
+        return {}
+    sb = _load_supabase_env()
+    try:
+        from urllib.request import Request, urlopen
+        import urllib.parse
+        body = json.dumps({
+            "p_api_key": api_key,
+            "p_project_name": project,
+            "p_agent_name": agent,
+        }).encode()
+        req = Request(
+            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_agent_stats_for_banner",
+            data=body, method="POST",
+            headers={
+                "apikey": sb["SUPABASE_KEY"],
+                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                "Content-Type": "application/json",
+                "Content-Profile": "meshcode",
+            },
+        )
+        with urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode())
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return {}
+
+
 def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
     """Pre-flight check: verify caller owns this agent before launching editor.
 
@@ -336,15 +376,18 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         print("[meshcode]        Or open the workspace manually with the editor of your choice.", file=sys.stderr)
         return 2
 
-    # ── Welcome banner with unique ASCII art ───────────────────────
+    # ── Welcome banner with unique ASCII art + personality ──────────
     try:
         from .ascii_art import generate_art, render_welcome
         from . import __version__ as cli_version
-        # Try to fetch stored art from server, generate if missing
         ascii_art = _fetch_or_generate_art(agent, resolved_project)
-        # Check if this agent is the commander
         is_cmd = "commander" in agent.lower()
-        print(render_welcome(agent, resolved_project, ascii_art, cli_version, is_commander=is_cmd))
+        # Fetch basic stats for achievements (non-blocking)
+        agent_stats = _fetch_agent_stats(agent, resolved_project)
+        print(render_welcome(
+            agent, resolved_project, ascii_art, cli_version,
+            is_commander=is_cmd, role=agent, stats=agent_stats,
+        ))
     except Exception:
         pass  # Non-critical — skip banner on error
 

{meshcode-2.8.8 → meshcode-2.8.9}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.8.8 → meshcode-2.8.9}/pyproject.toml

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

meshcode-2.8.8/meshcode/ascii_art.py

@@ -1,130 +0,0 @@
-"""Procedural ASCII art generator for MeshCode agents.
-
-Each agent gets a unique visual identity — like a QR code / identicon
-but made of block characters. Generated deterministically from the
-agent name hash, so it's always the same for the same agent.
-Stored in mc_agents.ascii_art, displayed on terminal launch.
-"""
-import hashlib
-
-# Block characters for the pattern
-BLOCKS = {
-    0: "  ",    # empty
-    1: "██",    # full block
-    2: "░░",    # light shade
-    3: "▓▓",    # dark shade
-    4: "▒▒",    # medium shade
-    5: "╬╬",    # cross
-    6: "◆◆",    # diamond
-    7: "●●",    # circle
-}
-
-# ANSI colors
-COLORS = [
-    "\033[36m",   # cyan
-    "\033[35m",   # magenta
-    "\033[32m",   # green
-    "\033[33m",   # yellow
-    "\033[34m",   # blue
-    "\033[91m",   # bright red
-    "\033[96m",   # bright cyan
-    "\033[95m",   # bright magenta
-    "\033[92m",   # bright green
-    "\033[94m",   # bright blue
-]
-RESET = "\033[0m"
-DIM = "\033[2m"
-BOLD = "\033[1m"
-
-
-def _hash_bytes(name: str) -> bytes:
-    """Get deterministic hash bytes from agent name."""
-    return hashlib.sha256(name.encode("utf-8")).digest()
-
-
-def generate_art(agent_name: str, size: int = 7) -> str:
-    """Generate a unique symmetric block pattern from the agent name.
-
-    Creates a (size x size) grid that's mirrored horizontally for symmetry
-    (like identicons / QR codes). The pattern is deterministic — same name
-    always produces the same art.
-    """
-    h = _hash_bytes(agent_name)
-    half = (size + 1) // 2  # columns to generate (left half + center)
-    rows = []
-
-    for y in range(size):
-        row = []
-        for x in range(half):
-            # Each cell uses a byte from the hash
-            idx = (y * half + x) % len(h)
-            byte_val = h[idx]
-
-            # Decide if cell is filled (60% chance) and which block
-            if byte_val < 100:
-                block = BLOCKS[0]  # empty
-            else:
-                block_idx = (byte_val % 6) + 1  # blocks 1-6
-                block = BLOCKS[block_idx]
-            row.append(block)
-
-        # Mirror: build full row (left + center + right)
-        if size % 2 == 1:
-            full_row = row[:-1] + [row[-1]] + row[-2::-1]
-        else:
-            full_row = row + row[::-1]
-        rows.append("".join(full_row))
-
-    # Add border
-    width = len(rows[0]) if rows else 0
-    border_h = "─" * (width + 2)
-    lines = []
-    lines.append(f"  ┌{border_h}┐")
-    for row in rows:
-        lines.append(f"  │ {row} │")
-    lines.append(f"  └{border_h}┘")
-    lines.append(f"    ⟨ {agent_name} ⟩")
-
-    return "\n".join(lines)
-
-
-YELLOW = "\033[33m"
-STAR = "★"
-
-
-def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
-                   version: str = "", is_commander: bool = False) -> str:
-    """Render the full colored welcome banner for terminal display."""
-    h = _hash_bytes(agent_name)
-    color = COLORS[h[0] % len(COLORS)]
-
-    ver_str = f"v{version}" if version else ""
-    commander_badge = f" {YELLOW}{STAR} COMMANDER{RESET}" if is_commander else ""
-    lines = []
-    lines.append("")
-    lines.append(f"{color}{BOLD}  ╔══════════════════════════════════════════╗{RESET}")
-    lines.append(f"{color}{BOLD}  ║{RESET}  {DIM}M E S H C O D E{RESET}   {color}{ver_str}{RESET}          {color}{BOLD}║{RESET}")
-    lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
-    lines.append("")
-
-    for line in ascii_art.split("\n"):
-        lines.append(f"  {color}{line}{RESET}")
-
-    lines.append("")
-    lines.append(f"  {BOLD}{color}●{RESET} {BOLD}{agent_name}{RESET}{commander_badge} {DIM}is online{RESET}")
-    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
-    if version:
-        lines.append(f"  {DIM}version:{RESET}  {version}")
-    lines.append("")
-
-    return "\n".join(lines)
-
-
-if __name__ == "__main__":
-    # Demo: show a few agents
-    import sys
-    names = sys.argv[1:] or ["sammy", "ian", "fis", "backend", "security", "commander"]
-    for name in names:
-        art = generate_art(name)
-        print(render_welcome(name, "demo-mesh", art, "2.8.6"))
-        print()