agents-city 0.3.0 → 0.5.1

package/README.md

@@ -104,7 +104,7 @@ This is `0.x` on purpose: the commands are usable today, and the file formats
 and APIs can still change between minor versions. Nothing here pretends to be
 frozen yet.
 
-You need Node.js 22+, Python 3 and tmux; the
+You need Node.js 22.13+, Python 3 and tmux; the
 [requirements table](#base-requirements) has the details, and `agents-city seat`
 offers to install tmux when it is missing. Nothing is installed system-wide
 beyond the npm global folder of your active Node installation.
@@ -160,7 +160,7 @@ agents-city --version
 
 | Requirement | Used for |
 |---|---|
-| Node.js 22 or later | npm package, WebSocket bus, and frontends |
+| Node.js 22.13 or later | npm package, WebSocket bus, local reception, and frontends |
 | npm | installation and packaging |
 | Python 3 | Hall, onboarding, cities, maps, and utilities |
 | bash | sessions and launchers |
@@ -486,6 +486,7 @@ agents-city setup
 agents-city seat
 agents-city cities
 agents-city road
+agents-city connect
 agents-city bus
 agents-city committee
 agents-city agents
@@ -550,12 +551,44 @@ spectator token rotates with the hub, accepts only an origin on this computer,
 and is read-only: the browser cannot direct the committee. `Ctrl-c` stops the
 Hall.
 
+**Demos** in the rail plays a whole committee without setting anything up: one
+story per work domain — a studio, a clinic, a law firm — with play, pause,
+replay and speed. What it plays are *recordings*: `demo/graba.py` runs each story
+over the real local bus, through the real committee state machine, and keeps the
+exact event stream a spectator saw; the Hall replays those events through the
+same renderer the live rail uses. It says so on screen, because a demo that
+pretends to be live is the one kind this product must not ship. To run one live
+in a terminal instead: `agents-city demo --domain software`.
+
+Regenerate the recordings after editing `demo/stories.py`:
+
+```bash
+demo/graba.py            # every story
+demo/graba.py medicina   # just one
+```
+
+The demo suite fails when a recording no longer matches the story it claims to
+be, so a stale one is a red build rather than a browser quietly playing last
+month's committee.
+
 Two buttons sit under the brand: **day/night**, and **ES/EN**. The Hall speaks
 Spanish and English, starting in the browser's own language and remembering an
 explicit choice. Translations are keyed by the English sentence, so anything not
 yet translated falls back to readable English rather than to an identifier — new
 strings are never blocked on a translation pass.
 
+Coverage is a test, not a habit. `bin/test-i18n.py` reads the render paths, pulls
+out every English sentence a person will see, and fails when one has no Spanish —
+so a new view cannot quietly ship untranslated, which is how coverage had drifted
+to about 40% before anybody noticed.
+
+The obvious mechanism, sweeping the rendered DOM and translating what matches a
+key, is deliberately **not** what this does. At DOM time there is no way to tell
+a sentence this product wrote from a city or agent name somebody typed, so a
+person whose city is called `Overview` would watch it rename itself. The
+distinction only exists in the source, between a literal and an interpolation,
+and that is where the check is made: anything holding a `${}` is skipped.
+
 ### `agents-city setup`
 
 Creates or selects a city and opens the Hall; `--tui` hands the flow to `seat`.
@@ -661,6 +694,62 @@ agents-city road disconnect product <remote-city-id>
 A city cannot connect to itself. Each machine must independently accept the
 other remote invitation.
 
+### `agents-city connect`
+
+Pairs this computer with a managed Road service. It does not create a
+connection unilaterally: both people approve it in the service, and the
+recipient sees the sender in their private human reception without exposing a
+city catalogue. The public client implements protocol v4; the hosted service is
+outside this repository and is not production-enabled or independently audited.
+
+```bash
+agents-city connect --service https://connect.example.com --trust-file roots.json
+agents-city connect --city product
+agents-city connect --all
+agents-city connect status
+agents-city connect roads
+```
+
+The command generates Ed25519/X25519, Olm and signed ML-KEM-768 material on this
+computer, prints a one-use PASCO and opens the browser for approval. Only public
+material is uploaded. Private keys, ratchet state, ML-KEM seeds and retry data
+are encrypted in `~/.agents-city/.runtime/connect/vault/`; the wrapping key
+stays in macOS Keychain, Windows Credential Manager or Linux Secret Service.
+The client fails closed if that keyring is unavailable. The vault is sealed from
+repo-agent windows on macOS and Linux.
+
+The signed root chain supplied through `--trust-file` is mandatory for first
+pairing with a non-development service. The client persists its last accepted
+version. A later root must continue from that exact local root and carry enough
+signatures from both the old and new offline authorities; skipped versions,
+rollback, expiry and silent operator/witness replacement are rejected. Protocol
+v4 then verifies the peer through key transparency, protects the first Olm
+message with hybrid X25519 + ML-KEM-768, and uses the Olm Double Ratchet. Normal
+sealed submissions omit sender, device, city and Road identity from the outer
+request. This does not hide IP address, timing or padded size from Cloudflare,
+and later ratchet steps are classical.
+
+The package includes a public root only for the exact managed sandbox origin;
+self-hosted services still require their reviewed `--trust-file`. A root
+returned by the service is never accepted as a first pin.
+
+`--city` chooses a local hub that can keep the computer's reception bridge
+alive; it is not a recipient selector and is never disclosed to the other
+person. Exactly one hub per computer holds the lease and one outbound encrypted
+session; no public port is opened. Use `--service URL` or
+`AGENTS_CITY_CONNECT_URL` for a pilot endpoint. The hosted server is not part of
+this Apache repository; the auditable client and wire protocol are.
+
+`agents-city connect roads` prints a connected person's name for a person Road,
+not the opaque `rx-*` transport endpoints. In the Hall, every incoming message
+waits for manual review by default. The owner may route it to one or more local
+cities, reject it with a reason, or explicitly enable the deterministic Auto
+router. Auto routes only one unique low-risk rule match; ambiguous, unmatched,
+prompt-like, secret-seeking, or command-like text remains in the human queue.
+
+See [docs/managed-connect.md](docs/managed-connect.md) for the exact key,
+envelope, encryption, ACK, revocation and threat-model contract.
+
 ### `agents-city bus`
 
 Operates messages between seats over declared roads.
@@ -675,7 +764,7 @@ agents-city bus send '*' "Notice for every connected city"
 | Subcommand | Effect |
 |---|---|
 | `roster` | return roads and known online presence |
-| `inbox` | return and consume pending inbox; append-only history remains |
+| `inbox` | return and consume the next approved batch of up to 20; managed text is unavailable until the owner routes it in the Hall |
 | `send owner/city TEXT` | send to one allowed destination |
 | `send '*' TEXT` | send to all roads; requires at least one |
 
@@ -1530,9 +1619,28 @@ AGENTS_CITY_DATA="$HOME/.agents-city/$CITY_OWNER/product" \
 Inside a normal session, you do not need to set `AGENTS_CITY_DATA`; it is already
 injected into each window. The example makes it explicit for an outside terminal.
 
-### Case 10: connect cities belonging to different machines or people
+### Case 10: connect two people on different machines
+
+With a managed Road operator, each person pairs a computer. `--city` chooses the
+local hub that will start the owner-level reception bridge; it does not reveal
+that city or give the other person direct access to it:
+
+```bash
+agents-city connect --city product --service https://connect.example.com --trust-file roots.json
+agents-city connect --city research --service https://connect.example.com --trust-file roots.json
+```
+
+One person requests the connection in that service and the other accepts it.
+The clients learn the active bilateral person Road over their authenticated
+relay sessions; neither side exchanges a shared bus token, exposes a local
+port, or receives the other person's city catalogue. Incoming text first stops
+in the human reception. The recipient decides which local city or cities may
+read it, or lets the optional fail-closed rule router decide when one match is
+unambiguous. The public client contract is documented in
+[docs/managed-connect.md](docs/managed-connect.md).
 
-On machine A:
+To self-host the existing token-based remote transport instead, exchange the
+public city invitations manually. On machine A:
 
 ```bash
 agents-city road invite product > product.invitation.json
@@ -1760,12 +1868,29 @@ The local hub keeps ephemeral state separate from readable configuration:
 ├── road-queue/*.json
 ├── road-inbox/*.json
 └── road-history.jsonl
+
+~/.agents-city/.runtime/reception/
+└── reception.sqlite3       # owner quarantine shared by local cities
 ```
 
 Credentials and runtime files are created with private permissions. Outboxes let
 an actor reconnect without losing an already accepted task; its ACK removes the
-pending item. Current limits are 200 pending items per queue and a 72-hour
-message lifetime. `bus inbox` consumes `road-inbox`, not append-only history.
+pending item. Actor outboxes and the local retry queue admit 200 pending items;
+the Road inbox admits 500 by default and returns at most 20 oldest items per
+read. Managed E2EE text first enters the separate owner reception: no city or
+model can consume it until a person rejects it or routes it to one or more
+cities in the Hall. A routed burst creates one coalesced seat wake-up rather
+than one model turn per message, and every native runtime runs at most one turn
+at a time. Full queues apply backpressure instead of silently deleting an older
+item. Message lifetime is 72 hours. `bus inbox` consumes approved `road-inbox`,
+not reception quarantine or append-only history.
+
+Relay throughput is not answer throughput. For one city, safe semantic capacity
+is approximately grouped requests per turn divided by turn duration. The local
+regression drains 100 Road messages in five exact batches of 20 after one
+content-free wake-up; a separate 20-request slow-runtime test proves model
+concurrency stays at one and the durable backlog drains without loss. A sender's
+`queued` result never means read or answered.
 
 ### Configurable variables
 
@@ -1787,6 +1912,12 @@ message lifetime. `bus inbox` consumes `road-inbox`, not append-only history.
 | `CITY_HOOKS` | `city` | `everywhere` runs the conscience hooks in every Claude session, not only city runtimes |
 | `CITY_DESKTOP` | `~/Desktop`, or the Windows desktop under WSL | where `agents-city shortcut` writes |
 | `CITY_CAGE` | `1` | `0` launches every window uncaged |
+| `CITY_ROAD_INBOX_MAX_PENDING` | `500` | local Road inbox capacity, from 20 to 10,000; a full inbox applies backpressure |
+| `CITY_ROAD_INBOX_WAKE_INTERVAL_MS` | `300000` | minimum interval between coalesced backlog wake-ups, from 30 seconds to 1 hour |
+| `CITY_RECEPTION_MAX_PENDING` | `10000` | owner-level pending remote messages before relay backpressure, from 100 to 100,000 |
+| `CITY_RECEPTION_MAX_BYTES` | `67108864` | total pending plaintext bytes in private local reception, from 1 MiB to 512 MiB |
+| `CITY_RECEPTION_PENDING_DAYS` | `30` | undecided local-message retention, from 1 to 90 days |
+| `CITY_RECEPTION_DELIVERY_INTERVAL_MS` | `1000` | how often a city bus claims human-approved routes, from 250 ms to 30 seconds |
 | `CITY_CAGE_DENY` | empty | extra colon-separated paths to seal |
 | `CITY_CAGE_ALLOW_WRITE` | empty | extra colon-separated paths to keep writable |
 | `CITY_UPDATE_CHECK` | `1` | `0` never asks npm whether a newer version exists |
@@ -1819,9 +1950,17 @@ CITY_SETTLE=0 CITY_STAGGER=0 agents-city seat --city product
 
 It reads `.git/config` and `HEAD` directly rather than running `git` once per
 repository, so a full scan finishes while somebody is looking at the screen, and
-it runs anywhere Python does — macOS, Linux and Windows alike. The guide and the
-Hall search this index; `plugin/scripts/find-repos.sh` is a thin shim over it for
-shell callers, printing the git half only.
+it runs anywhere Python does — macOS, Linux and Windows alike. This index is what
+the **terminal** uses: `seat --repos`, and the launcher resolving a card's
+`repo@branch` to a path on this machine. `plugin/scripts/find-repos.sh` is a thin
+shim over it for shell callers, printing the git half only.
+
+The **Hall** does not use it, and deliberately: choosing what an agent works on
+is a folder picker there. You walk your disk and take what you want — a
+repository, a worktree, a folder of documents, one exact file — and nothing is
+offered in advance or filtered out. A guessed list can only ever offer what it
+knew how to look for, and it is one more list to read before you can do the thing
+you came to do.
 
 The index is cached for one day at `$XDG_CACHE_HOME/agents-city/lugares.tsv` or
 `~/.cache/agents-city/lugares.tsv`. Both the Hall's house form and the seat offer
@@ -1908,10 +2047,18 @@ read your repos, attach to tmux, or read private files in your home. Use separat
 accounts, VMs, or containers for untrusted code, and also apply each provider
 CLI's permission controls.
 
-A remote bus expands the trust surface. Deploy HTTPS/WSS, rotate tokens, limit
-scopes, and read [docs/self-host.md](docs/self-host.md). A road authorises message
-exchange between seats; it neither authorises execution of received commands nor
-grants remote filesystem access.
+A remote bus expands the trust surface. For the self-hosted token transport,
+deploy HTTPS/WSS, rotate tokens, limit scopes, and read
+[docs/self-host.md](docs/self-host.md). Managed Connect instead uses device
+signatures, witnessed key transparency, hybrid X25519 + ML-KEM-768 session
+establishment, an Olm Double Ratchet and sealed delivery. Its private material
+is encrypted under an OS-keyring wrapping key in the cage-sealed
+`~/.agents-city/.runtime/connect/vault/` directory; see
+[docs/managed-connect.md](docs/managed-connect.md). A managed Road authorises
+encrypted reachability to the owner's human reception, not direct model input.
+Only the owner's later route makes the text available to selected cities. No
+Road authorises execution of received commands or grants remote filesystem
+access.
 
 ## Troubleshooting
 
@@ -2065,10 +2212,138 @@ agents-city seat --repos
 ```
 
 Discovery requires `.git` (a directory or worktree file) and an `origin` remote.
-If roots just changed, use the house form's **Search again**, or run
-`plugin/scripts/busca.py --refresh`. `AGENTS_CITY_ORG` may be filtering the repo;
+If roots just changed, run `plugin/scripts/busca.py --refresh`. `AGENTS_CITY_ORG` may be filtering the repo;
 leave it empty to index every remote.
 
+### Your CLIs, as you have them
+
+This does not compete with the CLI you already run. It orchestrates them, which
+only works if it respects what you configured in them — your plugins, your
+skills, your MCP servers, your model, your permissions.
+
+That is a claim about your machine, so it ships as a command rather than a
+promise:
+
+```bash
+agents-city doctor --config          # what we add, inherit and leave alone
+agents-city doctor --config --json   # the same, as data
+```
+
+It prints three columns per CLI, and the difference between them is the point:
+
+* **the deal** — what we add or override. It is short, every line says *why*,
+  and it is what makes the bus the only route between agents and the cage hold.
+  Without it there is no product.
+* **we inherit** — what we deliberately do *not* send, so your own CLI reads
+  your own configuration for it. Your model, your effort, your approval policy.
+* **untouched** — what loads exactly as it always did.
+
+The report and the runtime read the **same file** — `plugin/channel/runtime/arnes.json`
+— so the claim cannot drift from the behaviour. The connectors take their policy
+values out of that declaration instead of spelling them inline, and the suite
+fails if a runtime imposes something the declaration does not mention. Writing
+that check found two: a system prompt injected into Kimi that nothing declared,
+and a sandbox value written in two places.
+
+Where your setting and ours meet, yours wins where it can: Codex's
+`approval_policy` is honoured when you set one, and `on-request` is only the
+fallback when you have not. The report says the consequence out loud — `never`
+disables app and MCP tools — instead of quietly deciding you did not mean it.
+
+### Your chair keeps your own Claude Code
+
+The seat window opens **Claude Code itself** — your plugins, your skills, your
+MCP servers, your statusline, slash-command completion, the model picker. It is
+the harness you already use, in the pane, and that is deliberate: the chair is
+where a person works by hand.
+
+It is still on the bus. The city plugin's `SessionStart`, `UserPromptSubmit`,
+`Stop` and `SessionEnd` hooks report that session's prompts and answers as the
+same `conversation.*` events the gateway reports, so the town hall sees the
+conversation either way. And it carries the same two flags that make the bus the
+only route between agents — `crossSessionInbound: refuse` and
+`--disallowed-tools SendMessage,ListAgents`. A quieter product with a hole in it
+would not be a better product.
+
+**Agent houses keep the gateway** and its `city>` prompt, because what the
+gateway buys is the bus being able to *push* work into a window — which is the
+whole job of a house and no part of the chair's.
+
+One card key moves the chair back:
+
+```yaml
+ui.seat: gateway     # the city's own prompt in the chair, as before
+```
+
+`CITY_UI=gateway` forces it for one launch. Houses are not asked: a house exists
+to receive assignments, and the gateway is what makes that possible.
+
+### The engine a house runs on
+
+`model.<window>` and `effort.<window>` on the card say what a house runs on, once,
+whatever CLI runs it. Claude takes them as flags; the native gateways parse the
+same spelling out of the command string and send it with the turn — which is why
+one key means the same thing for all four:
+
+| provider | model | effort |
+| --- | --- | --- |
+| `claude` | yes, an alias the CLI resolves (`opus`, `sonnet`…) | yes |
+| `codex` | yes, the name your Codex uses (`~/.codex/config.toml`) | yes |
+| `opencode` | yes, `provider/model` | no such setting |
+| `kimi` | yes | no such setting |
+
+A command that already carries the flag keeps it: `runs.dbt: codex --model o3`
+was somebody saying what they meant, and a generic key must not overrule a
+specific sentence. Effort is written only where it is read, because a flag
+nothing reads is how a control ends up looking like it works.
+
+### Releasing
+
+A release is a tag. Pushing `v0.5.2` runs the whole suite on Linux, macOS and
+Windows, checks that the tag and the three manifests name the same version, and
+publishes with **provenance** — a signed statement of which commit and which
+workflow produced that exact tarball. Anyone can check it:
+
+```bash
+npm audit signatures
+```
+
+No token is stored anywhere. It publishes through npm's trusted publishing,
+which trades a short-lived OIDC identity from the workflow for the right to
+publish this one package: a secret that does not exist cannot leak.
+
+```bash
+npm version patch --no-git-tag-version   # then open a PR with the bump
+git tag v0.5.2 && git push origin v0.5.2 # the tag is the release
+```
+
+This exists because publishing by hand did not work. Four versions went
+unpublished in a single day, not because anybody was careless but because the
+step lived in a person's head and needed their passkey — and what reached the
+registry was whatever happened to be in a working directory, connected to no
+commit anyone could name.
+
+### Removing it completely
+
+```bash
+agents-city uninstall           # says exactly what would go; removes nothing
+agents-city uninstall --yes     # goes through with it
+agents-city uninstall --keep-cities --yes   # unwire the machine, keep the cities
+agents-city uninstall --npm --yes           # and remove the global package too
+```
+
+It closes every session, hall and map the product started, removes the desktop
+shortcuts and the Claude plugin registration, and deletes `~/.agents-city` (your
+cities, their state and their backups), `~/.config/agents-city`,
+`~/.cache/agents-city` and `~/.claude/channels/city-bus` — plus the bus token in
+the macOS Keychain.
+
+It never touches your repositories, your worktrees or your document folders. An
+agent's home holds *links* to those, and a link is all that goes.
+
+`reset` is the other question: it empties one city, keeps a backup and leaves the
+install in place, for when you mean to keep using it.
+
 ### GitHub does not show private repos or organisations
 
 ```bash

package/benchmarks/latency/fake-claude-cli.mjs

@@ -72,6 +72,7 @@ function runNext() {
   working = true;
   const message = queue.shift();
   const text = userText(message);
+  const delay = behavior() === 'slow' ? 350 : 5;
   setTimeout(() => {
     emit({
       type: 'assistant',
@@ -95,7 +96,7 @@ function runNext() {
       working = false;
       runNext();
     }, 5);
-  }, 5);
+  }, delay);
 }
 
 function userText(message) {

package/benchmarks/reception/README.md

@@ -0,0 +1,16 @@
+# Local reception ingest
+
+This measures the durable, human-quarantine boundary only: decrypted messages
+committed to private local SQLite in protocol-v4 batches. It uses no network,
+relay, model, or fake model latency.
+
+Build the public client, then run the 1,000-message/second gate:
+
+```bash
+npm --prefix plugin/channel run build
+node benchmarks/reception/run.mjs --messages 1000 --batch-size 32 --minimum 1000
+```
+
+Passing this gate says the computer can quarantine the offered transport load
+without loss. It does not say a human or model can answer 1,000 requests per
+second. Pending-count and byte caps apply backpressure when review falls behind.

package/benchmarks/reception/run.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/** Reproducible local reception-ingest capacity check. No network or model. */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import {
+  receptionDatabasePath,
+  recordReceptionMessages,
+} from '../../plugin/channel/managed-connect-client.js';
+
+const integerArg = (name, fallback, minimum, maximum) => {
+  const index = process.argv.indexOf(name);
+  const value = index >= 0 ? Number(process.argv[index + 1]) : fallback;
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${name} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return value;
+};
+
+const total = integerArg('--messages', 1_000, 1, 100_000);
+const batchSize = integerArg('--batch-size', 32, 1, 32);
+const minimum = integerArg('--minimum', 1_000, 1, 1_000_000);
+const root = mkdtempSync(join(tmpdir(), 'agents-city-reception-bench-'));
+const context = {
+  dataDir: root,
+  appHome: root,
+  runtimeDir: join(root, '.runtime', 'bus', 'city-target'),
+  owner: 'owner',
+  city: { id: 'city_target', address: 'owner/target', name: 'Target' },
+  domain: 'custom',
+  seatRole: '',
+  actors: { seat: { role: 'chair' } },
+  engines: { seat: 'claude' },
+  roads: [],
+};
+const envelope = (index) => ({
+  protocol: 'agents-city-bus/2',
+  id: `managed_bench_${String(index).padStart(8, '0')}`,
+  kind: 'road.message',
+  scope: 'road',
+  thread: null,
+  from: { city: 'peer/source', actor: 'seat', role: 'external-seat' },
+  to: { city: context.city.address, actor: 'seat' },
+  createdAt: '2026-08-28T12:00:00.000Z',
+  payload: {
+    text: 'x'.repeat(256),
+    transport: 'managed-e2ee',
+    roadId: 'road_benchmark',
+    remoteMessageId: String(index),
+  },
+});
+
+try {
+  // Exclude schema creation and first WAL setup from steady ingest.
+  recordReceptionMessages(context, [envelope(total)]);
+  const messages = Array.from({ length: total }, (_, index) => envelope(index));
+  const started = performance.now();
+  for (let index = 0; index < messages.length; index += batchSize) {
+    recordReceptionMessages(context, messages.slice(index, index + batchSize));
+  }
+  const seconds = (performance.now() - started) / 1_000;
+  const database = new DatabaseSync(receptionDatabasePath(root), { readOnly: true });
+  const persisted = Number(
+    database.prepare('SELECT COUNT(*) AS count FROM reception_messages').get().count,
+  ) - 1;
+  database.close();
+  const messagesPerSecond = total / seconds;
+  const result = {
+    messages: total,
+    batchSize,
+    persisted,
+    lost: total - persisted,
+    seconds: Number(seconds.toFixed(3)),
+    messagesPerSecond: Number(messagesPerSecond.toFixed(1)),
+    minimum,
+    passed: persisted === total && messagesPerSecond >= minimum,
+  };
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.passed) process.exitCode = 1;
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

package/bin/agents-city.js

@@ -25,11 +25,16 @@ const ORDENES = {
   cities: { que: ['bin/cities'], di: 'list, create or select your cities' },
   agents: { que: ['bin/agents'], di: 'list agents and manage their workspace mounts' },
   road: { que: ['bin/road'], di: 'connect two cities explicitly' },
+  connect: { que: ['bin/connect'], di: 'pair this computer and open encrypted managed Roads' },
   bus: { que: ['bin/bus'], di: 'send information over those roads (seat only)' },
   committee: { que: ['bin/committee'], di: 'chair-mediated work with repo agents' },
   benchmark: { que: ['bin/benchmark'], di: 'offline stress/governance or opt-in live runtime latency' },
   logs: { que: ['bin/logs'], di: 'read or follow visible activity and operational diagnostics' },
   reset: { que: ['bin/reset'], di: 'reset one city to onboarding, recoverably' },
+  uninstall: {
+    que: ['bin/uninstall'],
+    di: 'remove everything this wrote on this machine (previews first)',
+  },
   skills: { que: ['bin/skills'], di: 'recognise the skills installed in each repo' },
   city: { que: ['bin/city'], di: 'draw your city' },
   shortcut: { que: ['bin/shortcut'], di: 'put a city on your desktop: icon, name, double-click' },

package/bin/connect

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Pair this computer and connect one or more local cities to managed Roads.
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+exec node "$ROOT/plugin/channel/managed-connect-cli.js" "$@"