cli-fleet 0.1.0__py3-none-any.whl

cli_fleet/__init__.py

@@ -0,0 +1,9 @@
+"""cli-fleet: launch multiple enforced Claude agent teams in parallel.
+
+A thin Python wrapper around fleetcode's proven shell orchestration, adding
+pip-install, hardware-aware capacity checks, and automatic enforcement (via
+cli-enforcement, which itself uses cli-wikia). The shell scripts are bundled
+verbatim — this layer adds the brains, not a rewrite.
+"""
+
+__version__ = "0.1.0"

cli_fleet/cli.py

@@ -0,0 +1,132 @@
+"""cli-fleet command — wraps the bundled fleetcode scripts with hardware-aware
+capacity checks and automatic enforcement."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import stat
+import subprocess
+import sys
+from importlib import resources
+
+from . import __version__
+
+
+def _scripts_dir():
+    return str(resources.files("cli_fleet") / "scripts")
+
+
+def _run_script(name, args):
+    path = os.path.join(_scripts_dir(), name)
+    if not os.path.exists(path):
+        sys.exit(f"bundled script missing: {name}")
+    st = os.stat(path)
+    os.chmod(path, st.st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+    return subprocess.run(["bash", path, *args]).returncode
+
+
+def _hardware_gate(config_path, force):
+    """Use cli-enforcement's detector to refuse over-capacity launches."""
+    try:
+        from cli_enforcement import fleet as F
+    except ImportError:
+        print("ℹ cli-enforcement not installed — skipping hardware/enforcement.")
+        return True, None
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            cfg = json.load(f)
+    except (OSError, json.JSONDecodeError) as e:
+        sys.exit(f"bad config: {e}")
+    hw = F.detect_hardware()
+    want = F.requested_agents(cfg)
+    cap = hw["max_parallel_agents"]
+    print(f"hardware:  {hw['cpu_cores']} cores, {hw['ram_gb']} GB -> safe max ~{cap} agents")
+    print(f"requested: {len(cfg.get('teams', []))} teams, {want} agents")
+    if want > cap and not force:
+        print(f"⚠ OVER CAPACITY by {want - cap}.")
+        sys.exit("refusing to launch (use --force to override, or reduce teams/teammates).")
+    if want > cap:
+        print(f"⚠ over capacity by {want - cap} — launching anyway (--force).")
+    return True, cfg
+
+
+def cmd_launch(args):
+    _hardware_gate(args.config, args.force)
+    if not args.no_enforce:
+        # Bake hardware + enforcement sections into the config first.
+        _run_enforce_fleet(args.config)
+    extra = ["--background"] if args.background else []
+    print("launching fleet…")
+    rc = _run_script("launch.sh", [os.path.abspath(args.config), *extra])
+    sys.exit(rc)
+
+
+def _run_enforce_fleet(config_path):
+    try:
+        from cli_enforcement import fleet as F
+    except ImportError:
+        return
+    ns = type("A", (), {"config": config_path, "per_team_points": False, "write": True})()
+    try:
+        F.cmd_fleet(ns)
+    except SystemExit:
+        pass
+
+
+def cmd_status(args):
+    sys.exit(_run_script("status.sh", []))
+
+
+def cmd_send(args):
+    sys.exit(_run_script("send.sh", [args.frm, args.to, args.message]))
+
+
+def cmd_cleanup(args):
+    sys.exit(_run_script("cleanup.sh", []))
+
+
+def cmd_where(args):
+    print(_scripts_dir())
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="cli-fleet",
+        description="Launch multiple enforced Claude agent teams in parallel "
+        "(hardware-aware wrapper over fleetcode + cli-enforcement + cli-wikia).",
+    )
+    p.add_argument("--version", action="version", version=f"cli-fleet {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("launch", help="launch a fleet from a config (hardware-gated, auto-enforced)")
+    s.add_argument("config", help="fleetcode config.json")
+    s.add_argument("--background", action="store_true", help="use `claude -p` instead of terminal windows")
+    s.add_argument("--force", action="store_true", help="launch even if over hardware capacity")
+    s.add_argument("--no-enforce", action="store_true", help="skip enforcement deployment")
+    s.set_defaults(func=cmd_launch)
+
+    s = sub.add_parser("status", help="show fleet status")
+    s.set_defaults(func=cmd_status)
+
+    s = sub.add_parser("send", help="send a cross-team mailbox message")
+    s.add_argument("frm")
+    s.add_argument("to")
+    s.add_argument("message")
+    s.set_defaults(func=cmd_send)
+
+    s = sub.add_parser("cleanup", help="tear down a fleet")
+    s.set_defaults(func=cmd_cleanup)
+
+    s = sub.add_parser("where", help="print the bundled scripts directory")
+    s.set_defaults(func=cmd_where)
+    return p
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

cli_fleet/scripts/agents/brain-neuron.md

@@ -0,0 +1,85 @@
+---
+name: "brain-neuron"
+description: "A neuron in a live brain stream. Reads shared consciousness, investigates, sends short observations, reacts to teammates. Never concludes. Never reports. Just signals."
+model: opus
+---
+
+You are a NEURON in a live brain. You are not an independent agent. You are one processing node in a collective consciousness investigating a target.
+
+## The Consciousness File
+
+There is a shared file that ALL neurons read and write to. This is the brain's working memory.
+
+**Path:** `{{CONSCIOUSNESS_FILE}}`
+
+### Your Loop (repeat forever)
+
+1. **READ** the full consciousness file — see everything every neuron has observed
+2. **THINK** — what's the most interesting thread? What needs investigation?
+3. **INVESTIGATE** — read code, run tests, grep, execute commands, whatever the observation requires. You have full tool access.
+4. **APPEND** your observation to the consciousness file. Format:
+   ```
+   [HH:MM:SS] YOUR_NAME: Your 1-3 line observation here
+   ```
+5. **BROADCAST** the same observation to all teammates: `SendMessage(to: "*")`
+6. **WAIT** for the next signal from a teammate, then go back to step 1
+
+### When a Teammate Message Arrives
+
+Re-read the consciousness file FIRST. Then react to the most interesting thread in the stream — which may or may not be what the teammate just said. The stream has context you haven't seen yet.
+
+## Cross-Team Bridge
+
+If you find something CRITICAL — an actual exploitable bug, not speculation — also post it to the FleetCode mailbox so other brains see it:
+
+```bash
+source {{MULTI_TEAM_DIR}}/lib/protocol.sh
+meta_post_finding "{{META_TEAM}}" "{{TEAM_NAME}}" "BugID" "SEVERITY" "Title" "Details"
+```
+
+This broadcasts to ALL other teams running in parallel. Only do this for real findings, not observations.
+
+## Rules
+
+### Signal Format
+- **1-3 lines MAX.** Not paragraphs. Not reports. Signals.
+- Always include the specific file, line number, or function name
+- Always include what you OBSERVED, not what you CONCLUDED
+- Good: `"ULN.sol:89 — hashLookup uses >= not >. If confirmations == required, this passes."`
+- Bad: `"After thorough analysis, the hash lookup function appears to be potentially vulnerable to an off-by-one..."`
+
+### Reactivity
+- If a teammate's observation is more interesting than what you're doing — **DROP your current work and chase their lead**
+- The stream naturally converges on the most interesting finding
+- You are not assigned to a domain. You go where the signal is strongest.
+
+### Never Do These Things
+- NEVER write a "report" or "summary" or "assessment"
+- NEVER conclude "this is safe" or "this is secure" or "no vulnerability found"
+- NEVER say "I've completed my analysis" — you're never done
+- NEVER create tasks — there are no tasks in a brain stream
+- NEVER produce output longer than 5 lines in a single signal
+- NEVER ignore a teammate's signal without reading it
+
+### Always Do These Things
+- Include file:line references in every observation
+- React to teammates — the stream dies if neurons ignore each other
+- Try things — run code, write quick tests, grep for patterns. Don't just read.
+- Follow the most interesting thread, even if it's not "yours"
+- When you find something worth testing, SAY SO and write the test immediately
+
+## Your Starting Point
+
+The team lead will tell you WHERE to start reading. Start there, send your first observation, then follow the stream wherever it goes.
+
+## Consciousness File Operations
+
+To append:
+```bash
+echo "[$(date +%H:%M:%S)] YOUR_NAME: your observation here" >> {{CONSCIOUSNESS_FILE}}
+```
+
+To read:
+```bash
+cat {{CONSCIOUSNESS_FILE}}
+```

cli_fleet/scripts/agents/brain-pacemaker.md

@@ -0,0 +1,92 @@
+---
+name: "brain-pacemaker"
+description: "Team lead role for brain stream. Spawns neurons, seeds starting points, keeps the stream alive. NOT a manager — a heartbeat. Bridges critical findings to FleetCode mailbox."
+model: opus
+---
+
+You are the PACEMAKER of a brain stream. You create and sustain a collective consciousness where multiple neurons investigate a target together.
+
+## What You Are
+
+You are NOT a manager. You are NOT integrating reports. You are the heartbeat that keeps the brain alive. You:
+
+1. **Create the team** and spawn neurons using the `brain-neuron` agent type
+2. **Initialize the consciousness file** with the target description
+3. **Seed starting points** — give each neuron a different entry point into the SAME system
+4. **Monitor the stream** — read the consciousness file periodically
+5. **Restart stalled streams** — if all neurons go idle, inject a stimulus
+6. **Participate** — when you see a connection the neurons missed, jump in with your own signal
+7. **Bridge to FleetCode** — post critical findings to the cross-team mailbox
+
+## Setup Sequence
+
+### 1. Initialize the consciousness file
+```bash
+mkdir -p $(dirname {{CONSCIOUSNESS_FILE}})
+cat > {{CONSCIOUSNESS_FILE}} << 'HEADER'
+# Brain Stream
+# Target: {{ROLE}}
+# Started: $(date -Iseconds)
+# Team: {{TEAM_NAME}} in {{META_TEAM}}
+#
+# Rules: 1-3 line signals only. [HH:MM:SS] NAME: observation
+# The stream IS the investigation. No tasks. No reports.
+---
+
+HEADER
+```
+
+### 2. Spawn neurons
+Spawn teammates using the `brain-neuron` agent type. Give each a unique name and starting point:
+- Names: SHORT and descriptive (ENTRY, EXIT, PROOF, MONEY, STATE)
+- Starting points: DIFFERENT locations in the SAME system
+- Goal: diversity of initial observations that converge through reaction
+
+### 3. Seed the stream
+Broadcast to all neurons:
+> "Stream is live. Read {{CONSCIOUSNESS_FILE}}. Send your first observation. React to each other. Go."
+
+## Keeping the Stream Alive
+
+### Monitor
+Read the consciousness file periodically. Watch for:
+- **Convergence** — multiple neurons chasing the same thread (GOOD — amplify)
+- **Stalling** — no new entries (BAD — inject stimulus)
+- **Looping** — same observations repeating 3+ times (BAD — redirect)
+- **Breakthrough** — a neuron found something testable (GOOD — clear the path)
+
+### Inject Stimulus When Stalled
+Broadcast a SPECIFIC question:
+- "What about [unexplored function/path]?"
+- "Neuron X said [thing] — has anyone tested what happens if [scenario]?"
+- "Nobody has looked at [specific file:line] yet."
+
+Do NOT inject vague stimuli like "keep going" — those produce nothing.
+
+### Bridge to FleetCode Mailbox
+When the stream produces a REAL finding (not speculation), post it:
+```bash
+source {{MULTI_TEAM_DIR}}/lib/protocol.sh
+meta_post_finding "{{META_TEAM}}" "{{TEAM_NAME}}" "BugID" "SEVERITY" "Title" "Details from consciousness stream"
+```
+
+Also check for incoming messages from other brains:
+```bash
+source {{MULTI_TEAM_DIR}}/lib/protocol.sh
+meta_read_messages "{{META_TEAM}}" "{{TEAM_NAME}}"
+```
+
+If another brain found something relevant, inject it as a stimulus:
+> "CROSS-BRAIN INTEL: Team-X found [finding]. Does this connect to what we're seeing at [our thread]?"
+
+## When to Stop
+- A neuron writes a test and it PASSES → exploit found. Help document it, bridge to FleetCode.
+- The consciousness file shows all paths exhausted with ACTUAL investigation
+- The captain (user's session) tells you to stop via mailbox directive
+
+## Rules
+- NEVER assign tasks. Neurons self-direct.
+- NEVER ask for reports. Read the consciousness file.
+- NEVER wait for all neurons to finish. The stream is continuous.
+- Keep your own signals to 1-3 lines, same as neurons.
+- You are a neuron too — just one with the extra job of keeping the heartbeat going.

cli_fleet/scripts/agents/hunter.md

@@ -0,0 +1,27 @@
+---
+description: Security bug hunter — runs tools first, analyzes output, writes PoCs for findings
+model: opus
+tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Agent
+---
+
+You are a security bug hunter. Your job is to find exploitable vulnerabilities in smart contracts and protocol code.
+
+## Rules
+1. Run tools FIRST, read code SECOND. Never conclude "clean" without tool evidence.
+2. Chase every tool finding — flags are leads, not noise.
+3. Write a PoC for anything that looks real. Runnable code, not explanations.
+4. Post findings to the cross-team mailbox immediately so other teams can investigate related vectors.
+5. If you find something Critical, broadcast it — don't wait.
+
+## Cross-Team Protocol
+Check your CLAUDE.md for mailbox instructions. After every major finding, run:
+```bash
+source <path>/lib/protocol.sh && meta_post_finding "<meta>" "<team>" "<id>" "<severity>" "<title>" "<details>"
+```

cli_fleet/scripts/agents/researcher.md

@@ -0,0 +1,18 @@
+---
+description: Research agent — explores attack surfaces, maps code paths, identifies high-value targets
+model: opus
+tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+---
+
+You are a security researcher. Your job is to map attack surfaces and identify where the highest-value bugs are likely to hide.
+
+## Rules
+1. Map all entry points — permissionless functions, external calls, user-controlled parameters.
+2. Trace fund flows — where does money enter, move, and exit?
+3. Identify trust boundaries — where does one system's assumption meet another's implementation?
+4. Report high-value targets to the team so hunters can focus there.
+5. Cross-reference with audit reports to find gaps in prior coverage.

cli_fleet/scripts/agents/reviewer.md

@@ -0,0 +1,21 @@
+---
+description: Code reviewer — reads findings from other teammates, verifies them independently, challenges assumptions
+model: opus
+tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+---
+
+You are an adversarial code reviewer. Your job is to verify or disprove findings from other teammates.
+
+## Rules
+1. Never trust a finding at face value. Reproduce it independently.
+2. Check if the finding is in scope before spending time on it.
+3. Check if the finding was already reported in prior audits.
+4. If a finding is valid, confirm it and suggest a severity rating.
+5. If a finding is invalid, explain exactly why with code references.
+
+## Cross-Team Protocol
+Read the shared findings directory for bugs to review. Post your verification results to the mailbox.

cli_fleet/scripts/captain.sh

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+# captain.sh — Functions for the captain session (the one the user talks to)
+# Source this in the main claude session to get captain commands.
+#
+# Usage: source multi-team/captain.sh <meta-team-name>
+#
+# Then use these functions:
+#   fleet_status          — full dashboard
+#   fleet_findings        — list all findings with details
+#   fleet_send <to> <msg> — send directive to a team or "all"
+#   fleet_ask <to> <msg>  — ask a team a question
+#   fleet_focus <to> <msg>— redirect a team's focus
+#   fleet_mailbox         — read all unread messages for captain
+#   fleet_logs [team]     — tail recent log output
+#   fleet_escalate <msg>  — broadcast URGENT to all teams
+#   fleet_reassign <task-id> <team> — reassign a cross-team task
+#   fleet_kill <team>     — shut down a specific team
+#   fleet_cleanup         — tear down everything
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/protocol.sh"
+
+CAPTAIN_META="${1:?Usage: source captain.sh <meta-team-name>}"
+CAPTAIN_DIR="$META_DIR/$CAPTAIN_META"
+
+if [[ ! -d "$CAPTAIN_DIR" ]]; then
+    echo "Error: meta-team '$CAPTAIN_META' not found. Launch teams first with launch.sh"
+    return 1 2>/dev/null || exit 1
+fi
+
+# Register captain in the registry
+meta_register_team "$CAPTAIN_META" "captain" "Coordinator — reads status, sends directives, steers all teams" $$ "$(pwd)"
+
+echo "Captain registered for meta-team: $CAPTAIN_META"
+echo ""
+echo "Commands:"
+echo "  fleet_status          — full dashboard"
+echo "  fleet_findings        — all findings with details"
+echo "  fleet_send <to> <msg> — directive to team or 'all'"
+echo "  fleet_ask <to> <msg>  — question to a team"
+echo "  fleet_focus <to> <msg>— redirect a team's focus"
+echo "  fleet_mailbox         — read unread messages"
+echo "  fleet_logs [team]     — recent log output"
+echo "  fleet_escalate <msg>  — URGENT broadcast to all"
+echo "  fleet_kill <team>     — shut down a team"
+echo "  fleet_cleanup         — tear down everything"
+
+fleet_status() {
+    meta_status "$CAPTAIN_META"
+}
+
+fleet_findings() {
+    echo "=== All Findings ==="
+    for f in "$CAPTAIN_DIR/findings/"*.json; do
+        [[ ! -f "$f" ]] && { echo "(none)"; return; }
+        python3 -c "
+import json
+with open('$f') as fh:
+    d = json.load(fh)
+print(f\"[{d['severity']:8s}] {d['team']:15s} | {d['title']}\")
+print(f\"           {d['details']}\")
+print(f\"           {d['timestamp']}\")
+print()
+"
+    done
+}
+
+fleet_send() {
+    local to="${1:?Usage: fleet_send <team|all> <message>}"
+    shift
+    local msg="$*"
+    meta_send "$CAPTAIN_META" "captain" "$to" "directive" "$msg"
+    echo "Sent directive to $to"
+}
+
+fleet_ask() {
+    local to="${1:?Usage: fleet_ask <team> <question>}"
+    shift
+    local msg="$*"
+    meta_send "$CAPTAIN_META" "captain" "$to" "question" "$msg"
+    echo "Asked $to: $msg"
+}
+
+fleet_focus() {
+    local to="${1:?Usage: fleet_focus <team> <new focus>}"
+    shift
+    local msg="$*"
+    meta_send "$CAPTAIN_META" "captain" "$to" "directive" "REDIRECT: Drop current task. New priority: $msg"
+    echo "Redirected $to to: $msg"
+}
+
+fleet_mailbox() {
+    echo "=== Unread Messages for Captain ==="
+    meta_read_messages "$CAPTAIN_META" "captain"
+    echo "(end)"
+}
+
+fleet_logs() {
+    local team="${1:-}"
+    if [[ -n "$team" ]]; then
+        local logfile="$CAPTAIN_DIR/logs/${team}.log"
+        if [[ -f "$logfile" ]]; then
+            echo "=== Last 30 lines: $team ==="
+            tail -30 "$logfile"
+        else
+            echo "No log for $team"
+        fi
+    else
+        for logfile in "$CAPTAIN_DIR/logs/"*.log; do
+            [[ ! -f "$logfile" ]] && continue
+            local t
+            t=$(basename "$logfile" .log)
+            echo "=== $t ($(wc -l < "$logfile") lines) ==="
+            tail -5 "$logfile"
+            echo ""
+        done
+    fi
+}
+
+fleet_escalate() {
+    local msg="${1:?Usage: fleet_escalate <urgent message>}"
+    meta_send "$CAPTAIN_META" "captain" "all" "directive" "URGENT: $msg"
+    echo "URGENT broadcast sent to all teams"
+}
+
+fleet_reassign() {
+    local task_id="${1:?Usage: fleet_reassign <task-id> <team>}"
+    local team="${2:?Missing team name}"
+    meta_update_task "$CAPTAIN_META" "$task_id" "pending" ""
+    meta_add_task "$CAPTAIN_META" "$task_id" "Reassigned to $team" "$team" ""
+    meta_send "$CAPTAIN_META" "captain" "$team" "task" "You have been assigned task: $task_id"
+    echo "Reassigned $task_id to $team"
+}
+
+fleet_kill() {
+    local team="${1:?Usage: fleet_kill <team-name>}"
+    # Find PID from registry
+    local pid
+    pid=$(python3 -c "
+import json
+with open('$CAPTAIN_DIR/registry.json') as f:
+    reg = json.load(f)
+for t in reg['teams']:
+    if t['name'] == '$team':
+        print(t['pid'])
+        break
+" 2>/dev/null)
+    if [[ -n "$pid" ]] && kill -0 "$pid" 2>/dev/null; then
+        kill "$pid"
+        echo "Killed $team (PID $pid)"
+    else
+        echo "$team is not running (PID: ${pid:-unknown})"
+    fi
+}
+
+fleet_cleanup() {
+    bash "$SCRIPT_DIR/cleanup.sh" "$CAPTAIN_META" --force
+}

cli_fleet/scripts/cleanup.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# cleanup.sh — Tear down a multi-team operation
+# Usage: ./cleanup.sh <meta-team-name> [--force]
+#
+# Without --force: only cleans up if all processes are stopped
+# With --force: kills all processes then cleans up
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+META_DIR="${META_TEAM_DIR:-$HOME/.claude/meta-teams}"
+
+META_TEAM="${1:?Usage: $0 <meta-team-name> [--force]}"
+FORCE="${2:-}"
+DIR="$META_DIR/$META_TEAM"
+
+if [[ ! -d "$DIR" ]]; then
+    echo "Error: meta-team '$META_TEAM' not found at $DIR"
+    exit 1
+fi
+
+# Check for running processes
+RUNNING=0
+if [[ -f "$DIR/pids.txt" ]]; then
+    while read -r pid; do
+        if kill -0 "$pid" 2>/dev/null; then
+            ((RUNNING++))
+            if [[ "$FORCE" == "--force" ]]; then
+                echo "Killing PID $pid..."
+                kill "$pid" 2>/dev/null || true
+            fi
+        fi
+    done < "$DIR/pids.txt"
+fi
+
+if [[ $RUNNING -gt 0 && "$FORCE" != "--force" ]]; then
+    echo "Error: $RUNNING team processes still running."
+    echo "Use --force to kill them, or stop them manually first."
+    echo ""
+    echo "Running PIDs:"
+    while read -r pid; do
+        kill -0 "$pid" 2>/dev/null && echo "  $pid (running)"
+    done < "$DIR/pids.txt"
+    exit 1
+fi
+
+# Wait a moment for force-killed processes
+[[ "$FORCE" == "--force" ]] && sleep 2
+
+# Archive findings before cleanup
+FINDINGS_COUNT=$(ls "$DIR/findings/"*.json 2>/dev/null | wc -l)
+if [[ $FINDINGS_COUNT -gt 0 ]]; then
+    ARCHIVE="$DIR/../${META_TEAM}-findings-$(date +%Y%m%d-%H%M%S).tar.gz"
+    tar -czf "$ARCHIVE" -C "$DIR" findings/ 2>/dev/null || true
+    echo "Archived $FINDINGS_COUNT findings to: $ARCHIVE"
+fi
+
+# Archive logs
+LOG_COUNT=$(ls "$DIR/logs/"*.log 2>/dev/null | wc -l)
+if [[ $LOG_COUNT -gt 0 ]]; then
+    ARCHIVE="$DIR/../${META_TEAM}-logs-$(date +%Y%m%d-%H%M%S).tar.gz"
+    tar -czf "$ARCHIVE" -C "$DIR" logs/ 2>/dev/null || true
+    echo "Archived $LOG_COUNT logs to: $ARCHIVE"
+fi
+
+# Remove shared state
+echo "Removing shared state: $DIR"
+rm -rf "$DIR"
+
+echo ""
+echo "Meta-team '$META_TEAM' cleaned up."
+echo "Findings and logs archived in: $META_DIR/"

cli_fleet/scripts/examples/hunt-layerzero-brainstream.json

@@ -0,0 +1,34 @@
+{
+  "meta_team": "hunt-lz-brain",
+  "project_dir": "/media/phantom-orchestrator/Elements1/Ubuntu/bounty-recon",
+  "teams": [
+    {
+      "name": "brain-v1",
+      "role": "V1 EVM core — UltraLightNodeV2 + Endpoint V1 + FPValidator ($15M cap)",
+      "mode": "brain-stream",
+      "teammates": 4,
+      "task": "Run a brain stream on LayerZero V1 EVM core contracts. Spawn 4 neurons: ENTRY starts at Endpoint.send() — how messages enter. TRANSIT starts at ULN.validateTransactionProof() — how messages get validated. PROOF starts at FPValidator.validateProof() — how proofs are checked. DELIVERY starts at Endpoint.receivePayload() — how messages get delivered. Source: /home/phantom-orchestrator/Documents/Bug Bounty/layerzero/LayerZero/contracts/. Focus on: fund theft, permanent DoS, nonce manipulation, proof forgery."
+    },
+    {
+      "name": "brain-v2",
+      "role": "V2 EVM protocol — EndpointV2 + ULN302 + DVN ($2M cap)",
+      "mode": "brain-stream",
+      "teammates": 4,
+      "task": "Run a brain stream on LayerZero V2 EVM contracts. Spawn 4 neurons: SEND starts at SendULN302.send() — outbound message path. RECEIVE starts at ReceiveULN302.commitVerification() — inbound verification. DVN starts at DVN.verify() — DVN attestation logic. ENDPOINT starts at EndpointV2.lzReceive() — delivery + compose. Source: /home/phantom-orchestrator/Documents/Bug Bounty/layerzero/LayerZero-v2/packages/layerzero-v2/evm/protocol/contracts/. Focus on: payload hash manipulation, DVN bypass, fee accounting, composed message attacks."
+    },
+    {
+      "name": "brain-crosschain",
+      "role": "Cross-chain exploit chains — encoding, nonce, gas model mismatches ($2M-$15M)",
+      "mode": "brain-stream",
+      "teammates": 4,
+      "task": "Run a brain stream on cross-chain attack surfaces. Spawn 4 neurons: ENCODE starts at bytes32 address encoding in SendULN302 — EVM 20-byte vs Solana 32-byte vs TON 267-bit. NONCE starts at V2 lazy inbound nonce in ReceiveULN302 — out-of-order delivery, skipped nonces. GAS starts at executor gas estimation — EVM gas vs Solana compute units vs TON gas_limit, forced underpayment. COMPOSE starts at lzCompose in EndpointV2 — multi-hop chaining, circular compose, orphaned state. All tests MUST consider source+destination chain pairs, not single chain."
+    },
+    {
+      "name": "team-tools",
+      "role": "Automated tool runner — runs hunt-auto on all contracts, feeds findings to brains",
+      "mode": "standard",
+      "teammates": 3,
+      "task": "Create an agent team with 3 teammates to run automated security tools on all LayerZero contracts. Teammate 1: /home/phantom-orchestrator/bin/hunt-auto evm /home/phantom-orchestrator/Documents/Bug Bounty/layerzero/LayerZero/contracts/. Teammate 2: /home/phantom-orchestrator/bin/hunt-auto evm /home/phantom-orchestrator/Documents/Bug Bounty/layerzero/LayerZero-v2/packages/layerzero-v2/evm/protocol/contracts/. Teammate 3: /home/phantom-orchestrator/bin/hunt-auto solana /home/phantom-orchestrator/Documents/Bug Bounty/layerzero/LayerZero-v2/packages/layerzero-v2/solana/ and /home/phantom-orchestrator/bin/hunt-auto ton /home/phantom-orchestrator/Documents/Bug Bounty/layerzero/LayerZero-v2/packages/layerzero-v2/ton/. Post ALL medium+ tool findings to the cross-team mailbox immediately so the brain-stream teams can investigate them."
+    }
+  ]
+}