Fleet lab: swarm coordination sandbox + teaching tool

.github/workflows/no-private-leak.yml

@@ -0,0 +1,27 @@
+name: no-private-leak
+
+# Hard gate: the public repo must never track private strategy material.
+# This is the backstop for the one footgun that bit us before — a `git add -f`
+# slipping a private/ file past .gitignore. Runs on every push and PR.
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  guard:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Fail if any private path is tracked
+        run: |
+          set -euo pipefail
+          # Paths that must never be committed to the public repo.
+          forbidden='^(private/|site/|docs/ANTIOCH_PARITY\.md$|docs/DEMO_SPEC\.md$|docs/RL_HARNESS_SPEC\.md$)'
+          hits="$(git ls-files | grep -E "$forbidden" || true)"
+          if [ -n "$hits" ]; then
+            echo "::error::Private material is tracked in the public repo:"
+            echo "$hits"
+            exit 1
+          fi
+          echo "OK — no private paths tracked."

.gitignore

@@ -28,6 +28,17 @@ private/
 *.pem
 *.key
 
+# Strategy / planning docs — live in the private website repo only, never public
+/docs/ANTIOCH_PARITY.md
+/docs/DEMO_SPEC.md
+/docs/RL_HARNESS_SPEC.md
+
+# Local agent / dev tooling — belongs in neither published repo
+.agents/
+.claude/
+.goalkeeper/
+skills-lock.json
+
 # Logs
 *.log
 *.tmp

CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## Unreleased
+
+### Added
+- **FLEET sandbox** (`/fleet`) — a multi-quadruped teaching arena reachable from the right of the robot picker. Configure the radio (range, link reliability), the airtime each robot gets, and its onboard memory + inbox depth, then watch a fleet split a field under four coordination strategies (lone wolves, gossip, claim-and-yield, one commander). Live links, in-flight messages, dropped packets, coverage and wasted re-walks all rendered.
+- Fleet **hover-to-inspect**: mouse over any robot to highlight what *it* knows — tiles it sensed firsthand (filled) vs. only heard from peers (outlined) — with a live knowledge/inbox/data card.
+- Fleet **base station + data points**: discover data and relay it home with greedy geographic routing (multi-hop / data-mule), plus selectable **environments** (open / obstacles / building with line-of-sight-blocking walls).
+- Fleet **CONCEPTS panel** (expandable): in-UI explanations of delivered vs. dropped, overlapping searches, optimisation, "is this libp2p?", swarm intelligence/stigmergy, and the base-station sink — plus hover tooltips on every metric.
+- Fleet **bring-your-own algorithm**: a "✨ Your algorithm" strategy with a live JS editor, and a **Generate** button that asks the local runtime's LLM (`POST /api/fleet/strategy`) to draft a coordination policy from a plain-language goal — runnable on the spot against the same radio limits.
+- **`roborun/swarm/`** — the comms model, four strategies, base-station relay and data points as runnable Python (`python -m roborun.swarm`), the headless twin of the sandbox; ships with the package.
+- ROS card **network scan**: an "Allow network scan to load robots" button that trips the browser's local-network permission and lists every rosbridge robot found as its own one-click view.
+
+### Changed
+- ROS-connected robots land in the **exact same multi-panel deck** as the rapier.js sim — the live camera (EYES) now docks into the deck layout where the sim shows its POV, instead of floating.
+- The FLEET picker card is now a single **Open Fleet Lab** button; every knob lives inside the sandbox.
+- Replaced the last native `confirm()` (deploy-to-robot) with the in-app styled modal, usable from the deck as well as the cockpit.
+
+### Deploy
+- `vercel.json` with `cleanUrls` so `/fleet` resolves on the static Vercel build, matching the local server's route.
+
 ## v0.9.2 — 2026-06-09
 
 ### Fixed

README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">RoboRun: Write a Robot Behavior Once, Run It on Any ROS 1/2 Robot</h1>
 
-<p align="center"><b>The base layer for coding robots: <code>see / move / ask</code> primitives, hot-reload Python behaviors,<br>the same file from webcam + MuJoCo to real hardware. MCP-native for AI agents, every run flight-recorded.</b></p>
+<p align="center"><b>The base layer for coding robots: <code>see / move / ask</code> primitives, hot-reload Python behaviors,<br>the same file from webcam + MuJoCo to real hardware. MCP-native for AI agents — and every run is flight-recorded, sealed, and searchable, so you can find anything your robots ever saw, across all of time.</b></p>
 
 <p align="center">
   <a href="https://pypi.org/project/ros-agent/"><img src="https://img.shields.io/pypi/v/ros-agent?style=flat-square&color=00d47e&label=pip%20install%20ros-agent" alt="PyPI"></a>
@@ -19,10 +19,19 @@
 
 ```bash
 pip install ros-agent     # the package keeps its PyPI name; the command is roborun
-roborun
+roborun                   # serves the UI at http://localhost:8765 (prints the URL)
 ```
 
-The browser opens live, and a `behaviors/` folder appears with the robot's brain. Open **`/arena`** — a robot dog in a browser sim, body and eyes in the same world (what it does changes what it sees). Nothing else to install; the base package is three small dependencies, no torch. The robot's brain:
+Open the printed URL and a `behaviors/` folder appears with the robot's brain. Open **`/arena`** — a robot dog in a browser sim, body and eyes in the same world (what it does changes what it sees). Nothing else to install; the base package is three small dependencies, no torch.
+
+Prefer the terminal? It runs fully without the web UI:
+
+```bash
+roborun run     # headless: drives behaviors, streams the see/move/ask loop to stdout
+roborun tui     # full-screen terminal dashboard (pip install 'ros-agent[tui]')
+```
+
+The robot's brain:
 
 ```python
 # behaviors/follow_person.py (already running)
@@ -55,6 +64,7 @@ Want real eyes instead of the sim? `pip install 'ros-agent[vision]'` (YOLO + CLI
 | `robot.delegate("fix my search pattern")` | async LLM **with tools** — it can call any MCP tool, including rewriting the running policy (hot reload applies it live) |
 | `robot.tool("navigate", x=2, y=3)` | call any MCP tool from inside the policy |
 | `robot.lidar()` | 360° ranges in meters, `[0]` = straight ahead |
+| `robot.go_to_place("the charging dock")` | semantic navigation — recall where it last saw something, then drive there |
 | `robot.remember(k, v)` / `robot.recall(k)` | memory that survives restarts |
 | `robot.state` | dict that survives across loop ticks |
 
@@ -101,6 +111,33 @@ What this proves: the recorded run — images, detections, and decisions include
 
 The UI at `http://localhost:8765` is the flight deck itself: live camera with YOLO boxes, the black box streaming, the live anchor badge, a command bar, and director keys. `M` record/seal · `V` verify · `T` tamper · `R` runs/replay · `C` sources.
 
+## Track and search everything over time
+
+Every run — sim, real robot, or webcam — flows through one loop: **YOLO + CLIP → sealed MCAP → a live index you can search across all of history.** So "where did I last see the forklift", "who was in the lobby yesterday", "every red mug across the fleet" are one query — semantic (CLIP), label (YOLO), place, or time window — over every run and robot.
+
+The cockpit's **▤ VIEWS** menu opens the dashboards (also `roborun demo` to populate them instantly):
+
+- **/search** — find anything/anyone over time; export the hits as a labeled dataset (sealed provenance).
+- **/scenarios** — give a behavior a task, run it, and see if it passed; group runs into suites with a pass-rate, and re-run after every change.
+- **/run** — per-run trajectory · velocity · clearance · LiDAR, with **synced playback** (scrub a moment → the frame the robot saw) and **⚑ Flag** to bookmark incidents to revisit.
+- **/analytics** — detections over time, suite pass-rates, per-robot fleet activity.
+- **/timeline** — the live event stream + recent sightings.
+
+From the local runner, no browser needed:
+
+```bash
+roborun demo                     # load sample data so the dashboards aren't empty
+roborun ask "patrol the lobby"   # tell the robot what to do in plain English
+roborun search "person"          # across every recorded run, all-time
+roborun scenarios run mjx_reach  # score a scenario (vectorized MuJoCo, sealed)
+roborun dataset "forklift" ./ds  # curate a labeled training set from a search
+roborun status                   # is it running, what's connected, how much recorded
+```
+
+(`roborun help` lists every verb.)
+
+The robot handle gets it too: `robot.go_to_place("the charging dock")` navigates to where it last saw something (semantic memory), and the same `recall_place` is an MCP tool any agent can call.
+
 ## Connect a real robot
 
 ```bash
@@ -109,7 +146,7 @@ roborun connect 192.168.1.42 --move   # proves it: clamped 0.5s nudge, then stop
 roborun connect --scan                # DDS discovery — nothing to install on the robot
 ```
 
-If rosbridge isn't running on the robot yet, the command prints the exact two lines to run there — that's the whole setup. **No ROS install on your machine.** Once connected, plain `roborun` drives that robot and the same `behaviors/*.py` files now move real hardware: Unitree Go2/G1, TurtleBot, arms, drones, NVIDIA Isaac Sim, Gazebo. `robot.move()` goes to the sim if it's running, otherwise to the connected robot, always through the same safety clamps.
+If rosbridge isn't running on the robot yet, the command prints the exact two lines to run there — that's the whole setup. **No ROS install on your machine, and it works with both ROS 1 and ROS 2** — rosbridge speaks both, and RoboRun detects which (the DDS path is ROS 2-only). Once connected, plain `roborun` drives that robot and the same `behaviors/*.py` files now move real hardware: Unitree Go2/G1, TurtleBot, arms, drones, NVIDIA Isaac Sim, Gazebo. `robot.move()` goes to the sim if it's running, otherwise to the connected robot, always through the same safety clamps.
 
 Optional extras: `pip install ros-agent[vision]` (YOLO + CLIP), `[sim]` (MuJoCo), `[ros]` (direct DDS), `[crypto]` (Ed25519 signing), `[anchor]` (RFC 3161 timestamping), `[fleet]` (R2 + DuckDB cross-robot), `[all]`.
 

app/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+*.tsbuildinfo

app/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RoboRun Studio</title>
+    <!-- shared design tokens, served by the python server (proxied in dev) -->
+    <link rel="stylesheet" href="/ui.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

app/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "roborun-studio",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^7.1.0",
+    "uplot": "^1.6.31",
+    "zustand": "^5.0.2"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.5"
+  }
+}

app/src/App.tsx

@@ -0,0 +1,44 @@
+import { useEffect } from "react";
+import { BrowserRouter, Routes, Route } from "react-router-dom";
+import { AppShell } from "./shell/AppShell";
+import { useStudio } from "./store";
+import { Home } from "./routes/Home";
+import { Live } from "./routes/Live";
+import { Runs } from "./routes/Runs";
+import { Sims } from "./routes/Sims";
+import { Search } from "./routes/Search";
+import { Scenarios } from "./routes/Scenarios";
+import { Analytics } from "./routes/Analytics";
+import { Agent } from "./routes/Agent";
+import { Hosted } from "./routes/Hosted";
+
+// One throttled loop drives the playhead. 10Hz is plenty — the camera polls at
+// 5Hz and events are coarse — and it avoids 60fps whole-app re-renders.
+function usePlayhead() {
+  const tick = useStudio((s) => s.tick);
+  useEffect(() => {
+    const id = setInterval(tick, 100);
+    return () => clearInterval(id);
+  }, [tick]);
+}
+
+export function App() {
+  usePlayhead();
+  return (
+    <BrowserRouter basename="/studio">
+      <Routes>
+        <Route element={<AppShell />}>
+          <Route index element={<Home />} />
+          <Route path="live" element={<Live />} />
+          <Route path="sims" element={<Sims />} />
+          <Route path="runs" element={<Runs />} />
+          <Route path="search" element={<Search />} />
+          <Route path="agent" element={<Agent />} />
+          <Route path="swarm" element={<Hosted title="Swarm Lab" src="/fleet" />} />
+          <Route path="scenarios" element={<Scenarios />} />
+          <Route path="analytics" element={<Analytics />} />
+        </Route>
+      </Routes>
+    </BrowserRouter>
+  );
+}

app/src/main.tsx

@@ -0,0 +1,18 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+// Dashboards use the system monospace stack (RoboRun DS) — no webfont.
+import "./theme.css";
+import { App } from "./App";
+import { resolveBase, installFetchBridge } from "./runtime";
+
+// Find the backend (same-origin local server, or a localhost roborun reached
+// from the hosted site), THEN install the /api+/mcp fetch shim and mount. The
+// probe is quick and fails fast when nothing's listening.
+resolveBase().finally(() => {
+  installFetchBridge();
+  createRoot(document.getElementById("root")!).render(
+    <StrictMode>
+      <App />
+    </StrictMode>
+  );
+});

app/src/panels/CameraPanel.tsx

@@ -0,0 +1,51 @@
+import { useState } from "react";
+import { useStudio } from "../store";
+import { Panel } from "./Panel";
+
+// Source-agnostic: live shows the latest frame (polled ~5Hz via the playhead),
+// replay shows the frame nearest the scrubbed t. Same component, same <img>.
+export function CameraPanel() {
+  const { source, t } = useStudio();
+  const [ok, setOk] = useState(true);
+  // quantize to 5Hz so live polling and replay scrubbing both stay sane
+  const qt = Math.floor(t * 5) / 5;
+  const url = source.frameURL(qt);
+  return (
+    <Panel title="Camera">
+      <div style={{ position: "relative", background: "#000", borderRadius: "var(--r-sm)", minHeight: 160 }}>
+        <img
+          src={url}
+          alt="camera feed"
+          style={{ opacity: ok ? 1 : 0 }}
+          onLoad={() => setOk(true)}
+          onError={() => setOk(false)}
+        />
+        {!ok && (
+          <div
+            style={{
+              position: "absolute",
+              inset: 0,
+              display: "grid",
+              placeItems: "center",
+              textAlign: "center",
+              gap: 6,
+              color: "var(--fg-dim)",
+              fontSize: 13,
+            }}
+          >
+            {source.kind === "live" ? (
+              <div>
+                <div style={{ fontFamily: "var(--mono)" }}>○ no camera</div>
+                <div style={{ marginTop: 6 }}>
+                  Start a sim in <a href="/studio/sims" style={{ color: "var(--accent)" }}>Sims</a> or connect a robot.
+                </div>
+              </div>
+            ) : (
+              <div style={{ fontFamily: "var(--mono)" }}>○ no camera frame at this point in the run</div>
+            )}
+          </div>
+        )}
+      </div>
+    </Panel>
+  );
+}

app/src/panels/DetectionsPanel.tsx

@@ -0,0 +1,29 @@
+import { useStudio } from "../store";
+import { Panel } from "./Panel";
+
+// What the robot sees at the current playhead. sceneAt(t) is source-agnostic.
+export function DetectionsPanel() {
+  const { source, t } = useStudio();
+  const { detections, pose } = source.sceneAt(t);
+  return (
+    <Panel title="Detections">
+      {pose && (
+        <div style={{ fontFamily: "var(--mono)", fontSize: 12, color: "var(--fg-dim)", marginBottom: 8 }}>
+          pose x={pose.x.toFixed(2)} y={pose.y.toFixed(2)} z={pose.z.toFixed(2)}
+        </div>
+      )}
+      {detections.length ? (
+        detections.map((d, i) => (
+          <div key={i} style={{ fontFamily: "var(--mono)", fontSize: 12, lineHeight: 1.7 }}>
+            <span style={{ color: "var(--accent)" }}>{d.label}</span>
+            {d.confidence != null && <span style={{ color: "var(--fg-dim)" }}> {(d.confidence * 100).toFixed(0)}%</span>}
+          </div>
+        ))
+      ) : (
+        <div style={{ color: "var(--fg-dim)", fontSize: 12 }}>
+          {source.kind === "live" ? "No detections yet — start a sim or connect a robot." : "Nothing detected at this point in the run."}
+        </div>
+      )}
+    </Panel>
+  );
+}