meshcode 2.8.9__tar.gz → 2.9.1__tar.gz

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

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

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

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

meshcode-2.9.1/meshcode/ascii_art.py

@@ -0,0 +1,468 @@
+"""Procedural ASCII art + agent personality generator for MeshCode.
+
+Each agent gets:
+- Unique identicon (QR-style, varied borders, from SHA-256 hash)
+- Personality traits (based on actual role)
+- Catchphrase (unique motto)
+- Boot greeting (personalized online message)
+- Achievements (from real stats)
+- Session tips
+
+Identicons are GUARANTEED unique — SHA-256 produces 2^256 patterns.
+The embedded tag ⟨ meshwork/agent ⟩ enables paste-to-run.
+"""
+import hashlib
+
+# ── Block characters ────────────────────────────────────────────────
+BLOCKS = {
+    0: "  ",    # empty
+    1: "██",    # full block
+    2: "░░",    # light shade
+    3: "▓▓",    # dark shade
+    4: "▒▒",    # medium shade
+    5: "╬╬",    # cross
+    6: "◆◆",    # diamond
+}
+
+# ── Border styles (varied shapes per agent) ─────────────────────────
+BORDERS = [
+    # 0: Classic box
+    {"tl": "┌", "tr": "┐", "bl": "└", "br": "┘", "h": "─", "v": "│"},
+    # 1: Double line
+    {"tl": "╔", "tr": "╗", "bl": "╚", "br": "╝", "h": "═", "v": "║"},
+    # 2: Rounded
+    {"tl": "╭", "tr": "╮", "bl": "╰", "br": "╯", "h": "─", "v": "│"},
+    # 3: Heavy
+    {"tl": "┏", "tr": "┓", "bl": "┗", "br": "┛", "h": "━", "v": "┃"},
+    # 4: Diamond frame
+    {"tl": "◇", "tr": "◇", "bl": "◇", "br": "◇", "h": "─", "v": "│"},
+    # 5: Dot frame
+    {"tl": "●", "tr": "●", "bl": "●", "br": "●", "h": "·", "v": "·"},
+    # 6: Block frame
+    {"tl": "▛", "tr": "▜", "bl": "▙", "br": "▟", "h": "▀", "v": "▌"},
+    # 7: Arrow frame
+    {"tl": "▸", "tr": "◂", "bl": "▸", "br": "◂", "h": "─", "v": "│"},
+]
+
+# ── Shapes (grid layout variations) ─────────────────────────────────
+# Each shape defines which cells are "active" in a 9x9 grid
+# This gives different silhouettes beyond just square
+
+SHAPES = [
+    "square",       # 0: full square
+    "diamond",      # 1: diamond/rhombus
+    "hexagon",      # 2: hex-ish
+    "shield",       # 3: shield shape (wide top, narrow bottom)
+    "circle",       # 4: circular-ish
+    "cross",        # 5: plus/cross shape
+]
+
+
+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)
+
+
+def _in_shape(shape: str, y: int, x: int, size: int) -> bool:
+    """Check if cell (y,x) is inside the given shape."""
+    cy, cx = size // 2, size // 2
+    if shape == "square":
+        return True
+    elif shape == "diamond":
+        return abs(y - cy) + abs(x - cx) <= cy
+    elif shape == "hexagon":
+        return abs(y - cy) + max(0, abs(x - cx) - 1) <= cy
+    elif shape == "shield":
+        # Wide top, tapers at bottom
+        max_width = cx - max(0, (y - cy)) * (cx // (size - cy))
+        return abs(x - cx) <= max(1, cx - max(0, y - cy))
+    elif shape == "circle":
+        return ((y - cy) ** 2 + (x - cx) ** 2) <= (cy + 0.5) ** 2
+    elif shape == "cross":
+        return abs(y - cy) <= 1 or abs(x - cx) <= 1
+    return True
+
+
+def generate_art(agent_name: str, meshwork_name: str = "", size: int = 7) -> str:
+    """Generate a unique identicon with varied border and shape.
+
+    The pattern is deterministic from the agent name — same name = same art.
+    Embeds meshwork/agent tag for paste-to-run feature.
+    """
+    h = _hash_bytes(agent_name)
+    hi = _hash_int(agent_name)
+
+    # Select border style and shape from hash
+    border = BORDERS[h[0] % len(BORDERS)]
+    shape = SHAPES[h[1] % len(SHAPES)]
+
+    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]
+
+            # Check if this cell is inside the shape
+            # Mirror x for full width check
+            full_x = x  # left half
+            if not _in_shape(shape, y, full_x, size):
+                row.append(BLOCKS[0])
+                continue
+
+            # Fill decision: vary density based on hash byte
+            if byte_val < 90:
+                block = BLOCKS[0]  # empty
+            else:
+                block_idx = (byte_val % 6) + 1
+                block = BLOCKS[block_idx]
+            row.append(block)
+
+        # Mirror: build full row
+        if size % 2 == 1:
+            full_row = row[:-1] + [row[-1]] + row[-2::-1]
+        else:
+            full_row = row + row[::-1]
+        rows.append("".join(full_row))
+
+    # Build framed output
+    width = len(rows[0]) if rows else 0
+    border_h = border["h"] * (width + 2)
+    lines = []
+    lines.append(f"  {border['tl']}{border_h}{border['tr']}")
+    for row in rows:
+        lines.append(f"  {border['v']} {row} {border['v']}")
+    lines.append(f"  {border['bl']}{border_h}{border['br']}")
+
+    # Embedded tag (visual identity)
+    if meshwork_name:
+        lines.append(f"    ⟨ {meshwork_name}/{agent_name} ⟩")
+    else:
+        lines.append(f"    ⟨ {agent_name} ⟩")
+
+    return "\n".join(lines)
+
+
+# ── 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 = "★"
+
+
+# ── 2. Personality traits (role-based) ──────────────────────────────
+
+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"),
+    ],
+}
+
+
+ROLE_KEYWORDS = {
+    "commander": ["lead", "commander", "coordinator", "manager", "architect", "cmo", "partner", "founder", "maintainer", "oncall-lead", "sre-lead", "security-lead", "editor"],
+    "backend": ["backend", "api", "database", "db", "server", "infra", "devops", "gateway", "loader", "extractor", "pipeline", "build", "deploy", "operations", "ingestion"],
+    "frontend": ["frontend", "ui", "ux", "design", "mobile", "ios", "android", "social", "writer", "driver", "navigator", "email", "content"],
+    "security": ["security", "audit", "compliance", "forensics", "siem", "threat", "auth"],
+    "qa": ["qa", "test", "quality", "review", "eval", "critic", "triager", "investigator", "analyst", "metrics", "logs", "traces"],
+}
+
+
+def get_personality_traits(agent_name: str, role: str = "", stats: dict = None) -> list:
+    """Get traits based on role_description keywords + real stats.
+
+    Combines role-based traits (from what the agent IS) with
+    stats-based traits (from what the agent DOES).
+    """
+    h = _hash_int(agent_name)
+    role_lower = (role or agent_name).lower()
+    stats = stats or {}
+
+    # Match role keywords to find the best trait pool
+    pool = None
+    best_match = 0
+    for key, keywords in ROLE_KEYWORDS.items():
+        matches = sum(1 for kw in keywords if kw in role_lower)
+        if matches > best_match:
+            best_match = matches
+            pool = ROLE_TRAITS[key]
+    if pool is None:
+        pool = ROLE_TRAITS["default"]
+
+    # Pick 2 role-based traits
+    selected = []
+    available = list(pool)
+    for i in range(2):
+        if not available:
+            available = list(ROLE_TRAITS["default"])
+        idx = (h + i * 7) % len(available)
+        selected.append(available.pop(idx % len(available)))
+
+    # Add 1 stats-based trait (earned through behavior)
+    msgs = stats.get("message_count", 0)
+    tasks = stats.get("task_count", 0)
+    connects = stats.get("connect_count", 0)
+
+    if msgs > 500:
+        selected.append(("░▓█", "prolific"))
+    elif tasks > 20:
+        selected.append(("▣▣▣", "workhorse"))
+    elif connects > 50:
+        selected.append(("◉◉◉", "always-on"))
+    elif msgs > 100:
+        selected.append(("░▓░", "communicative"))
+    elif tasks > 5:
+        selected.append(("▣▣░", "productive"))
+    else:
+        # Fallback: pick from default pool
+        dflt = list(ROLE_TRAITS["default"])
+        selected.append(dflt[(h + 99) % len(dflt)])
+
+    return selected
+
+
+# ── 3. Catchphrase ──────────────────────────────────────────────────
+
+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:
+    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 ────────────────────────────────────────────────
+
+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:
+    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 ──────────────────────────────────────────
+
+def compute_achievements(stats: dict) -> list:
+    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)
+
+    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"))
+
+    if tasks >= 50:      badges.append(("▣▣▣", "task machine"))
+    elif tasks >= 10:    badges.append(("▣▣░", "productive"))
+    elif tasks >= 1:     badges.append(("▣░░", "first task"))
+
+    if days >= 30:       badges.append(("███", "veteran"))
+    elif days >= 7:      badges.append(("██░", "regular"))
+    elif days >= 1:      badges.append(("█░░", "newcomer"))
+
+    if connects >= 100:  badges.append(("◉◉◉", "always on"))
+    elif connects >= 20: badges.append(("◉◉░", "reliable"))
+
+    if night >= 5:       badges.append(("◆◇◆", "night owl"))
+
+    return badges
+
+
+# ── 6. Tips ─────────────────────────────────────────────────────────
+
+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.',
+    '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.',
+    'Use meshcode_remember() to save context across agent sessions.',
+    'Check meshcode_tasks() regularly — other agents may have assigned you work.',
+    'Paste an agent\'s identicon in terminal to launch it instantly.',
+]
+
+
+def get_tip(agent_name: str) -> str:
+    import time
+    h = _hash_int(agent_name + str(int(time.time()) // 3600))
+    return TIPS[h % len(TIPS)]
+
+
+# ── 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:
+    h = _hash_bytes(agent_name)
+    color = COLORS[h[0] % len(COLORS)]
+
+    traits = get_personality_traits(agent_name, role, stats or {})
+    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("")
+
+    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}{greeting}{RESET}")
+    lines.append(f"  {DIM}\"{catchphrase}\"{RESET}")
+    lines.append("")
+
+    trait_str = "  ".join(f"{emoji} {name}" for emoji, name in traits)
+    lines.append(f"  {color}{trait_str}{RESET}")
+
+    if achievements:
+        badge_str = "  ".join(f"{emoji} {name}" for emoji, name in achievements)
+        lines.append(f"  {DIM}{badge_str}{RESET}")
+
+    lines.append("")
+    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
+    if version:
+        lines.append(f"  {DIM}version:{RESET}  {version}")
+    lines.append("")
+
+    tip = get_tip(agent_name)
+    lines.append(f"  {DIM}▸ tip: {tip}{RESET}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+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, "demo-mesh")
+        is_cmd = "commander" in name.lower()
+        demo_stats = {"message_count": 150, "task_count": 12, "days_active": 8, "connect_count": 30}
+        print(render_welcome(name, "demo-mesh", art, "2.8.9",
+                             is_commander=is_cmd, role=name, stats=demo_stats))
+        print()

{meshcode-2.8.9 → meshcode-2.9.1}/meshcode/comms_v4.py

@@ -2180,6 +2180,49 @@ if __name__ == "__main__":
         _run = importlib.import_module("meshcode.run_agent").run
         sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override))
 
+    elif cmd == "scan":
+        # meshcode scan — detect identicon from stdin/clipboard and launch agent
+        import re as _re
+        art_text = ""
+        # Try clipboard first (pyperclip optional)
+        try:
+            import pyperclip
+            art_text = pyperclip.paste() or ""
+        except Exception:
+            pass
+        # If no clipboard content, read from stdin
+        if not art_text and not sys.stdin.isatty():
+            art_text = sys.stdin.read()
+        if not art_text:
+            print("Usage: meshcode scan")
+            print("  Reads an agent identicon from clipboard or stdin.")
+            print("  Detects the ⟨ agent_name ⟩ tag and launches meshcode run.")
+            print()
+            print("  Examples:")
+            print("    meshcode scan                  # reads from clipboard")
+            print("    cat identicon.txt | meshcode scan  # reads from stdin")
+            sys.exit(1)
+        # Look for ⟨ agent ⟩ or ⟨ meshwork/agent ⟩
+        match = _re.search(r'⟨\s*(\S+)\s*⟩', art_text)
+        if not match:
+            print("[meshcode] No identicon tag found. Expected: ⟨ agent_name ⟩")
+            sys.exit(1)
+        tag = match.group(1)
+        if "/" in tag:
+            _proj, _agent = tag.split("/", 1)
+        else:
+            _agent = tag
+            _proj = None
+        print(f"[meshcode] Detected agent: {_agent}" + (f" (project: {_proj})" if _proj else ""))
+        # Auth check
+        api_key = _load_api_key_for_cli()
+        if not api_key:
+            print("[meshcode] Not logged in. Run: meshcode login <api_key>")
+            sys.exit(1)
+        import importlib
+        _run = importlib.import_module("meshcode.run_agent").run
+        sys.exit(_run(_agent, project=_proj))
+
     elif cmd == "invite":
         # meshcode invite <project> <agent> [--role "..."] [--days N]
         if len(pos) < 2:

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

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

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

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

meshcode-2.8.9/meshcode/ascii_art.py

@@ -1,466 +0,0 @@
-"""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()