agents-city 0.3.0-beta.21 → 0.3.0

package/city/web/src/idioma.ts

@@ -0,0 +1,86 @@
+/**
+ * Two languages, one page.
+ *
+ * The READMEs shipped in Spanish and English from the start and the product did
+ * not, which is the wrong way round: a person reads the documentation once and
+ * lives in the interface every day. So the Hall speaks both.
+ *
+ * The dictionary is keyed by the ENGLISH sentence, not by an invented id. That
+ * matters here: an untranslated string falls back to the source and the page
+ * stays usable while coverage grows, instead of showing `hall.agents.title` to
+ * somebody. It also means the code still reads as English prose, so a
+ * contributor who speaks neither can follow it.
+ */
+
+type Diccionario = Record<string, string>;
+
+const ES: Diccionario = {};
+
+/**
+ * The lookup key: the source sentence with its whitespace flattened.
+ *
+ * A paragraph in a template literal is indented to match the code around it,
+ * and that indentation is invisible in HTML but fatal to an exact-match
+ * dictionary — every translated paragraph would have to be re-indented in
+ * lockstep with the file it came from. Flattening both sides means prose can be
+ * written where it reads best and translated as one line.
+ */
+function clave(fuente: string): string {
+  return fuente.replace(/\s+/g, ' ').trim();
+}
+
+/** Register translations. Split across files so each screen carries its own. */
+export function anota(pares: Diccionario): void {
+  for (const [fuente, texto] of Object.entries(pares)) ES[clave(fuente)] = texto;
+}
+
+type Lengua = 'es' | 'en';
+
+let ELEGIDO: Lengua | '' = '';
+
+/** The language showing right now: the stored choice, else this browser's. */
+export function idioma(): 'es' | 'en' {
+  if (ELEGIDO === 'es' || ELEGIDO === 'en') return ELEGIDO;
+  try {
+    const guardado = localStorage.getItem('hall-idioma');
+    if (guardado === 'es' || guardado === 'en') {
+      ELEGIDO = guardado;
+      return ELEGIDO;
+    }
+  } catch {
+    /* a browser with site data blocked still gets a working page */
+  }
+  const suyo = (navigator.language || 'en').toLowerCase();
+  ELEGIDO = suyo.startsWith('es') ? 'es' : 'en';
+  return ELEGIDO;
+}
+
+export function ponIdioma(cual: 'es' | 'en'): void {
+  ELEGIDO = cual;
+  try {
+    localStorage.setItem('hall-idioma', cual);
+  } catch {
+    /* not being able to remember it is not a reason to refuse the switch */
+  }
+  document.documentElement.lang = cual;
+}
+
+/**
+ * One string in the showing language.
+ *
+ * `t` takes the English source: `t('Your cities')`. Interpolation is by
+ * `{name}` placeholders so a translator can move them — Spanish does not put
+ * numbers and nouns where English does.
+ */
+export function t(fuente: string, valores?: Record<string, string | number>): string {
+  const texto = idioma() === 'es' ? (ES[clave(fuente)] ?? fuente) : fuente;
+  if (!valores) return texto;
+  return texto.replace(/\{(\w+)\}/g, (_, clave) =>
+    valores[clave] === undefined ? `{${clave}}` : String(valores[clave]),
+  );
+}
+
+/** Plural without a library: two forms, which is all these two languages need. */
+export function plural(n: number, una: string, varias: string): string {
+  return t(n === 1 ? una : varias, { n: String(n) });
+}

package/city/web/src/main.ts

@@ -50,7 +50,30 @@ import { Puertas } from './puertas';
 let COLOR: Record<string, number> = {};
 let BARRIOS: { id: string; nom: string; cols: number; nota?: string }[] = [];
 const COLOR_POR_DEFECTO = 0xc8b48a;
+//: The canvas behind the city, per skin.
+//:
+//: The map itself stays a night city in both: its buildings, shadows and
+//: asphalt are lit for a dark ground, and bleaching them would be a redesign
+//: rather than a palette swap. What day mode changes is the margin around the
+//: plan — it takes the ground's own colour, so a light Hall frames a deliberate
+//: viewport instead of leaving paper around a black island.
 const SUELO = 0x121821;
+const SUELO_CLARO = 0x0b1119;
+
+/** The Hall's theme message: the map is framed by it and must match its light. */
+function esTema(dato: unknown): dato is { type: string; theme: 'light' | 'dark' } {
+  const m = dato as { type?: unknown; theme?: unknown } | null;
+  return !!m && m.type === 'agents-city-map-theme/1' && (m.theme === 'light' || m.theme === 'dark');
+}
+
+function ponTema(cual: 'light' | 'dark'): void {
+  const suelo = cual === 'light' ? SUELO_CLARO : SUELO;
+  document.documentElement.dataset.tema = cual;
+  document.body.style.background = '#' + suelo.toString(16).padStart(6, '0');
+  // The renderer may not exist yet (the message can beat the boot); the body
+  // colour above already carries the skin until it does.
+  if (appGlobal) appGlobal.renderer.background.color = suelo;
+}
 
 interface Parcela {
   id: string;
@@ -175,6 +198,10 @@ window.addEventListener('message', (message) => {
     else configPendiente = message.data;
     return;
   }
+  if (esTema(message.data)) {
+    ponTema(message.data.theme);
+    return;
+  }
   if (!isMapActivityMessage(message.data)) return;
   const event = message.data.event;
   if (!isSpeechEvent(event) && !isPresenceEvent(event) && !event.kind.startsWith('committee.')) {

package/city/web/src/motores.ts

@@ -0,0 +1,54 @@
+/**
+ * What runs an agent: the provider, the engine and how hard it thinks.
+ *
+ * One list, imported by both the character sheet and the first-run guide. They
+ * used to be the sheet's private constants, which meant the guide could not ask
+ * the question at all — somebody built five houses and then went hunting for
+ * three dropdowns to set what they had already decided in their head. A curated
+ * list is never allowed to hold a card hostage, so `opciones` always keeps a
+ * value that is already written even when it is not one of these.
+ */
+
+export const RUNTIMES = ['claude', 'codex', 'opencode', 'kimi'];
+export const MODELOS = ['haiku', 'sonnet', 'opus', 'fable'];
+export const NIVEL_ESFUERZO: Record<string, number> = {
+  low: 1,
+  medium: 2,
+  high: 3,
+  xhigh: 4,
+  max: 5,
+};
+export const ESFUERZOS = Object.keys(NIVEL_ESFUERZO);
+
+/** `<option>`s from known values plus the current one when it is off the list. */
+export function opciones(
+  valores: string[],
+  actual: string,
+  esc: (s: unknown) => string,
+  porDefecto = 'default',
+): string {
+  return valores
+    .concat(actual && !valores.includes(actual) ? [actual] : [])
+    .map(
+      (v) =>
+        `<option value="${esc(v)}"${v === actual ? ' selected' : ''}>${esc(v || porDefecto)}</option>`,
+    )
+    .join('');
+}
+
+/** The engine's honest power reading. An alias maps to its tier; empty means
+ * the owner's default — unknown here, so it reads "default" rather than
+ * inventing a number. */
+export function nivelDeMotor(model: string): { ancho: number; texto: string; defecto: boolean } {
+  const alias = model.toLowerCase();
+  if (!alias) return { ancho: 0.5, texto: 'default', defecto: true };
+  for (const [clave, ancho] of [
+    ['fable', 1],
+    ['opus', 0.8],
+    ['sonnet', 0.55],
+    ['haiku', 0.35],
+  ] as const) {
+    if (alias.includes(clave)) return { ancho, texto: alias, defecto: false };
+  }
+  return { ancho: 0.6, texto: alias, defecto: false };
+}

package/docs/agents-first.md

@@ -31,7 +31,14 @@ what makes the map polymorphic instead of assuming everyone ships pull requests.
 `Agente`, so the launcher, the cage and the map read one model regardless of how
 the card was written.
 
-Legacy (unchanged — every repo is an agent whose single mount is that repo):
+**Read forever, written never.** The legacy shape below is still parsed by
+every door, so a city written a year ago opens today exactly as it did. Nothing
+writes it any more: the wizard and the Hall both produce the agent-first shape
+through `workspace.claves_de_roster`, because two writers of one fact is how the
+terminal and the web ended up able to produce different cities for the same
+city. Re-running `./bin/seat --agents` over an old card upgrades it in place.
+
+Legacy (still read — every repo is an agent whose single mount is that repo):
 
 ```yaml
 repos: [nova, store-service]

package/docs/security.md

@@ -14,18 +14,32 @@ credential to hold, and a signed trail of everything it tried.
 
 ## Layer 1 — the cage (`plugin/scripts/cage.py`)
 
-Claude, OpenCode and Kimi repo windows launch under a generated macOS seatbelt
-profile:
+Claude, OpenCode and Kimi agent windows launch confined by the kernel. Two
+mechanisms, one meaning — and the meaning is what `cage.py` owns, so the
+launcher asks for a prefix and never learns which kernel it is on:
 
 ```
-sandbox-exec -f ~/.agents-city/.runtime/cage/<window>.sb <runtime …>
+macOS   sandbox-exec -f ~/.agents-city/.runtime/cage/<window>.sb <runtime …>
+Linux   bwrap --ro-bind / / … --tmpfs ~/.ssh … <runtime …>
 ```
 
-The profile reads top to bottom: allow everything, deny all writes, re-allow
-the working set, then seal the secrets — reads and writes both. The semantics
-(last matching rule wins; children and grandchildren inherit) were verified on
-a real machine before a line of it was written, and `bin/test-cage.py` re-proves
-them live on every run where seatbelt exists.
+On macOS the profile reads top to bottom: allow everything, deny all writes,
+re-allow the working set, then seal the secrets — reads and writes both. The
+semantics (last matching rule wins; children and grandchildren inherit) were
+verified on a real machine before a line of it was written.
+
+On Linux the same shape is expressed as mounts, applied in the same order and
+with the same last-one-wins rule: the whole filesystem read-only, the working
+set re-bound writable, each sealed directory replaced by an empty tmpfs, each
+sealed file replaced by `/dev/null`, and finally this window's own broker token
+re-admitted read-only. A sealed path is not refused — it is *not there*.
+
+Availability is checked by doing, not by looking: `bwrap_sirve()` builds a real
+namespace once and remembers the answer, because Ubuntu 24's AppArmor policy and
+hardened kernels can refuse unprivileged user namespaces even with bubblewrap
+installed. Where the cage cannot run, the launcher says so and starts uncaged —
+the behaviour the product always had. `bin/test-cage.py` re-proves both cages
+live: seatbelt on every macOS run, bubblewrap on every Linux run.
 
 Inside the cage a window **can**: work freely in its own repo, run builds,
 reach the network, keep its runtime state (`~/.claude`, `~/.codex`,
@@ -33,10 +47,30 @@ reach the network, keep its runtime state (`~/.claude`, `~/.codex`,
 
 Inside the cage a window **cannot**: read or write `~/.ssh`, `~/.aws`,
 `~/.kube`, `~/.gnupg`, `~/.docker`, `~/.config/gcloud`, `~/.config/gh`,
-`~/.git-credentials`, `~/.netrc`, `~/.pgpass`, cargo credentials, any remote
-road `.env` under `~/.claude/channels/`, or the broker's state; nor write
-anywhere outside its repo and the allowed runtime/cache set — other repos on
-the machine included.
+`~/.git-credentials`, `~/.netrc`, `~/.pgpass`, cargo credentials,
+`~/.claude/.credentials.json`, any remote road `.env` under
+`~/.claude/channels/`, or the broker's state; nor write anywhere outside its
+repo and the allowed runtime/cache set — other repos on the machine included.
+
+`~/.claude/.credentials.json` earns its own line because it is the one this
+product created: `~/.claude` stays writable for runtime state, and outside
+macOS there is no Keychain, so Claude Code writes its OAuth tokens there as
+plain JSON. Every third-party credential store was sealed while ours was not,
+which is the sort of hole that only a review looking for it finds.
+
+### Where the two cages differ, exactly
+
+They seal the same set, and both are re-proved live on every CI run — seatbelt
+on macOS, bubblewrap on Linux. One difference is real and worth knowing:
+
+macOS states the road-token rule as a **pattern** (`channels/*/.env`), so a
+road created after the window started is sealed too. Linux states it as one
+**mount per file**, and a mount needs a path that exists — so a road opened
+mid-session is not sealed inside windows that were already running. It is
+sealed for every window started afterwards, and closing and reopening the city
+closes the gap. The alternative — hiding the whole `channels` directory — would
+also hide what the in-window hooks legitimately read, so this stays a known,
+bounded difference rather than a silent one.
 
 Dials, all environment variables read at launch:
 

package/docs/testing.md

@@ -149,7 +149,7 @@ temporary prefix before touching a global installation:
 ```bash
 npm pack
 PREFIX=$(mktemp -d)
-npm install -g --prefix "$PREFIX" ./agents-city-0.3.0-beta.21.tgz
+npm install -g --prefix "$PREFIX" ./agents-city-*.tgz
 "$PREFIX/bin/agents-city" --version
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-city",
-  "version": "0.3.0-beta.21",
+  "version": "0.3.0",
   "description": "Run autonomous agent cities: one chair seat, role-aware repo agents, repo-owned skills, and explicit roads.",
   "bin": {
     "agents-city": "bin/agents-city.js"

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "city",
   "displayName": "Agents City",
-  "version": "0.3.0-beta.21",
+  "version": "0.3.0",
   "description": "One autonomous city seat with a work domain, role, goal, repo support agents, recognised skills and explicit roads to other cities.",
   "author": {
     "name": "jlcases",

package/plugin/channel/bus.js

@@ -20100,7 +20100,7 @@ try {
 }
 var chair = Boolean(context && context.actors[actor]?.role === "chair" && actor === "seat");
 var server = new Server(
-  { name: "agents-city-bus", version: "0.3.0-beta.21" },
+  { name: "agents-city-bus", version: "0.2.1" },
   {
     capabilities: {
       ...channelEnabled ? { experimental: { "claude/channel": {} } } : {},

package/plugin/channel/bus.ts

@@ -24,7 +24,7 @@ try {
 
 const chair = Boolean(context && context.actors[actor]?.role === 'chair' && actor === 'seat');
 const server = new Server(
-  { name: 'agents-city-bus', version: '0.3.0-beta.21' },
+  { name: 'agents-city-bus', version: '0.2.1' },
   {
     capabilities: {
       ...(channelEnabled ? { experimental: { 'claude/channel': {} } } : {}),

package/plugin/channel/runtime/codex.ts

@@ -67,7 +67,7 @@ export class CodexConnector implements RuntimeConnector {
       async (method, params) => this.providerRequest(method, params),
     );
     await this.rpc.request('initialize', {
-      clientInfo: { name: 'agents-city', title: 'Agents City', version: '0.3.0-beta.21' },
+      clientInfo: { name: 'agents-city', title: 'Agents City', version: '0.2.1' },
       capabilities: { experimentalApi: true },
     });
     await this.rpc.notify('initialized');

package/plugin/channel/runtime-gateway.js

@@ -4894,7 +4894,7 @@ var CodexConnector = class {
       async (method, params) => this.providerRequest(method, params)
     );
     await this.rpc.request("initialize", {
-      clientInfo: { name: "agents-city", title: "Agents City", version: "0.3.0-beta.21" },
+      clientInfo: { name: "agents-city", title: "Agents City", version: "0.2.1" },
       capabilities: { experimentalApi: true }
     });
     await this.rpc.notify("initialized");

package/plugin/scripts/actualiza.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Knowing there is a new version, and getting it.
+
+A tool that cannot tell you it is out of date leaves every owner running
+whatever they installed the day they found it — including the day a security
+fix shipped. So this asks npm, and it asks rarely: once a day at most, cached
+under the runtime dir, and never on a plain command. The check runs where the
+person deliberately opened something (`doctor`, `update`, the Hall), not behind
+their back on every `agents-city cities`.
+
+It is a GET to the public registry and nothing else: no identifiers, no
+counters, nothing about this machine leaves it. `CITY_UPDATE_CHECK=0` turns it
+off completely, and the answer is cached so a plane, a firewall or a dead
+registry degrade to silence rather than to an error.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+
+GUIONES = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, GUIONES)
+import cities  # noqa: E402
+
+PAQUETE = 'agents-city'
+REGISTRO = f'https://registry.npmjs.org/{PAQUETE}/latest'
+#: A day. The point is to notice a release, not to poll a registry.
+VIDA = 24 * 3600
+
+
+def version_instalada():
+    """What is running right now, read from the package this file ships in."""
+    raiz = os.path.dirname(os.path.dirname(GUIONES))
+    try:
+        with open(os.path.join(raiz, 'package.json'), encoding='utf-8') as f:
+            return str(json.load(f).get('version') or '')
+    except (OSError, ValueError):
+        return ''
+
+
+def _cache():
+    return os.path.join(cities.raiz(), '.runtime', 'version.json')
+
+
+def _lee_cache():
+    try:
+        with open(_cache(), encoding='utf-8') as f:
+            return json.load(f)
+    except (OSError, ValueError):
+        return {}
+
+
+def _guarda_cache(ultima):
+    ruta = _cache()
+    try:
+        os.makedirs(os.path.dirname(ruta), mode=0o700, exist_ok=True)
+        cities.escribe_atomico(ruta, json.dumps({'latest': ultima, 'when': time.time()}))
+    except OSError:
+        pass  # not being able to remember is not a reason to fail a command
+
+
+def consulta_registro(timeout=8):
+    """The published version, or '' when the network says nothing useful.
+
+    Eight seconds because the first call of the day pays DNS and a TLS
+    handshake from cold; a tighter budget turns "you are up to date" into a
+    lie told by a stopwatch.
+    """
+    try:
+        peticion = urllib.request.Request(
+            REGISTRO, headers={'Accept': 'application/vnd.npm.install-v1+json'}
+        )
+        with urllib.request.urlopen(peticion, timeout=timeout) as r:
+            return str(json.load(r).get('version') or '')
+    except (urllib.error.URLError, OSError, ValueError, TimeoutError):
+        return ''
+
+
+def _partes(v):
+    """A version as comparable pieces. A prerelease sorts BELOW its release."""
+    base, _, pre = str(v).partition('-')
+    numeros = []
+    for trozo in base.split('.'):
+        try:
+            numeros.append(int(trozo))
+        except ValueError:
+            numeros.append(0)
+    while len(numeros) < 3:
+        numeros.append(0)
+    # No prerelease outranks one: 1.0.0 > 1.0.0-beta.1, as semver says.
+    return (numeros[0], numeros[1], numeros[2], 1 if not pre else 0, pre)
+
+
+def es_mas_nueva(candidata, actual):
+    return bool(candidata) and bool(actual) and _partes(candidata) > _partes(actual)
+
+
+def comprueba(forzar=False, vida=VIDA):
+    """(installed, published, there-is-an-update). Cached, quiet, opt-out-able.
+
+    Returns the published version as '' when the check is switched off or the
+    registry could not be reached — the caller then says nothing, which is the
+    right thing to say when you do not know.
+    """
+    instalada = version_instalada()
+    if os.environ.get('CITY_UPDATE_CHECK', '1') == '0':
+        return instalada, '', False
+    guardado = _lee_cache()
+    fresca = (time.time() - float(guardado.get('when') or 0)) < vida
+    if fresca and not forzar:
+        ultima = str(guardado.get('latest') or '')
+    else:
+        ultima = consulta_registro()
+        if ultima:
+            _guarda_cache(ultima)
+        else:
+            ultima = str(guardado.get('latest') or '')
+    return instalada, ultima, es_mas_nueva(ultima, instalada)
+
+
+def aviso():
+    """One line for a person who did not ask, or '' when there is nothing to say."""
+    instalada, ultima, hay = comprueba()
+    if not hay:
+        return ''
+    return (f'  A newer Agents City is out: {instalada} → {ultima}. '
+            f'Update with: agents-city update')
+
+
+def como_se_instalo():
+    """'npm' when this copy lives inside a global npm install, else 'clone'.
+
+    It decides what `update` may do: pulling somebody's git checkout from under
+    them is not an update, it is a surprise.
+    """
+    raiz = os.path.dirname(os.path.dirname(GUIONES))
+    if os.path.isdir(os.path.join(raiz, '.git')):
+        return 'clone'
+    return 'npm' if f'node_modules{os.sep}{PAQUETE}' in raiz else 'clone'
+
+
+def actualiza(canal=''):
+    """Install the newest published version over this one. Returns an exit code."""
+    if como_se_instalo() == 'clone':
+        print('  This is a git checkout, not an npm install.\n'
+              '  Update it the way you got it:\n'
+              '    git pull && npm pack && npm install -g ./agents-city-*.tgz')
+        return 1
+    destino = f'{PAQUETE}@{canal}' if canal else PAQUETE
+    print(f'  Installing {destino} over {version_instalada()}…')
+    hecho = subprocess.run(['npm', 'install', '-g', destino])
+    if hecho.returncode != 0:
+        print('  npm could not install it. Nothing was changed.', file=sys.stderr)
+        return hecho.returncode
+    print('  Done. Open cities keep the code they already loaded;\n'
+          '  `agents-city exit <city>` and then `agents-city seat` picks the new one up.')
+    return 0
+
+
+def _uso():
+    print(
+        '  usage: agents-city update [--check] [--tag beta]\n\n'
+        '  Install the newest published version, or just ask whether there is one.\n\n'
+        '    --check      say what is installed and what is published, and stop\n'
+        '    --tag NAME   follow a dist-tag (for example: beta)\n\n'
+        '  The check is one GET to the public npm registry, cached for a day.\n'
+        '  Nothing about this machine is sent. CITY_UPDATE_CHECK=0 disables it.'
+    )
+
+
+def main():
+    args = sys.argv[1:]
+    if any(a in ('-h', '--help', 'help') for a in args):
+        _uso()
+        return 0
+    if '--check' in args:
+        instalada, ultima, hay = comprueba(forzar=True)
+        if not ultima:
+            print(f'  Installed: {instalada}. The registry could not be reached '
+                  '(or the check is off).')
+            return 0
+        print(f'  Installed: {instalada}\n  Published: {ultima}')
+        print('  There is a newer version — agents-city update' if hay
+              else '  You are up to date.')
+        return 0
+    canal = ''
+    if '--tag' in args:
+        i = args.index('--tag')
+        canal = args[i + 1] if len(args) > i + 1 else ''
+    return actualiza(canal)
+
+
+if __name__ == '__main__':
+    sys.exit(main())