agents-city 0.5.9 → 0.5.11

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "city",
       "source": "./plugin",
-      "version": "0.5.9",
+      "version": "0.5.11",
       "description": "Operate one autonomous city seat, its domain, role, repo support agents, goal, recognised skills and explicit roads to other cities."
     }
   ]

package/README.es.md

@@ -165,10 +165,9 @@ agents-city --version
 | Node.js 22.13 o posterior | paquete npm, bus WebSocket, recepción local y frontends |
 | npm | instalación y empaquetado |
 | Python 3 | Hall, onboarding, ciudades, mapas y utilidades |
-| bash | sesiones y launchers |
-| tmux | una ventana por asiento/repo; `seat` intenta instalarlo si falta |
-| macOS o Linux | plataformas nativas soportadas |
-| WSL | necesario en Windows porque Windows no incluye bash/tmux nativos |
+| un servidor de ventanas | una ventana por asiento/agente: **tmux** en macOS y Linux, **herdr** en Windows; `seat` intenta instalarlo si falta |
+| macOS, Linux o Windows | los tres de forma nativa. Cuatro comandos siguen necesitando shell — `city`, `demo`, `benchmark`, `test` — y lo dicen por su nombre en Windows |
+| bash | sólo para esos cuatro |
 
 Cada motor necesita además su propio CLI instalado y autenticado. Agents City no
 incluye ni suplanta las cuentas de Claude, Codex, OpenCode o Kimi.
@@ -340,15 +339,18 @@ agents-city shortcut --remove     # quitarlo otra vez
 agents-city shortcut --to ~/bin   # en otro sitio que no sea el escritorio
 ```
 
-**En Windows** la ciudad vive dentro de WSL, y un `~/Desktop` de WSL es el
-escritorio del home de Linux: uno que nadie mira nunca. Por eso el acceso directo
-se escribe en el escritorio **de Windows**, preguntándoselo a Windows en vez de
-adivinarlo a partir del nombre de usuario (un escritorio redirigido a OneDrive o
-a un perfil de dominio no está bajo `C:\Users\<nombre>\Desktop`). Es un `.lnk` de
-verdad, construido con la propia PowerShell de Windows para que pueda llevar un
-`.ico`, y arranca `wsl.exe` ejecutando el mismo comando en una shell de login. Si
-no hay interoperabilidad, se escribe un `.cmd` que también se abre con doble
-clic: la misma puerta, con icono genérico.
+**En Windows** es un `.lnk` de verdad, construido con la propia PowerShell de
+Windows para que pueda llevar un `.ico`, y ejecuta el mismo comando de la puerta
+principal que cualquier otro escritorio. El escritorio se le pregunta a Windows
+en vez de adivinarlo a partir del nombre de usuario: uno redirigido a OneDrive o
+a un perfil de dominio no está bajo `C:\Users\<nombre>\Desktop`. Si no hay
+PowerShell se escribe un `.cmd` que también se abre con doble clic: la misma
+puerta, con icono genérico.
+
+**Dentro de WSL** el acceso directo sigue cruzando de vuelta: un `~/Desktop` de
+ahí es el escritorio del home de Linux, que nadie mira, así que el escritorio de
+Windows recibe un `.lnk` que arranca `wsl.exe` con el mismo comando en una shell
+de login.
 
 ### Qué se crea
 
@@ -619,6 +621,35 @@ agents-city setup --no-browser
 | `--tui` | usa onboarding de terminal y abre la sesión |
 | `--no-browser` | mantiene el Hall en terminal e imprime su URL |
 
+### `agents-city hall`
+
+El ayuntamiento corre **desacoplado**, como el bus de la ciudad y todo lo demás
+que vive mucho en este producto. Cerrar la ventana desde la que lo lanzaste deja
+de ser una forma de romper la página que alguien está mirando, y `agents-city
+hall` dos veces te devuelve la dirección que ya está sirviendo en vez de abrir
+un segundo. Se para con `agents-city exit`; `--foreground` sirve en la ventana y
+muere con ella.
+
+Su dirección sobrevive a un reinicio. El token se acuñaba por proceso, y eso
+hacía desechable cada pestaña — cierras el ayuntamiento, lo vuelves a abrir, y la
+página que alguien tenía queda rechazada para siempre, sin más vuelta que leer
+una URL nueva en una terminal. Se guarda en `~/.agents-city/.runtime/hall.pase`,
+modo 0600, en la misma clase que el token del bus que este producto ya guarda.
+
+Si la ciudad está corriendo se dice en **todas** las pantallas, no en una
+portada a la que quizá no vuelvas: abierta o no, cuántos agentes están conectados
+de verdad y — sólo cuando falta — que esta ciudad corre sin ninguna de sus reglas.
+Esa última luz hubo que ganársela: antes adivinaba si existía un directorio, y ese
+directorio es la caché del *marketplace*, que aparece en cuanto alguien lo añade.
+Así que una máquina sin el plugin enseñaba un «installed» en verde, y por eso su
+dueño podía pasarse una tarde sin ver que no se estaba aplicando nada. Ahora se lo
+pregunta a Claude.
+
+Y cuando el ayuntamiento no contesta, la página lo dice con sus palabras: qué ha
+pasado, que no se ha perdido nada, el comando que lo vuelve a abrir y un botón
+que reintenta — más un reintento silencioso cada pocos segundos, para que una
+pestaña abierta se recupere sola cuando el ayuntamiento vuelve.
+
 ### `agents-city seat`
 
 Configura lo solicitado, garantiza tmux/plugin y abre o reanuda la sesión de la

package/README.md

@@ -163,10 +163,9 @@ agents-city --version
 | 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 |
-| tmux | one window per seat/repo; `seat` tries to install it when missing |
-| macOS or Linux | natively supported platforms |
-| WSL | required on Windows because native Windows has no bash/tmux |
+| a window server | one window per seat/agent: **tmux** on macOS and Linux, **herdr** on Windows; `seat` tries to install it when missing |
+| macOS, Linux or Windows | all three natively. Four commands still need a shell — `city`, `demo`, `benchmark`, `test` — and say so by name on Windows |
+| bash | only for those four |
 | bubblewrap | optional, Linux only: it IS the cage there. Without it agents run uncaged — see [the cage](#the-cage-the-broker-and-the-audit-chain) |
 
 Each runtime also needs its own installed and authenticated CLI. Agents City
@@ -336,14 +335,16 @@ agents-city shortcut --remove     # take it off again
 agents-city shortcut --to ~/bin   # somewhere other than the desktop
 ```
 
-**On Windows** the city lives inside WSL, and a `~/Desktop` in WSL is the Linux
-home's desktop — which nobody ever looks at. So the shortcut is written to the
-**Windows** desktop instead, asked of Windows itself rather than guessed from a
-username (a desktop redirected to OneDrive or a domain profile is not under
-`C:\Users\<name>\Desktop`). It is a real `.lnk`, built through Windows' own
-PowerShell so it can carry an `.ico`, and it launches `wsl.exe` running the same
-command in a login shell. Where interop is unavailable, a double-clickable
-`.cmd` is written instead — same door, plain icon.
+**On Windows** it is a real `.lnk`, built through Windows' own PowerShell so it
+can carry an `.ico`, running the same front-door command as every other desktop.
+The desktop is asked of Windows itself rather than guessed from a username — one
+redirected to OneDrive or a domain profile is not under `C:\Users\<name>\Desktop`.
+Where PowerShell is unavailable a double-clickable `.cmd` is written instead:
+same door, plain icon.
+
+**Inside WSL** the shortcut still crosses back: a `~/Desktop` there is the Linux
+home's desktop, which nobody looks at, so the Windows desktop gets a `.lnk` that
+launches `wsl.exe` running the same command in a login shell.
 
 ### What gets created
 
@@ -610,6 +611,34 @@ agents-city setup --no-browser
 | `--tui` | use terminal onboarding and open the session |
 | `--no-browser` | keep the Hall in the terminal and print its URL |
 
+### `agents-city hall`
+
+The town hall runs **detached**, like the city bus and every other long-lived
+piece of this product. Closing the window that started it is not a way to break
+the page somebody is looking at, and `agents-city hall` run twice hands back the
+address that is already serving rather than starting a second one. Stop it with
+`agents-city exit`; `--foreground` serves in the window and stops with it.
+
+Its address survives a restart. The token used to be minted per process, which
+made every tab disposable — close the hall, open it again, and the page somebody
+had is permanently refused, with no way back except reading a new URL out of a
+terminal. It is stored at `~/.agents-city/.runtime/hall.pase`, mode 0600, in the
+same class as the bus token this product already keeps.
+
+Whether the city is running is said on **every** screen, not on the front page
+somebody may never return to: open or not, how many agents are actually
+connected, and — only when it is missing — that this city is running with none of
+its rules. That last light is the one that had to be earned: it used to be a
+guess at whether a directory existed, and that directory is the *marketplace's*
+cache, which appears the moment somebody adds the marketplace. So a machine with
+no city plugin showed a green "installed", which is why its owner could spend an
+afternoon unable to see that nothing was being enforced. It asks Claude now.
+
+And when the hall is not answering, the page says so in its own words: what
+happened, that nothing was lost, the command that opens it again, and a button
+that retries — plus a quiet retry every few seconds, so a page left open
+recovers by itself when the hall comes back.
+
 ### `agents-city seat`
 
 Configures requested settings, ensures tmux/plugin, and opens or resumes the city
@@ -961,7 +990,8 @@ script pretending:
 |---|---|---|
 | macOS | `.app` bundle running the city in Terminal | `.icns`, built with the system's `iconutil` |
 | Linux | `.desktop` entry, marked trusted where `gio` exists | `.png` under `XDG_DATA_HOME` |
-| Windows (WSL) | `.lnk` on the **Windows** desktop, launching `wsl.exe` | `.ico`, when PowerShell interop is reachable |
+| Windows | `.lnk` on the desktop, running the front-door command | `.ico`, built by hand; a `.cmd` without PowerShell |
+| Windows (inside WSL) | `.lnk` on the **Windows** desktop, launching `wsl.exe` | `.ico`, when PowerShell interop is reachable |
 
 All of them run the same line you would type, so the shortcut is a labelled
 button on the front door rather than a second way in. The icon is generated

package/bin/agents-city.js

@@ -3,9 +3,15 @@
  *
  * The same trick Claude Code uses — npm as the installer, the payload being
  * whatever the product actually is. Here the payload is the repo itself: the
- * Python that writes your files, the bash that builds your tmux session, and the
- * prebuilt map. Node is only the dispatcher, and it is guaranteed present because
- * npm just ran.
+ * Python that writes your files and builds your city, the Node that carries the
+ * bus, and the prebuilt map. Node is only the dispatcher, and it is guaranteed
+ * present because npm just ran.
+ *
+ * Every command used to go through a bash door, and fifteen of them were one
+ * `exec python3 x.py "$@"` line — a spelling of the interpreter, in the one
+ * language Windows does not have. They are named by their implementation now,
+ * and this file picks the interpreter, so what is left needing a shell is five
+ * commands rather than all of them.
  *
  * Deliberately not a port to JS: the shared modules (card, parcels, units, roles)
  * are the product's single source of truth and every door reads them — the
@@ -19,35 +25,114 @@ const fs = require('fs');
 
 const RAIZ = path.dirname(__dirname);
 
+/* Every command, named by what it IS rather than by the door it used to have.
+ *
+ * A door that was one `exec python3 x.py "$@"` line is not a door: it is a
+ * spelling of the interpreter, and spelling it in bash is what kept this
+ * product off Windows for the fifteen commands that never needed a shell at
+ * all. So each entry says its kind, and this file picks the interpreter:
+ *
+ *   py    a Python module — everywhere
+ *   node  a Node entry point — everywhere; `env` first resolves the city's
+ *         settings, which the bash door used to do by sourcing city-env.sh
+ *   sh    a door with shell logic of its own, and therefore POSIX for now
+ */
 const ORDENES = {
-  hall: { que: ['bin/hall'], di: 'the town hall: manage your city from the browser' },
-  seat: { que: ['bin/seat'], di: 'your chair: domain, seat role, repo-agent roles, goal, tmux' },
-  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' },
+  hall: { py: 'bin/hall', di: 'the town hall: manage your city from the browser' },
+  seat: {
+    py: 'plugin/scripts/seat.py',
+    di: 'your chair: domain, seat role, repo-agent roles, goal, tmux',
+  },
+  cities: { py: 'plugin/scripts/cities.py', di: 'list, create or select your cities' },
+  agents: {
+    py: 'plugin/scripts/workspace.py',
+    di: 'list agents and manage their workspace mounts',
+  },
+  road: { py: 'plugin/scripts/roads.py', di: 'connect two cities explicitly' },
+  connect: {
+    node: 'plugin/channel/managed-connect-cli.js',
+    di: 'pair this computer and open encrypted managed Roads',
+  },
+  bus: {
+    node: 'plugin/channel/client.js',
+    antes: ['bus'],
+    entorno: true,
+    di: 'send information over those roads (seat only)',
+  },
+  committee: {
+    node: 'plugin/channel/client.js',
+    antes: ['committee'],
+    entorno: true,
+    di: 'chair-mediated work with repo agents',
+  },
+  benchmark: {
+    sh: 'bin/benchmark',
+    di: 'offline stress/governance or opt-in live runtime latency',
+  },
+  logs: {
+    py: 'plugin/scripts/logs.py',
+    di: 'read or follow visible activity and operational diagnostics',
+  },
+  reset: { py: 'plugin/scripts/reset.py', di: 'reset one city to onboarding, recoverably' },
   uninstall: {
-    que: ['bin/uninstall'],
+    py: 'plugin/scripts/desinstala.py',
     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' },
-  demo: { que: ['bin/demo'], di: 'Aurora Games — see it working, no account' },
-  setup: { que: ['bin/setup.py'], di: 'create or open a personal city' },
-  report: { que: ['bin/report.py'], di: 'report growth from your folders' },
-  tokens: { que: ['bin/tokens.py'], di: 'report token spend' },
-  exit: { que: ['bin/exit'], di: 'close the day — every session and agent, or one city' },
-  doctor: { que: ['bin/doctor'], di: 'check this machine: tools, runtimes, cage, city, version' },
-  update: { que: ['bin/update'], di: 'install the newest published version (--check just asks)' },
-  test: { que: ['bin/test'], di: 'every check in the repo' },
+  skills: {
+    py: 'plugin/scripts/capabilities.py',
+    di: 'recognise the skills installed in each repo',
+  },
+  city: { sh: 'bin/city', di: 'draw your city' },
+  shortcut: {
+    py: 'plugin/scripts/atajos.py',
+    di: 'put a city on your desktop: icon, name, double-click',
+  },
+  demo: { sh: 'bin/demo', di: 'Aurora Games — see it working, no account' },
+  setup: { py: 'bin/setup.py', di: 'create or open a personal city' },
+  report: { py: 'bin/report.py', di: 'report growth from your folders' },
+  tokens: { py: 'bin/tokens.py', di: 'report token spend' },
+  exit: {
+    py: 'plugin/scripts/apaga.py',
+    di: 'close the day — every session and agent, or one city',
+  },
+  doctor: {
+    py: 'plugin/scripts/doctor.py',
+    di: 'check this machine: tools, runtimes, cage, city, version',
+  },
+  update: {
+    py: 'plugin/scripts/actualiza.py',
+    di: 'install the newest published version (--check just asks)',
+  },
+  test: { sh: 'bin/test', di: 'every check in the repo' },
 };
 
+/* Which Python. `python3` is the POSIX spelling and it is NOT what a Windows
+ * install from python.org gives you — that is `python` and the `py` launcher,
+ * and the Microsoft Store's `python3.exe` is a stub that opens the Store when
+ * nothing is installed. So: ask, in order, and take the first that answers with
+ * a version. Resolved once per run.
+ */
+let elInterprete;
+function interprete() {
+  if (elInterprete !== undefined) return elInterprete;
+  const candidatos =
+    process.platform === 'win32'
+      ? [['python'], ['py', '-3'], ['python3']]
+      : [['python3'], ['python']];
+  for (const c of candidatos) {
+    const r = spawnSync(c[0], [...c.slice(1), '-c', 'import sys; print(sys.version_info[0])'], {
+      encoding: 'utf8',
+    });
+    if (r.status === 0 && String(r.stdout).trim() === '3') {
+      elInterprete = c;
+      return elInterprete;
+    }
+  }
+  elInterprete = null;
+  return elInterprete;
+}
+
+
 function ayuda() {
   const v = require(path.join(RAIZ, 'package.json')).version;
   console.log(`
@@ -60,17 +145,16 @@ function ayuda() {
   for (const [n, o] of Object.entries(ORDENES)) {
     console.log(`    ${n.padEnd(11)}${o.di}`);
   }
+  const conShell = Object.entries(ORDENES).filter(([, o]) => o.sh).map(([n]) => n);
   console.log(`
-  Needs python3 and tmux (the seat installs tmux itself). On Windows, run it
-  inside WSL — the session is made of tmux windows, and there is no native tmux.
+  Needs Python 3, and a window server for the ones that open a city (the seat
+  installs it itself).
 `);
-}
-
-function hay(programa) {
-  const r = spawnSync(process.platform === 'win32' ? 'where' : 'command',
-    process.platform === 'win32' ? [programa] : ['-v', programa],
-    { shell: process.platform !== 'win32', stdio: 'ignore' });
-  return r.status === 0;
+  if (process.platform === 'win32') {
+    console.log(`  On Windows these still need WSL, because they are shell programs:
+    ${conShell.join(', ')}
+`);
+  }
 }
 
 function main() {
@@ -83,42 +167,83 @@ function main() {
     return 0;
   }
 
-  if (process.platform === 'win32') {
-    console.error('\n  agents-city runs on tmux and bash, and Windows has neither');
-    console.error('  natively. Install it inside WSL and run it from there:\n');
-    console.error('    wsl -- npm install -g agents-city\n');
-    return 1;
-  }
-
-  const orden = ORDENES[primera];
-  const resto = orden ? args.slice(1) : args;
-  const entrada = orden ? orden.que[0] : ORDENES.hall.que[0];
-  if (!orden && args.length && primera.startsWith('-') === false) {
+  const orden = ORDENES[primera] || ORDENES.hall;
+  const resto = ORDENES[primera] ? args.slice(1) : args;
+  if (!ORDENES[primera] && args.length && primera.startsWith('-') === false) {
     console.error(`\n  No such command: ${primera}\n`);
     ayuda();
     return 1;
   }
 
-  if (!hay('python3')) {
-    console.error('\n  agents-city needs python3 on PATH — the files it manages are');
-    console.error('  written by Python, the same modules every door shares.');
-    console.error('  macOS: xcode-select --install   ·   Debian: apt install python3\n');
+  // A door with shell logic of its own. Named, with what it is, rather than a
+  // blanket "this product does not run here" — fifteen of these commands do.
+  if (orden.sh && process.platform === 'win32') {
+    console.error(`\n  \`agents-city ${primera}\` is still a shell program, and Windows has`);
+    console.error('  no shell to run it in. Everything else on this install works;');
+    console.error('  for this one, run it inside WSL:\n');
+    console.error(`    wsl -- agents-city ${primera}\n`);
     return 1;
   }
 
-  const guion = path.join(RAIZ, entrada);
+  const objetivo = orden.sh || orden.py || orden.node;
+  const guion = path.join(RAIZ, objetivo);
   if (!fs.existsSync(guion)) {
-    console.error(`\n  ${entrada} is missing from this install — reinstall:`);
+    console.error(`\n  ${objetivo} is missing from this install — reinstall:`);
     console.error('    npm install -g agents-city\n');
     return 1;
   }
+
+  let programa = guion;
+  let antes = [];
+  if (orden.py) {
+    const py = interprete();
+    if (!py) {
+      console.error('\n  agents-city needs Python 3 on PATH — the files it manages are');
+      console.error('  written by Python, the same modules every door shares.');
+      console.error('  macOS: xcode-select --install   ·   Debian: apt install python3');
+      console.error('  Windows: winget install Python.Python.3.12\n');
+      return 1;
+    }
+    programa = py[0];
+    antes = [...py.slice(1), guion];
+  } else if (orden.node) {
+    programa = process.execPath;
+    antes = [guion, ...(orden.antes || [])];
+  }
+
+  // The settings the bash doors used to establish by sourcing city-env.sh.
+  // Asked of the one resolver, in the one shape a non-shell can read.
+  // PYTHONUTF8 makes `open()` and stdout default to UTF-8 whatever code page
+  // the console is on. Without it, on Windows, a card with an em dash is
+  // written in cp1252 and read back as UTF-8 by the next door along.
+  let entorno = {
+    ...process.env, PYTHONUNBUFFERED: '1', PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8',
+  };
+  if (orden.entorno) {
+    const py = interprete();
+    if (py) {
+      const r = spawnSync(py[0], [...py.slice(1), path.join(RAIZ, 'plugin/scripts/city_env.py'),
+        '--json'], { encoding: 'utf8' });
+      if (r.status === 0) {
+        try {
+          entorno = { ...entorno, ...JSON.parse(r.stdout) };
+        } catch {
+          /* a resolver that cannot answer leaves the environment as it found it */
+        }
+      }
+    }
+  }
+
   // Unbuffered, so the URL a server prints reaches a pipe as well as a terminal
   // — a CI log or a `| head` otherwise swallows it and the run looks silent.
-  const r = spawnSync(guion, orden ? resto : args, {
-    stdio: 'inherit', cwd: RAIZ,
-    env: { ...process.env, PYTHONUNBUFFERED: '1' },
+  const r = spawnSync(programa, [...antes, ...resto], {
+    stdio: 'inherit', cwd: RAIZ, env: entorno,
   });
   return r.status === null ? 1 : r.status;
 }
 
-process.exit(main());
+// Only when this IS the command. Exported so the checks can read the real map
+// rather than a regex over this file — what each command runs, and which ones
+// still need a shell, is exactly the thing that must not drift unnoticed.
+if (require.main === module) process.exit(main());
+module.exports = { ORDENES };

package/bin/hall

@@ -4,6 +4,12 @@
     ./bin/hall                open it
     ./bin/hall --city lab     open one known city
     ./bin/hall --no-browser   print the address instead
+    ./bin/hall --foreground   serve here, and stop when this window closes
+
+It runs detached, like the city bus and every other long-lived piece of this
+product. Closing the window that started it is not a way to break the page
+somebody is looking at, and its address survives a restart, so a tab left open
+overnight still works in the morning.
 
 One page on localhost: the selected city's identity, owner seat (role, folders,
 goal), repo support agents, recognised skills, roads, districts and houses. It
@@ -51,10 +57,72 @@ def asegura_build():
     return True
 
 
+def vivo():
+    """The URL of a Hall already serving on this machine, or ''.
+
+    Asked, not assumed: a marker file outlives a process that was killed, and
+    handing somebody a URL that answers nothing is exactly the broken tab this
+    change exists to remove.
+    """
+    import json
+    import urllib.error
+    import urllib.request
+
+    try:
+        with open(serve.marcador(), encoding='utf-8') as f:
+            url = str(json.load(f).get('url') or '')
+        if not url:
+            return ''
+        with urllib.request.urlopen(url, timeout=2) as r:
+            return url if r.status == 200 else ''
+    except (OSError, ValueError, urllib.error.URLError):
+        return ''
+
+
+def despega(datos, abrir):
+    """Start the Hall detached, and wait until it can actually answer.
+
+    Detached because every other long-lived piece of this product already is —
+    the bus hub, the gateways, the adapters — and the Hall was the one that died
+    with whichever terminal happened to start it. Closing a window is not
+    supposed to be a way to break the page somebody is looking at.
+
+    It waits for the address to serve rather than printing one optimistically: a
+    URL that is not up yet is the same broken tab, one second earlier.
+    """
+    import subprocess
+    import time
+    import webbrowser
+
+    subprocess.Popen(
+        [sys.executable, os.path.join(AQUI, 'serve.py'), datos],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, **runtime_processes.DESPEGADO,
+    )
+    limite = time.monotonic() + 25
+    while time.monotonic() < limite:
+        url = vivo()
+        if url:
+            print(f'\n  The town hall\n\n    {url}\n')
+            print('    It keeps running when you close this window.')
+            print('    Stop it with:  agents-city exit\n')
+            if abrir:
+                try:
+                    webbrowser.open(url)
+                except Exception:
+                    pass
+            return 0
+        time.sleep(0.2)
+    print('  The hall did not come up. Run it here to see why:', file=sys.stderr)
+    print(f'    {os.path.basename(sys.argv[0])} --foreground', file=sys.stderr)
+    return 1
+
+
 if __name__ == '__main__':
     ap = argparse.ArgumentParser(description='Open one personal city in the local Hall')
     ap.add_argument('--city', default='', help='known city name, id or path')
     ap.add_argument('--no-browser', action='store_true', help='print the URL only')
+    ap.add_argument('--foreground', action='store_true',
+                    help='serve in this window and stop when it closes')
     a = ap.parse_args()
     if not asegura_build():
         sys.exit(1)
@@ -68,6 +136,18 @@ if __name__ == '__main__':
         print(f"  This city belongs to {owner!r}, not {usuario!r}.", file=sys.stderr)
         sys.exit(1)
     cities.selecciona(usuario, datos)
-    sys.exit(0 if serve.sirve(datos,
-                              abrir=not a.no_browser,
-                              pagina='hall') else 0)
+    if a.foreground:
+        sys.exit(0 if serve.sirve(datos, abrir=not a.no_browser, pagina='hall') else 0)
+    # Already open: hand back the same address rather than starting a second
+    # hall and leaving somebody with two of them and no way to tell which.
+    ya = vivo()
+    if ya:
+        print(f'\n  The town hall is already open\n\n    {ya}\n')
+        if not a.no_browser:
+            import webbrowser
+            try:
+                webbrowser.open(ya)
+            except Exception:
+                pass
+        sys.exit(0)
+    sys.exit(despega(datos, abrir=not a.no_browser))