blitzwing 0.1.0

package/README.md

@@ -0,0 +1,29 @@
+# blitzwing
+
+Interactive setup wizard to contribute layers to a Blitzwing Petals mother swarm.
+
+## Install
+
+```bash
+npm i -g blitzwing
+```
+
+## Use
+
+```bash
+blitzwing
+```
+
+The wizard talks to the **Discovery Service** (no mother URL to type), asks which model and how many layers to host, installs Petals if needed, and joins the swarm.
+
+```bash
+blitzwing status
+blitzwing leave
+```
+
+Override discovery URL (dev/staging only):
+
+```bash
+export BLITZWING_DISCOVERY_URL=http://127.0.0.1:9000
+blitzwing
+```

package/bin/blitzwing.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { run } from "../src/index.js";
+
+run(process.argv.slice(2)).catch((err) => {
+  console.error(err?.stack || err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "blitzwing",
+  "version": "0.1.0",
+  "description": "Interactive setup wizard to join a Blitzwing Petals mother swarm as a compute contributor",
+  "bin": {
+    "blitzwing": "bin/blitzwing.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "blitzwing",
+    "petals",
+    "llm",
+    "distributed-inference"
+  ],
+  "license": "MIT",
+  "config": {
+    "discoveryUrl": "http://127.0.0.1:9000"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "picocolors": "^1.1.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,68 @@
+export async function httpJson(url, options = {}) {
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...(options.headers || {}),
+    },
+  });
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+    body = { raw: text };
+  }
+  if (!res.ok) {
+    const err = new Error(
+      typeof body === "object"
+        ? body.detail?.message || body.detail || body.message || text || res.statusText
+        : text || res.statusText
+    );
+    err.status = res.status;
+    err.body = body;
+    throw err;
+  }
+  return body;
+}
+
+export async function listMothers(discoveryUrl) {
+  return httpJson(`${discoveryUrl.replace(/\/$/, "")}/v1/mothers`);
+}
+
+export async function motherHealth(motherUrl) {
+  return httpJson(`${motherUrl.replace(/\/$/, "")}/health`);
+}
+
+export async function motherHosts(motherUrl) {
+  return httpJson(`${motherUrl.replace(/\/$/, "")}/v1/hosts`);
+}
+
+export async function joinHost(motherUrl, payload) {
+  return httpJson(`${motherUrl.replace(/\/$/, "")}/v1/hosts/join`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export async function readyHost(motherUrl, payload) {
+  return httpJson(`${motherUrl.replace(/\/$/, "")}/v1/hosts/ready`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export async function heartbeatHost(motherUrl, payload) {
+  return httpJson(`${motherUrl.replace(/\/$/, "")}/v1/hosts/heartbeat`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export async function leaveHost(motherUrl, payload) {
+  return httpJson(`${motherUrl.replace(/\/$/, "")}/v1/hosts/leave`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}

package/src/config.js

@@ -0,0 +1,9 @@
+/** Default Discovery Service URL — override with BLITZWING_DISCOVERY_URL or --discovery-url */
+export const DEFAULT_DISCOVERY_URL =
+  process.env.BLITZWING_DISCOVERY_URL || "http://127.0.0.1:9000";
+
+export const HOME_DIR = process.env.BLITZWING_HOME || `${process.env.HOME || process.env.USERPROFILE}/.blitzwing`;
+export const STATE_PATH = `${HOME_DIR}/contributor.json`;
+export const VENV_PATH = `${HOME_DIR}/venv`;
+export const SHARD_PORT = Number(process.env.BLITZWING_SHARD_PORT || 8001);
+export const PETALS_PORT = Number(process.env.BLITZWING_PETALS_PORT || 31337);

package/src/index.js

@@ -0,0 +1 @@
+export { run } from "./wizard.js";

package/src/install.js

@@ -0,0 +1,218 @@
+import { spawn, execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { HOME_DIR, VENV_PATH, SHARD_PORT, PETALS_PORT } from "./config.js";
+import { which } from "./net.js";
+
+function venvPython() {
+  if (process.platform === "win32") {
+    return path.join(VENV_PATH, "Scripts", "python.exe");
+  }
+  return path.join(VENV_PATH, "bin", "python");
+}
+
+function venvPip() {
+  if (process.platform === "win32") {
+    return path.join(VENV_PATH, "Scripts", "pip.exe");
+  }
+  return path.join(VENV_PATH, "bin", "pip");
+}
+
+export function ensurePython() {
+  const py = which("python3") || which("python");
+  if (!py) {
+    throw new Error("Python 3 is required. Install Python 3.10+ and re-run blitzwing.");
+  }
+  const ver = execFileSync(py, ["--version"], { encoding: "utf8" });
+  return { py, ver: ver.trim() };
+}
+
+export function ensureVenvAndPetals({ onLog }) {
+  const { py } = ensurePython();
+  fs.mkdirSync(HOME_DIR, { recursive: true });
+
+  if (!fs.existsSync(venvPython())) {
+    onLog?.(`Creating venv at ${VENV_PATH}`);
+    execFileSync(py, ["-m", "venv", VENV_PATH], { stdio: "inherit" });
+  }
+
+  const pip = venvPip();
+  const python = venvPython();
+
+  onLog?.("Installing CPU PyTorch + Petals (may take a few minutes on first run)...");
+  execFileSync(pip, ["install", "-U", "pip"], { stdio: "inherit" });
+  execFileSync(
+    pip,
+    ["install", "torch", "--index-url", "https://download.pytorch.org/whl/cpu"],
+    { stdio: "inherit" }
+  );
+  // Prefer git install for contributors without the monorepo
+  execFileSync(
+    pip,
+    ["install", "git+https://github.com/bigscience-workshop/petals.git"],
+    { stdio: "inherit" }
+  );
+  execFileSync(pip, ["install", "fastapi", "uvicorn[standard]", "pydantic", "httpx"], {
+    stdio: "inherit",
+  });
+
+  return { python, pip };
+}
+
+/**
+ * Write a tiny local shard-manager runner script so contributors don't need the monorepo.
+ * Embeds a minimal supervisor compatible with mother /reload API.
+ */
+export function writeLocalShardManager() {
+  const dir = path.join(HOME_DIR, "runtime");
+  fs.mkdirSync(dir, { recursive: true });
+  const appPath = path.join(dir, "shard_manager_app.py");
+  const code = `
+import os, signal, subprocess, threading, time
+from typing import Optional, List
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+
+class ReloadRequest(BaseModel):
+    block_indices: str = Field(..., pattern=r"^\\d+:\\d+$")
+
+class StatusResponse(BaseModel):
+    running: bool
+    pid: Optional[int] = None
+    block_indices: Optional[str] = None
+    model: str
+    public_ip: Optional[str] = None
+    port: int
+    last_exit_code: Optional[int] = None
+
+class Mgr:
+    def __init__(self):
+        self.model = os.environ["MODEL_NAME"]
+        self.public_ip = os.environ.get("PUBLIC_IP")
+        self.port = int(os.environ.get("PETALS_PORT", "31337"))
+        self.identity_path = os.environ.get("IDENTITY_PATH", os.path.expanduser("~/.blitzwing/petals-identity"))
+        self.block_indices = os.environ["BLOCK_INDICES"]
+        peers = [p.strip() for p in os.environ.get("INITIAL_PEERS", "").split(",") if p.strip()]
+        self.initial_peers = peers
+        self.python = os.environ.get("PETALS_PYTHON", "python")
+        self._proc = None
+        self._lock = threading.Lock()
+        self.last_exit_code = None
+
+    def cmd(self, bi):
+        c = [self.python, "-m", "petals.cli.run_server", self.model,
+             "--device", "cpu", "--quant_type", "none",
+             "--block_indices", bi, "--port", str(self.port),
+             "--identity_path", self.identity_path, "--num_handlers", "1"]
+        if self.public_ip:
+            c += ["--public_ip", self.public_ip]
+        if self.initial_peers:
+            c += ["--initial_peers", *self.initial_peers]
+        return c
+
+    def start(self, bi=None):
+        with self._lock:
+            if bi: self.block_indices = bi
+            if self._proc and self._proc.poll() is None:
+                return
+            self._proc = subprocess.Popen(self.cmd(self.block_indices))
+            self.last_exit_code = None
+
+    def stop(self):
+        with self._lock:
+            if not self._proc or self._proc.poll() is not None:
+                self._proc = None
+                return
+            p = self._proc
+            p.send_signal(signal.SIGTERM)
+            try: p.wait(timeout=30)
+            except Exception:
+                p.kill(); p.wait(timeout=10)
+            self.last_exit_code = p.returncode
+            self._proc = None
+
+    def reload(self, bi):
+        self.stop(); time.sleep(1); self.start(bi)
+
+    def status(self):
+        running = self._proc is not None and self._proc.poll() is None
+        return StatusResponse(
+            running=running,
+            pid=(self._proc.pid if running else None),
+            block_indices=self.block_indices,
+            model=self.model,
+            public_ip=self.public_ip,
+            port=self.port,
+            last_exit_code=self.last_exit_code,
+        )
+
+mgr = Mgr()
+app = FastAPI()
+
+@app.on_event("startup")
+def _up():
+    mgr.start()
+
+@app.on_event("shutdown")
+def _down():
+    mgr.stop()
+
+@app.get("/status")
+def status():
+    return mgr.status()
+
+@app.post("/reload")
+def reload(body: ReloadRequest):
+    a,b = map(int, body.block_indices.split(":"))
+    if b <= a: raise HTTPException(400, "bad range")
+    mgr.reload(body.block_indices)
+    time.sleep(0.5)
+    return mgr.status()
+
+@app.post("/stop")
+def stop():
+    mgr.stop(); return mgr.status()
+`;
+  fs.writeFileSync(appPath, code);
+  return appPath;
+}
+
+export function startShardManagerProcess({
+  python,
+  env,
+  logPath,
+}) {
+  const appPath = writeLocalShardManager();
+  const out = fs.openSync(logPath, "a");
+  const child = spawn(
+    python,
+    ["-m", "uvicorn", `shard_manager_app:app`, "--host", "0.0.0.0", "--port", String(SHARD_PORT)],
+    {
+      cwd: path.dirname(appPath),
+      env: { ...process.env, ...env, PETALS_PYTHON: python },
+      detached: true,
+      stdio: ["ignore", out, out],
+    }
+  );
+  child.unref();
+  return { pid: child.pid, logPath, appPath };
+}
+
+export async function waitForShardRunning({ timeoutMs = 300000 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${SHARD_PORT}/status`);
+      if (res.ok) {
+        const body = await res.json();
+        if (body.running) return body;
+      }
+    } catch {
+      /* retry */
+    }
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  throw new Error("Timed out waiting for local Petals shard manager to become ready");
+}
+
+export { SHARD_PORT, PETALS_PORT, venvPython };

package/src/net.js

@@ -0,0 +1,36 @@
+import { execFileSync } from "node:child_process";
+
+export async function detectPublicIp() {
+  const tryUrls = [
+    "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/access-configs/0/external-ip",
+    "http://169.254.169.254/latest/meta-data/public-ipv4",
+    "https://api.ipify.org",
+  ];
+
+  for (const url of tryUrls) {
+    try {
+      const headers = url.includes("metadata.google.internal")
+        ? { "Metadata-Flavor": "Google" }
+        : {};
+      const ctrl = AbortSignal.timeout(3000);
+      const res = await fetch(url, { headers, signal: ctrl });
+      if (!res.ok) continue;
+      const text = (await res.text()).trim();
+      if (/^\d+\.\d+\.\d+\.\d+$/.test(text)) return text;
+    } catch {
+      /* try next */
+    }
+  }
+  return "";
+}
+
+export function which(cmd) {
+  try {
+    const out = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
+      encoding: "utf8",
+    });
+    return out.split(/\r?\n/)[0].trim();
+  } catch {
+    return null;
+  }
+}

package/src/state.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+import { STATE_PATH, HOME_DIR } from "./config.js";
+
+export function ensureHome() {
+  fs.mkdirSync(HOME_DIR, { recursive: true });
+}
+
+export function loadState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveState(state) {
+  ensureHome();
+  fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+}
+
+export function clearState() {
+  try {
+    fs.unlinkSync(STATE_PATH);
+  } catch {
+    /* ignore */
+  }
+}
+
+export function stateDir() {
+  return path.dirname(STATE_PATH);
+}

package/src/wizard.js

@@ -0,0 +1,318 @@
+import * as p from "@clack/prompts";
+import color from "picocolors";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { DEFAULT_DISCOVERY_URL, HOME_DIR, SHARD_PORT, PETALS_PORT } from "./config.js";
+import { listMothers, motherHosts, joinHost, readyHost, leaveHost } from "./api.js";
+import { detectPublicIp } from "./net.js";
+import {
+  ensureVenvAndPetals,
+  startShardManagerProcess,
+  waitForShardRunning,
+  venvPython,
+} from "./install.js";
+import { saveState, loadState, clearState, ensureHome } from "./state.js";
+
+function parseArgs(argv) {
+  const out = { cmd: null, discoveryUrl: process.env.BLITZWING_DISCOVERY_URL || DEFAULT_DISCOVERY_URL };
+  const rest = [...argv];
+  if (rest[0] === "status" || rest[0] === "leave" || rest[0] === "help") {
+    out.cmd = rest.shift();
+  }
+  while (rest.length) {
+    const a = rest.shift();
+    if (a === "--discovery-url") out.discoveryUrl = rest.shift();
+    else if (a === "--help" || a === "-h") out.cmd = "help";
+  }
+  return out;
+}
+
+export async function run(argv) {
+  const args = parseArgs(argv);
+  if (args.cmd === "help") {
+    printHelp();
+    return;
+  }
+  if (args.cmd === "status") {
+    await showStatus();
+    return;
+  }
+  if (args.cmd === "leave") {
+    await doLeave();
+    return;
+  }
+  await wizard(args);
+}
+
+function printHelp() {
+  console.log(`
+${color.bold("blitzwing")} — join a Blitzwing mother swarm as a compute node
+
+  blitzwing              Interactive setup wizard (recommended)
+  blitzwing status       Show local contributor status
+  blitzwing leave        Leave the swarm and reclaim your layers
+
+Env:
+  BLITZWING_DISCOVERY_URL   Override discovery service (default ${DEFAULT_DISCOVERY_URL})
+`);
+}
+
+async function wizard(args) {
+  p.intro(color.bgCyan(color.black(" blitzwing ")));
+  ensureHome();
+
+  const spin = p.spinner();
+  spin.start("Loading network from Discovery Service…");
+  let mothers;
+  try {
+    mothers = await listMothers(args.discoveryUrl);
+  } catch (err) {
+    spin.stop("Discovery failed");
+    p.cancel(`Could not reach discovery at ${args.discoveryUrl}: ${err.message}`);
+    process.exit(1);
+  }
+  spin.stop(`Found ${mothers.length} model(s)`);
+
+  if (!mothers.length) {
+    p.cancel("No mothers registered yet. Ask the operator to bootstrap a mother node.");
+    process.exit(1);
+  }
+
+  let selected = mothers[0];
+  if (mothers.length > 1) {
+    const choice = await p.select({
+      message: "Which model do you want to help serve?",
+      options: mothers.map((m) => ({
+        value: m.model,
+        label: m.model,
+        hint: m.mother_url,
+      })),
+    });
+    if (p.isCancel(choice)) {
+      p.cancel("Setup cancelled");
+      process.exit(0);
+    }
+    selected = mothers.find((m) => m.model === choice);
+  } else {
+    p.log.info(`Model: ${color.cyan(selected.model)}`);
+  }
+
+  let maxLayers = selected.total_layers - 1;
+  try {
+    const hosts = await motherHosts(selected.mother_url);
+    if (typeof hosts.max_layers_available === "number") {
+      maxLayers = hosts.max_layers_available;
+    }
+  } catch (err) {
+    p.log.warn(`Could not read live host map (${err.message}); using total_layers-1=${maxLayers}`);
+  }
+
+  if (maxLayers < 1) {
+    p.cancel("No spare layers available on this swarm right now. Try again later.");
+    process.exit(1);
+  }
+
+  const layers = await p.text({
+    message: `How many layers can this machine host? (1–${maxLayers})`,
+    initialValue: String(Math.min(8, maxLayers)),
+    validate(v) {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > maxLayers) {
+        return `Enter an integer between 1 and ${maxLayers}`;
+      }
+    },
+  });
+  if (p.isCancel(layers)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+  const layersN = Number(layers);
+
+  const detected = await detectPublicIp();
+  const publicIp = await p.text({
+    message: "Public IP for this machine (other peers must reach you)",
+    initialValue: detected || "",
+    validate(v) {
+      if (!v || !v.trim()) return "Public IP is required";
+    },
+  });
+  if (p.isCancel(publicIp)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+
+  const confirm = await p.confirm({
+    message: `Join ${selected.model} hosting ${layersN} layers from ${String(publicIp).trim()}?`,
+    initialValue: true,
+  });
+  if (p.isCancel(confirm) || !confirm) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+
+  spin.start("Preparing Python environment + Petals");
+  try {
+    ensureVenvAndPetals({
+      onLog: (msg) => {
+        spin.message(msg);
+      },
+    });
+  } catch (err) {
+    spin.stop("Install failed");
+    p.cancel(err.message);
+    process.exit(1);
+  }
+  const python = venvPython();
+  spin.stop("Environment ready");
+
+  const shardManagerUrl = `http://${String(publicIp).trim()}:${SHARD_PORT}`;
+
+  spin.start("Requesting layer assignment from mother…");
+  let assignment;
+  try {
+    assignment = await joinHost(selected.mother_url, {
+      model: selected.model,
+      layers: layersN,
+      public_ip: String(publicIp).trim(),
+      shard_manager_url: shardManagerUrl,
+    });
+  } catch (err) {
+    spin.stop("Join rejected");
+    const max = err.body?.detail?.max_layers;
+    p.cancel(`${err.message}${max != null ? ` (max available: ${max})` : ""}`);
+    process.exit(1);
+  }
+  spin.stop(`Assigned blocks ${assignment.block_indices} (${assignment.layers_hosted} layers)`);
+
+  const logPath = path.join(HOME_DIR, "shard_manager.log");
+  spin.start("Starting local Petals server…");
+  const { pid } = startShardManagerProcess({
+    python,
+    logPath,
+    env: {
+      MODEL_NAME: selected.model,
+      PUBLIC_IP: String(publicIp).trim(),
+      BLOCK_INDICES: assignment.block_indices,
+      INITIAL_PEERS: (assignment.initial_peers || []).join(","),
+      PETALS_PORT: String(PETALS_PORT),
+      IDENTITY_PATH: path.join(HOME_DIR, "petals-identity"),
+      SHARD_AUTO_START: "1",
+    },
+  });
+
+  try {
+    await waitForShardRunning({ timeoutMs: 600000 });
+  } catch (err) {
+    spin.stop("Petals did not become ready");
+    p.cancel(`${err.message}. See ${logPath}`);
+    process.exit(1);
+  }
+  spin.stop("Petals is serving your layers");
+
+  spin.start("Finalizing handoff with mother…");
+  try {
+    await readyHost(selected.mother_url, { host_id: assignment.host_id });
+  } catch (err) {
+    spin.stop("Handoff failed");
+    p.cancel(err.message);
+    process.exit(1);
+  }
+  spin.stop("Handoff complete");
+
+  const state = {
+    host_id: assignment.host_id,
+    model: selected.model,
+    mother_url: selected.mother_url,
+    block_indices: assignment.block_indices,
+    layers_hosted: assignment.layers_hosted,
+    public_ip: String(publicIp).trim(),
+    shard_manager_url: shardManagerUrl,
+    shard_pid: pid,
+    discovery_url: args.discoveryUrl,
+    joined_at: new Date().toISOString(),
+  };
+  saveState(state);
+  startHeartbeatDaemon(state);
+
+  p.outro(
+    `${color.green("You are online.")} Hosting ${color.cyan(String(state.layers_hosted))} layers of ${color.cyan(state.model)} at ${state.block_indices}\n` +
+      `Run ${color.bold("blitzwing status")} anytime, or ${color.bold("blitzwing leave")} to exit.`
+  );
+}
+
+function startHeartbeatDaemon(state) {
+  const hbPath = path.join(HOME_DIR, "heartbeat.mjs");
+  fs.writeFileSync(
+    hbPath,
+    `const mother = ${JSON.stringify(state.mother_url)};
+const hostId = ${JSON.stringify(state.host_id)};
+async function beat() {
+  try {
+    await fetch(mother.replace(/\\/$/, "") + "/v1/hosts/heartbeat", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ host_id: hostId }),
+    });
+  } catch {}
+}
+setInterval(beat, 60000);
+beat();
+`
+  );
+  const child = spawn(process.execPath, [hbPath], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}
+
+async function showStatus() {
+  const state = loadState();
+  if (!state) {
+    console.log("Not joined. Run blitzwing to set up this machine as a node.");
+    return;
+  }
+  console.log(color.bold("Contributor status"));
+  console.log(`  model:          ${state.model}`);
+  console.log(`  host_id:        ${state.host_id}`);
+  console.log(`  layers_hosted:  ${state.layers_hosted}`);
+  console.log(`  block_indices:  ${state.block_indices}`);
+  console.log(`  mother:         ${state.mother_url}`);
+  console.log(`  public_ip:      ${state.public_ip}`);
+  try {
+    const res = await fetch(`http://127.0.0.1:${SHARD_PORT}/status`);
+    if (res.ok) {
+      const st = await res.json();
+      console.log(`  petals_running: ${st.running}`);
+      console.log(`  petals_pid:     ${st.pid}`);
+    } else {
+      console.log("  petals_running: unknown");
+    }
+  } catch {
+    console.log(`  petals_running: no (shard manager not reachable on :${SHARD_PORT})`);
+  }
+}
+
+async function doLeave() {
+  const state = loadState();
+  if (!state) {
+    p.cancel("Not joined.");
+    process.exit(1);
+  }
+  const spin = p.spinner();
+  spin.start("Leaving swarm…");
+  try {
+    await leaveHost(state.mother_url, { host_id: state.host_id });
+  } catch (err) {
+    p.log.warn(`Mother leave call failed: ${err.message}`);
+  }
+  try {
+    await fetch(`http://127.0.0.1:${SHARD_PORT}/stop`, { method: "POST" });
+  } catch {
+    /* ignore */
+  }
+  clearState();
+  spin.stop("Left swarm");
+  p.outro("Your layers were reclaimed by the mother (when reachable).");
+}