agents-city 0.5.10 → 0.5.12

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "city",
       "source": "./plugin",
-      "version": "0.5.10",
+      "version": "0.5.12",
       "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
 

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
 
@@ -989,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/benchmarks/committee/run.py

@@ -34,12 +34,12 @@ def table(rows):
     widths = [max(len(label), *(len(str(row[key])) for row in rows))
               for label, key in columns]
     lines = [
-        '  '.join(label.ljust(width) for (label, _), width in zip(columns, widths)),
+        '  '.join(label.ljust(width) for (label, _), width in zip(columns, widths, strict=False)),
         '  '.join('-' * width for width in widths),
     ]
     for row in rows:
         lines.append('  '.join(str(row[key]).ljust(width)
-                               for (_, key), width in zip(columns, widths)))
+                               for (_, key), width in zip(columns, widths, strict=False)))
     return '\n'.join(lines)
 
 

package/benchmarks/latency/live.py

@@ -42,7 +42,8 @@ def parse_args():
     parser.add_argument('--timeout', type=int, default=180,
                         help='seconds to wait for model positions (default: 180)')
     parser.add_argument('--json', action='store_true', help='print only the JSON report')
-    parser.add_argument('--no-save', action='store_true', help='do not append the local baseline ledger')
+    parser.add_argument('--no-save', action='store_true',
+                        help='do not append the local baseline ledger')
     parser.add_argument('--keep', action='store_true', help='keep the temporary city and logs')
     return parser.parse_args()
 
@@ -81,7 +82,7 @@ def main():
     os.symlink(os.path.join(ROOT, 'bin', 'agents-city.js'), os.path.join(tools, 'agents-city'))
     marker = f'CITY_NATIVE_{int(time.time())}_{os.getpid()}'
     actors = {runtime: f'{runtime}-agent' for runtime in selected}
-    for runtime, actor in actors.items():
+    for _runtime, actor in actors.items():
         repo = os.path.join(repos, actor)
         os.makedirs(repo)
         with open(os.path.join(repo, 'README.md'), 'w', encoding='utf-8') as stream:
@@ -227,7 +228,9 @@ def wait_ready(runtimes, actors, processes, streams, app, timeout):
         for runtime in runtimes:
             process = processes[runtime]
             if process.poll() is not None:
-                raise RuntimeError(f'{runtime} exited during startup: {tail(read_stream(streams[runtime]), 12)}')
+                raise RuntimeError(
+                    f'{runtime} exited during startup: '
+                    f'{tail(read_stream(streams[runtime]), 12)}')
             ready = ready and os.path.exists(
                 os.path.join(status_dir, f'{actors[runtime]}.json'))
         if ready:
@@ -256,7 +259,8 @@ def report_for(results, unavailable, thread, duration):
     return {
         'schema': 'agents-city/native-e2e-latency@1',
         'runAt': datetime.datetime.now(datetime.timezone.utc).isoformat(),
-        'scope': 'live task completion through bus, native provider protocol and committee position',
+        'scope': ('live task completion through bus, native provider protocol '
+                  'and committee position'),
         'thread': thread,
         'durationMs': duration,
         'results': results + unavailable,

package/benchmarks/stress/run.py

@@ -140,7 +140,8 @@ def run(args):
             raise RuntimeError('a Codex gateway exited during startup')
         startup_hubs = hub_pids(city)
         if len(startup_hubs) != 1:
-            raise RuntimeError(f'concurrent startup created {len(startup_hubs)} hubs: {startup_hubs}')
+            raise RuntimeError(
+                f'concurrent startup created {len(startup_hubs)} hubs: {startup_hubs}')
         report['startupMs'] = round((time.monotonic() - started) * 1000)
         report['startupHubProcesses'] = len(startup_hubs)
 
@@ -156,8 +157,11 @@ def run(args):
                 # recovery, not a stale endpoint. What must disappear is the
                 # stopped PID's ownership; the endpoint may validly already name
                 # the one new hub.
+                # Bound as a default: the lambda is called in this same
+                # iteration, so late binding does not bite — but correct by
+                # accident is not correct.
                 if not wait_for(
-                    lambda: endpoint_released_or_replaced(endpoint_path, stopped_pid), 4
+                    lambda pid=stopped_pid: endpoint_released_or_replaced(endpoint_path, pid), 4
                 ):
                     raise RuntimeError('the stopped hub still owns the endpoint')
             round_started = time.monotonic()
@@ -178,8 +182,8 @@ def run(args):
                     f'round {round_number} spectator feed did not represent all '
                     f'{args.agents} selected actors exactly once')
             if not wait_for(
-                lambda: round_complete(thread, claude_capture, codex_capture, metrics_path,
-                                       args.agents // 2, args.agents),
+                lambda t=thread: round_complete(t, claude_capture, codex_capture,
+                                                metrics_path, args.agents // 2, args.agents),
                 args.timeout,
             ):
                 raise RuntimeError(
@@ -197,7 +201,8 @@ def run(args):
                     f'Claude={claude_count}, Codex={codex_count}')
             if len(metrics) != args.agents:
                 raise RuntimeError(
-                    f'round {round_number} recorded {len(metrics)} acceptances, expected {args.agents}')
+                    f'round {round_number} recorded {len(metrics)} acceptances, '
+                    f'expected {args.agents}')
             latencies = sorted(int(row.get('totalToNativeAcceptMs', 0)) for row in metrics)
             round_report = {
                 'round': round_number,

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

@@ -28,6 +28,7 @@ sys.path.insert(0, AQUI)
 sys.path.insert(0, os.path.join(os.path.dirname(AQUI), 'plugin', 'scripts'))
 import serve  # noqa: E402
 import cities  # noqa: E402
+import runtime_processes  # noqa: E402  how a child is cut loose from a terminal
 
 def asegura_build():
     """hall.js, built if missing or older than its source. Same npm the map already
@@ -96,7 +97,7 @@ def despega(datos, abrir):
 
     subprocess.Popen(
         [sys.executable, os.path.join(AQUI, 'serve.py'), datos],
-        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True,
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, **runtime_processes.DESPEGADO,
     )
     limite = time.monotonic() + 25
     while time.monotonic() < limite:

package/bin/serve.py

@@ -45,6 +45,7 @@ import parcels  # noqa: E402
 import units  # noqa: E402
 import busca  # noqa: E402  the disk scanner, and the one list of where work lives
 import cities  # noqa: E402
+import multiplexor  # noqa: E402
 import diario  # noqa: E402  what happened, written down
 import demos  # noqa: E402  the recorded demos the Hall plays back
 import roads  # noqa: E402
@@ -277,7 +278,9 @@ def refresca_roster(ficha, datos):
         agentes = workspace.agentes(texto, datos)
     except (OSError, ValueError):
         return
-    card.cambia_agentes(ficha, [workspace.como_ficha(a) for a in agentes])
+    card.cambia_agentes(
+        ficha, [workspace.como_ficha(a, workspace.ajustes_de(texto, a.slug)) for a in agentes]
+    )
 
 
 def _crecimiento_cacheado(a, datos, vida=90):
@@ -402,26 +405,13 @@ def plugin_de_verdad():
 
 
 def ventanas_vivas(owner, datos):
-    """The window names alive in this city's tmux session, or nothing.
+    """The window names alive in this city's session, or nothing.
 
-    The `=` prefix asks tmux for an exact session match: bare `-t home` also
-    matches a session called `home-2`, and the green dot must never be lit by
-    a different city's windows."""
+    The exact-match form matters: tmux's bare `-t home` also matches a session
+    called `home-2`, and the green dot must never be lit by a different city's
+    windows. Which form that is belongs to the window server, not here."""
     try:
-        salida = subprocess.run(
-            [
-                "tmux",
-                "list-windows",
-                "-t",
-                "=" + cities.sesion(owner, datos),
-                "-F",
-                "#{window_name}",
-            ],
-            capture_output=True,
-            text=True,
-            timeout=3,
-        )
-        return set(salida.stdout.split()) if salida.returncode == 0 else set()
+        return set(multiplexor.ventanas(cities.sesion(owner, datos)))
     except (OSError, subprocess.SubprocessError):
         return set()
 
@@ -524,7 +514,7 @@ def lee_clave(fichero, clave, defecto=""):
     try:
         import re as _re
 
-        m = _re.search(rf"^{clave}:[ \t]*(.*)$", open(fichero).read(), _re.M)
+        m = _re.search(rf"^{clave}:[ \t]*(.*)$", open(fichero, encoding='utf-8').read(), _re.M)
         return (m.group(1).strip() if m else defecto) or defecto
     except OSError:
         return defecto
@@ -971,9 +961,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
                 c.pop("texto", None)
                 tarjetas.append(c)
         ps, lab, _ = parcels.lee(os.path.join(datos, "parcels.yml"))
-        sesiones = [
-            l.split(":")[0] for l in gh.sh(["tmux", "ls", "-F", "#{session_name}"]).splitlines()
-        ]
+        sesiones = multiplexor.sesiones()
         return self.responde(
             {
                 "datos": datos,
@@ -991,7 +979,19 @@ class Manejador(http.server.BaseHTTPRequestHandler):
                 "parcelas": ps,
                 "lab": sorted(lab),
                 "gh": gh.conectado(),
-                "tmux": sesiones,
+                # The window server, named on the wire rather than in the page.
+                # The Hall shows somebody the command to reattach to their own
+                # day, and that command belongs to whichever server is actually
+                # running the windows — so it is built from the same table the
+                # rest of the product drives it with, and the page prints what
+                # it is handed.
+                "mux": {
+                    "name": multiplexor.cual(),
+                    "sesiones": sesiones,
+                    "attach": " ".join(
+                        multiplexor.argv("attach", session=cities.sesion(owner, datos))
+                    ),
+                },
                 "plugin": plugin_de_verdad(),
                 "mapa": mapa_vivo(datos),
                 "sesion": cities.sesion(owner, datos),
@@ -1199,7 +1199,8 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         ficha_previa = os.path.join(datos, f"{quien}.md")
         try:
             texto_previo = card.lee(ficha_previa).get("texto") or ""
-            roster = [workspace.como_ficha(a) for a in workspace.agentes(texto_previo, datos)]
+            roster = [workspace.como_ficha(a, workspace.ajustes_de(texto_previo, a.slug))
+                      for a in workspace.agentes(texto_previo, datos)]
         except (OSError, ValueError):
             roster = []
         # Absent means unchanged, present means replace. This endpoint rewrites
@@ -1444,7 +1445,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             [guion, datos],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
-            start_new_session=True,
+            **runtime_processes.DESPEGADO,
         )
         return self.responde({"ok": True, "mapa": ""})
 
@@ -1466,7 +1467,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             ),
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
-            start_new_session=True,
+            **runtime_processes.DESPEGADO,
         )
         return self.responde(
             {"ok": True, "attach": f"tmux attach -t {cities.sesion(quien, datos)}"}
@@ -1543,7 +1544,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         # the new one joins them. Nothing that was working stops working. The
         # keys come from workspace, which owns what a roster looks like on a
         # card — the wizard writes the very same ones after its seven questions.
-        roster = [workspace.como_ficha(x) for x in ya]
+        roster = [workspace.como_ficha(x, workspace.ajustes_de(texto, x.slug)) for x in ya]
         roster.append(
             {"nombre": nombre, "slug": slug, "clase": clase, "rol": rol,
              "mounts": [], "motor": {}, "skills": []}