cli-fleet 0.1.0__tar.gz

cli_fleet-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.egg-info/
+build/
+dist/

cli_fleet-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Sorrell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cli_fleet-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: cli-fleet
+Version: 0.1.0
+Summary: Launch multiple enforced Claude Code agent teams in parallel terminal windows, hardware-aware, coordinating via a shared filesystem mailbox.
+Project-URL: Homepage, https://github.com/Alexander-Sorrell-IT/CLI-Enforcement
+Author-email: Alexander Sorrell <codehunterextreme@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Alexander Sorrell
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: agent-teams,claude,enforcement,fleet,multi-agent,orchestration
+Requires-Python: >=3.8
+Requires-Dist: cli-enforcement>=0.1.0
+Description-Content-Type: text/markdown
+
+# CLI Fleet
+
+Launch **multiple enforced Claude Code agent teams in parallel** — each team a
+separate `claude` session in its own window, coordinating via a shared
+filesystem mailbox. A thin, hardware-aware wrapper that completes the stack:
+
+```
+cli-wikia  →  cli-enforcement  →  cli-fleet
+(knowledge)    (the brakes)        (the power)
+```
+
+`cli-fleet` bundles fleetcode's proven shell orchestration verbatim and adds:
+- **Hardware gating** — refuses to launch more parallel agents than the box can take.
+- **Automatic enforcement** — deploys the cli-enforcement engine into each team
+  (hooks merged with fleetcode's mailbox hook), so every spawned team is governed.
+
+## Install
+
+```bash
+pip install cli-fleet        # pulls in cli-enforcement + cli-wikia
+```
+
+## Usage
+
+```bash
+cli-fleet launch fleet.json            # hardware-gated, auto-enforced launch
+cli-fleet launch fleet.json --background  # use `claude -p` instead of windows
+cli-fleet status                       # fleet status
+cli-fleet send team-a team-b "finding: ..."   # cross-team mailbox message
+cli-fleet cleanup                      # tear down
+```
+
+## License
+MIT — see [LICENSE](LICENSE).

cli_fleet-0.1.0/README.md

@@ -0,0 +1,34 @@
+# CLI Fleet
+
+Launch **multiple enforced Claude Code agent teams in parallel** — each team a
+separate `claude` session in its own window, coordinating via a shared
+filesystem mailbox. A thin, hardware-aware wrapper that completes the stack:
+
+```
+cli-wikia  →  cli-enforcement  →  cli-fleet
+(knowledge)    (the brakes)        (the power)
+```
+
+`cli-fleet` bundles fleetcode's proven shell orchestration verbatim and adds:
+- **Hardware gating** — refuses to launch more parallel agents than the box can take.
+- **Automatic enforcement** — deploys the cli-enforcement engine into each team
+  (hooks merged with fleetcode's mailbox hook), so every spawned team is governed.
+
+## Install
+
+```bash
+pip install cli-fleet        # pulls in cli-enforcement + cli-wikia
+```
+
+## Usage
+
+```bash
+cli-fleet launch fleet.json            # hardware-gated, auto-enforced launch
+cli-fleet launch fleet.json --background  # use `claude -p` instead of windows
+cli-fleet status                       # fleet status
+cli-fleet send team-a team-b "finding: ..."   # cross-team mailbox message
+cli-fleet cleanup                      # tear down
+```
+
+## License
+MIT — see [LICENSE](LICENSE).

cli_fleet-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cli-fleet"
+version = "0.1.0"
+description = "Launch multiple enforced Claude Code agent teams in parallel terminal windows, hardware-aware, coordinating via a shared filesystem mailbox."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { file = "LICENSE" }
+authors = [{ name = "Alexander Sorrell", email = "codehunterextreme@gmail.com" }]
+keywords = ["claude", "agent-teams", "fleet", "orchestration", "enforcement", "multi-agent"]
+dependencies = ["cli-enforcement>=0.1.0"]
+
+[project.urls]
+Homepage = "https://github.com/Alexander-Sorrell-IT/CLI-Enforcement"
+
+[project.scripts]
+cli-fleet = "cli_fleet.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cli_fleet"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/cli_fleet/scripts" = "cli_fleet/scripts"

cli_fleet-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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.