agents-city 0.5.2 → 0.5.4

package/bin/test-contracts.py

@@ -269,6 +269,46 @@ def conciencia_acotada():
 
 
 # ══ the demo is a city this code would write ═════════════════════════════════
+# ══ the shell has to run on somebody else's bash ═════════════════════════════
+def bash_que_no_es_la_de_macos():
+    """Shell that only bash 3.2 accepts is shell that only works on macOS.
+
+    `${#array[@]-0}` is the trap that got through: bash 3.2 — the one Apple has
+    shipped since 2007, and the reason this repo writes `${a[@]+"${a[@]}"}`
+    everywhere — accepts it, and every bash from 4.4 on refuses it as a bad
+    substitution. So a message printed here and never on Linux, silently, because
+    the error goes to stderr and the script does not stop. It sat in the launcher
+    for months: nothing read stderr until a test did.
+
+    A declared array needs no default. `a=()` already answers 0 under `set -u`;
+    only an UNDECLARED name is unbound, and the fix for that is to declare it.
+
+    shellcheck does not flag this at any severity, which is why it is here.
+    """
+    print('  shell that runs on a bash newer than 2007')
+    trampa = re.compile(r'\$\{#[A-Za-z_][A-Za-z0-9_]*\[[@*]\][-:+]')
+    ficheros = sorted(glob.glob(os.path.join(RAIZ, 'plugin', '**', '*.sh'), recursive=True))
+    ficheros += sorted(glob.glob(os.path.join(RAIZ, 'bus', 'scripts', '*.sh')))
+    culpables = []
+    for ruta in ficheros:
+        with open(ruta, encoding='utf-8') as f:
+            for n, linea in enumerate(f, 1):
+                # A comment may name the trap — the tombstone in the launcher does.
+                if linea.lstrip().startswith('#'):
+                    continue
+                if trampa.search(linea):
+                    culpables.append(f'{os.path.relpath(ruta, RAIZ)}:{n}')
+    afirma('· no shipped script uses a length expansion with a default',
+           not culpables,
+           '${#a[@]-0} is a macOS-only illusion: ' + ', '.join(culpables))
+    # And the idiom that IS portable stays in use, so this does not read as a
+    # rule against defaults in general.
+    lanzador = open(os.path.join(RAIZ, 'plugin/scripts/city-session.sh'),
+                    encoding='utf-8').read()
+    afirma('· and empty arrays are still expanded the way bash 3.2 needs',
+           '[@]+"${' in lanzador, '')
+
+
 def demo_coherente():
     print('  the demo agrees with the code')
     for f in sorted(glob.glob(os.path.join(RAIZ, 'demo', '*.md'))):
@@ -462,6 +502,49 @@ def asiento_con_su_arnes():
     shutil.rmtree(casa, ignore_errors=True)
 
 
+def el_aviso_lee_lo_que_viaja():
+    """What the roster carries has to be what the judgement reads.
+
+    The circuit is three pieces and it is only worth the sum if all three are
+    wired: a city publishes its role and its remit, the roster serves them, and
+    the thing that decides "does this reach anybody" reads THAT rather than a
+    local copy of a catalogue. Build the first two and leave the third pointing
+    at local files and you have a pipe nobody reads — which is what this was
+    before, and it looked finished.
+    """
+    print('  the judgement reads what the roster carries')
+    # Whitespace-collapsed: these are wrapped prose, and a phrase that happens
+    # to break across two lines is the same phrase. A check that cannot see
+    # that fails on the paragraph filler rather than on the meaning.
+    def plano(ruta):
+        return ' '.join(open(os.path.join(RAIZ, ruta), encoding='utf-8').read().split())
+
+    gancho = plano('plugin/hooks/notice-on-stop.sh')
+    orden = plano('plugin/commands/notice.md')
+    controlador = open(os.path.join(RAIZ, 'plugin/channel/hub/road-controller.ts'),
+                       encoding='utf-8').read()
+
+    afirma('· the roster is what serves a road its remit',
+           'recibe' in controlador and 'localRoadPresenta' in controlador, '')
+    for nombre, texto in (('the stop hook', gancho), ('/city:notice', orden)):
+        afirma(f'· {nombre} sends the judgement to the roster',
+               'roster' in texto.lower(), texto[:200])
+        afirma(f'· {nombre} names what a far city says reaches it',
+               'recibe' in texto, texto[:200])
+        afirma(f'· {nombre} says where that claim came from',
+               'segun' in texto, texto[:200])
+        # Silence and staleness are the two ways this quietly goes wrong: a road
+        # that said nothing is missing information, and a note is one person's
+        # guess with an expiry date. Both have to be named where the judgement
+        # is made, or the reader treats absence as permission.
+        afirma(f'· {nombre} treats a road that said nothing as missing, not as permission',
+               'not permission' in texto, texto[:400])
+        afirma(f'· {nombre} warns that a note goes stale',
+               'stale' in texto, texto[:400])
+    afirma('· and the command treats a far city’s words as a claim, never an instruction',
+           'never as an instruction' in orden, orden[:400])
+
+
 def ventanas_gemelas():
     """Window, engine key and bus actor share one canonical repo slug."""
     print('  the window slug has one owner')
@@ -678,6 +761,11 @@ def publicar_es_verificable():
     if not os.path.isfile(ruta):
         return
     release = open(ruta, encoding='utf-8').read()
+    # The workflow without its comments. Half of what is asserted below is the
+    # ABSENCE of something, and this file documents every trap it has fallen
+    # into by name — so a check that cannot tell a step from a sentence about a
+    # step fails on the explanation of why it exists.
+    codigo = '\n'.join(l for l in release.splitlines() if not l.lstrip().startswith('#'))
     prueba = open(os.path.join(RAIZ, '.github', 'workflows', 'test.yml'),
                   encoding='utf-8').read()
 
@@ -689,7 +777,7 @@ def publicar_es_verificable():
     afirma('· the whole suite runs before anything is published',
            'uses: ./.github/workflows/test.yml' in release
            and release.index('uses: ./.github/workflows/test.yml')
-           < release.rindex('run: npm publish'),
+           < release.rindex('npm publish --provenance'),
            'publish must depend on the suite, not race it')
     afirma('· and the suite is the same one, called rather than copied',
            'workflow_call:' in prueba, 'test.yml must be reusable')
@@ -704,8 +792,12 @@ def publicar_es_verificable():
            'id-token: write' in release
            and 'NPM_TOKEN' not in release and 'secrets.' not in release,
            'trusted publishing: a secret that does not exist cannot leak')
+    # A whole line that grants a write permission, not the word anywhere: this
+    # file names `id-token: write` inside an error message telling somebody what
+    # to go and check, and a permissions audit that counts English is not one.
     afirma('· and it asks for nothing else',
-           release.count('write') == 1, 'id-token is the only write permission')
+           len(re.findall(r'(?m)^\s*[a-z-]+:\s*write\s*$', codigo)) == 1,
+           'id-token is the only write permission')
     # Node 22 bundles npm 10, which cannot exchange an OIDC token and so
     # publishes UNAUTHENTICATED — the registry answers 404, which reads like a
     # missing package and is really a missing credential. It cost one release
@@ -715,6 +807,38 @@ def publicar_es_verificable():
            'trusted publishing needs npm >= 11.5.1; setup-node gives 10.x')
     afirma('· and it refuses to publish with an older one rather than trying',
            'process.exit(1)' in release, release)
+    # And an npm new enough is still not enough if something already handed it a
+    # credential, because a credential is how the OIDC exchange gets SKIPPED.
+    # `setup-node`'s `registry-url` looks like the line that points npm at
+    # npmjs.com; what it does is write `_authToken=${NODE_AUTH_TOKEN}` into an
+    # .npmrc and export NODE_AUTH_TOKEN as the literal `XXXXX-XXXXX-XXXXX-XXXXX`.
+    # npm then publishes authenticated as a string of X's and the registry
+    # answers the same 404 it answers a stranger. It cost the second release.
+    afirma('· and nothing hands npm a credential of its own before it asks',
+           'registry-url' not in codigo and 'NODE_AUTH_TOKEN' not in codigo,
+           'setup-node registry-url writes a placeholder token that skips the OIDC exchange')
+    afirma('· which is checked in the run rather than inferred from a 404',
+           '_authToken' in codigo
+           and codigo.index('_authToken') < codigo.rindex('npm publish --provenance'),
+           'the registry says "not found" when it means "not allowed"')
+    # Having no credential is only half of it: npm has to be able to GET one,
+    # and it only tries when GitHub has injected an OIDC endpoint into the job.
+    # Without one npm does not try, does not say it is not trying, and fails at
+    # the end with "you need to log in" — which sounds like a forgotten password
+    # and is a job that was never given an identity to trade.
+    afirma('· and it names the registry it means to be recognised at',
+           'npm config set registry https://registry.npmjs.org/' in codigo
+           and codigo.index('npm config set registry')
+           < codigo.rindex('npm publish --provenance'),
+           'npm offers an OIDC token only for a registry it recognises as decided')
+    afirma('· and a refusal has to explain itself in the log',
+           '--loglevel verbose' in codigo,
+           'ENEEDAUTH twice with no reason is a workflow that cannot be debugged remotely')
+    publica = codigo.rindex('npm publish --provenance')
+    afirma('· and the identity it means to trade is proved to exist first',
+           'ACTIONS_ID_TOKEN_REQUEST_URL' in codigo
+           and codigo.index('ACTIONS_ID_TOKEN_REQUEST_URL') < publica,
+           'a missing OIDC endpoint must fail by name, not as ENEEDAUTH ten steps later')
     # prepublishOnly rebuilds and re-runs the whole suite. By hand that is the
     # only safety net; here the suite has already run on three platforms and
     # byte-compared the artifacts, so a fourth run verifies nothing and can
@@ -728,7 +852,7 @@ def publicar_es_verificable():
     # map and no Hall bundle: 447 files instead of 503.
     afirma('· but it still builds the gitignored half of the package',
            'run: npm run build' in release
-           and release.index('run: npm run build') < release.rindex('run: npm publish'),
+           and release.index('run: npm run build') < release.rindex('npm publish --provenance'),
            'a publish with no build ships no front end')
     afirma('· and checks the front end is in the tarball before sending it',
            'city/web/dist/index.html' in release and 'city/web/dist-hall/hall.js' in release,
@@ -747,8 +871,10 @@ def main():
     una_definicion()
     rutas_reales()
     conciencia_acotada()
+    bash_que_no_es_la_de_macos()
     demo_coherente()
     varias_ciudades()
+    el_aviso_lee_lo_que_viaja()
     ventanas_gemelas()
     motor_para_todos()
     asiento_con_su_arnes()

package/bin/test-e2e.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+"""One city, from nothing to a refusal, through the doors a person actually uses.
+
+Every other suite here proves one piece: the Hall's endpoint writes the card,
+the launcher builds the right command, the guard judges a path, the journal
+records a line. Each of them stubs its neighbours, and that is what makes them
+fast and precise — and it is also how a product ends up with every part working
+and the whole thing broken at the seams. The two bugs this release fixes were
+both seam bugs. Adding a house wrote the frontmatter and not the body: two
+correct writers, one incoherent card. Adding a house to a RUNNING city wrote the
+card and never touched tmux: a correct endpoint and a correct launcher that had
+never met.
+
+So this one stubs nothing it can avoid. A real HTTP server over a real socket. A
+real `agents-city cities create`. The real `city-session.sh` against a real tmux
+server on a private socket. The real hook binary, over stdin, with the
+environment THE LAUNCHER ITSELF wrote — not one composed here, because "the
+launcher tells the window where its city is" is exactly the kind of fact a
+hand-made fixture will keep asserting long after it stops being true. And the
+journal read back through the API, so the write and the read resolve the city
+the same way.
+
+The story it walks, once, in order:
+
+    create a city → write its seat → add a house → mount its ground → open the
+    session → add a SECOND house while the city is running → open it again and
+    watch it reconcile → have the chair reach into somebody's repo → be refused,
+    by name → find the refusal in the journal → let the owner open the chair's
+    hands → watch the same call go through.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+import urllib.error
+import urllib.request
+
+AQUI = os.path.dirname(os.path.abspath(__file__))
+RAIZ = os.path.dirname(AQUI)
+sys.path.insert(0, AQUI)
+sys.path.insert(0, os.path.join(RAIZ, "plugin", "scripts"))
+
+import serve  # noqa: E402
+from testlib import afirma, comprueba, detiene_hubs_de_ciudad, resumen  # noqa: E402
+
+SESION = os.path.join(RAIZ, "plugin", "scripts", "city-session.sh")
+GANCHO = os.path.join(RAIZ, "plugin", "hooks", "ask-the-house.sh")
+
+
+# ── the doors, each one real ─────────────────────────────────────────────────
+
+
+def pide(puerto, ruta, metodo="GET", cuerpo=None):
+    url = f"http://127.0.0.1:{puerto}{ruta}"
+    url += ("&" if "?" in ruta else "?") + "PASE=" + serve.PASE
+    req = urllib.request.Request(
+        url, method=metodo, data=json.dumps(cuerpo).encode() if cuerpo is not None else None
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return r.status, json.loads(r.read() or b"{}")
+    except urllib.error.HTTPError as e:
+        try:
+            return e.code, json.loads(e.read() or b"{}")
+        except ValueError:
+            return e.code, {}
+
+
+class Mundo:
+    """One machine's worth of isolation: its own app home, tmux server and PATH."""
+
+    def __init__(self):
+        self.base = os.path.realpath(tempfile.mkdtemp(prefix="agents-city-e2e-"))
+        self.hogar = os.path.join(self.base, "app")
+        self.tmux = os.path.join(self.base, "tmux")
+        self.repo = os.path.join(self.base, "codigo", "api")
+        self.papeles = os.path.join(self.base, "papeles", "manual")
+        for d in (self.hogar, self.tmux, os.path.join(self.repo, "app"), self.papeles):
+            os.makedirs(d, exist_ok=True)
+        open(os.path.join(self.repo, "app", "router.rb"), "w").write("# routes\n")
+        open(os.path.join(self.papeles, "guia.md"), "w").write("# guide\n")
+        self.datos = ""
+
+    @property
+    def entorno(self):
+        e = dict(os.environ)
+        e.update({
+            "HOME": self.base,
+            "AGENTS_CITY_HOME": self.hogar,
+            "AGENTS_CITY_USER": "e2e",
+            "TMUX_TMPDIR": self.tmux,
+            "CITY_SEARCH_IN": self.base,
+            "XDG_CACHE_HOME": os.path.join(self.base, "cache"),
+        })
+        if self.datos:
+            e["AGENTS_CITY_DATA"] = self.datos
+        return e
+
+    def corre(self, *orden, **extra):
+        env = self.entorno
+        env.update(extra)
+        return subprocess.run(
+            list(orden), capture_output=True, text=True, env=env, cwd=self.base, timeout=180
+        )
+
+    def ventanas(self, sesion):
+        r = self.corre("tmux", "list-windows", "-t", sesion, "-F", "#W")
+        return [x for x in r.stdout.split() if x]
+
+    def paneles(self, sesion):
+        r = self.corre("tmux", "list-panes", "-a", "-t", sesion, "-F", "#W\t#{pane_id}")
+        fuera = {}
+        for linea in r.stdout.splitlines():
+            if "\t" in linea:
+                ventana, panel = linea.split("\t", 1)
+                fuera.setdefault(ventana, panel)
+        return fuera
+
+    def entorno_de_la_sesion(self, sesion):
+        """What the launcher told the session. Read back from tmux, not composed."""
+        r = self.corre("tmux", "show-environment", "-t", sesion)
+        fuera = {}
+        for linea in r.stdout.splitlines():
+            if "=" in linea and not linea.startswith("-"):
+                k, v = linea.split("=", 1)
+                fuera[k] = v
+        return fuera
+
+    def limpia(self):
+        self.corre("tmux", "kill-server")
+        if self.datos:
+            detiene_hubs_de_ciudad(self.datos)
+        shutil.rmtree(self.base, ignore_errors=True)
+
+
+def abre_la_sesion(mundo, usuario="e2e"):
+    """The real launcher. It ends in `tmux attach`, which cannot succeed with no
+    terminal — the windows are built by then, which is what the Hall relies on
+    when it opens a city from the browser."""
+    return mundo.corre("bash", SESION, usuario)
+
+
+def llama_al_gancho(mundo, sesion, herramienta, entrada, **extra):
+    """One tool call through the real hook, in the environment the launcher wrote.
+
+    The seat's own identity (`CITY_BUS_ACTOR=seat`) is the one value added here:
+    the launcher writes it in front of the runtime's command line rather than
+    into the session, so tmux cannot hand it back. Everything else — which city,
+    which home, which owner — comes from what the launcher actually set.
+    """
+    env = dict(mundo.entorno)
+    env.pop("AGENTS_CITY_DATA", None)
+    env.update(mundo.entorno_de_la_sesion(sesion))
+    env["CITY_BUS_ACTOR"] = "seat"
+    env["CLAUDE_PLUGIN_ROOT"] = os.path.join(RAIZ, "plugin")
+    env.update(extra)
+    r = subprocess.run(
+        ["/bin/bash", GANCHO],
+        input=json.dumps({"tool_name": herramienta, "tool_input": entrada, "cwd": mundo.datos}),
+        capture_output=True, text=True, env=env, timeout=60,
+    )
+    try:
+        return json.loads(r.stdout or "{}"), r
+    except ValueError:
+        return {}, r
+
+
+def decision(salida):
+    return (salida.get("hookSpecificOutput") or {}).get("permissionDecision", "")
+
+
+def motivo(salida):
+    return (salida.get("hookSpecificOutput") or {}).get("permissionDecisionReason", "")
+
+
+# ── the story ────────────────────────────────────────────────────────────────
+
+
+def main():
+    print("\n  one city, end to end")
+    if not shutil.which("tmux"):
+        afirma("· tmux is available", False, "tmux missing")
+        return resumen("e2e")
+
+    mundo = Mundo()
+    servidor = serve.Servidor(("127.0.0.1", 0), serve.Manejador)
+    puerto = servidor.server_port
+    threading.Thread(target=servidor.serve_forever, daemon=True).start()
+    previo = {k: os.environ.get(k) for k in
+              ("AGENTS_CITY_DATA", "AGENTS_CITY_HOME", "AGENTS_CITY_USER",
+               "CITY_SEARCH_IN", "XDG_CACHE_HOME", "HOME")}
+    registro_previo = serve.cities.REGISTRO
+    serve.cities.REGISTRO = os.path.join(mundo.base, "registro", "cities")
+
+    try:
+        # ── 1. a city, through its own door ──────────────────────────────────
+        print("  a city, a seat, a house")
+        r = mundo.corre(sys.executable, os.path.join(RAIZ, "plugin", "scripts", "cities.py"),
+                        "create", "home")
+        mundo.datos = os.path.join(mundo.hogar, "e2e", "home")
+        afirma(
+            "· `cities create` builds a city where a city goes",
+            r.returncode == 0 and os.path.isfile(os.path.join(mundo.datos, "city.yml")),
+            f"{r.stdout}{r.stderr}",
+        )
+        # The Hall serves whatever AGENTS_CITY_DATA points at; this process is
+        # the server, so it has to be told too.
+        os.environ.update({k: v for k, v in mundo.entorno.items() if k in previo})
+
+        # ── 2. the seat, through the Hall ────────────────────────────────────
+        st, _ = pide(puerto, "/api/ficha", metodo="POST",
+                     cuerpo={"role": "cpto", "domain": "software"})
+        ficha = os.path.join(mundo.datos, "e2e.md")
+        afirma("· the browser writes the owner card", st == 200 and os.path.isfile(ficha),
+               f"{st}")
+
+        # ── 3. a house, and the ground it works ─────────────────────────────
+        st, _ = pide(puerto, "/api/agentes", metodo="POST",
+                     cuerpo={"name": "api", "kind": "code", "role": "dev"})
+        comprueba("· and adds a house to it", st, 200)
+        # The frontmatter is what the launcher and the cage read; the body is
+        # what the SEAT reads. Both, or the city and its own chair disagree.
+        cuerpo_carta = open(ficha, encoding="utf-8").read().split("## Agents", 1)[-1]
+        cuerpo_carta = cuerpo_carta.split("## ", 1)[0]
+        afirma(
+            "· in the half the launcher reads and the half the seat reads",
+            "`api`" in cuerpo_carta and "0 mounts" in cuerpo_carta,
+            cuerpo_carta[:300],
+        )
+        st, montado = pide(puerto, "/api/montaje", metodo="POST",
+                           cuerpo={"agent": "api", "add": mundo.repo})
+        carta = open(ficha, encoding="utf-8").read()
+        cuerpo_carta = carta.split("## Agents", 1)[-1].split("## ", 1)[0]
+        afirma(
+            "· and the ground it works lands on disk and on the card, in both too",
+            st == 200
+            and any(m["target"] == mundo.repo for m in montado.get("mounts", []))
+            and "mounts.api:" in carta
+            and "1 mount." in cuerpo_carta,
+            carta,
+        )
+
+        # ── 4. open the city ────────────────────────────────────────────────
+        print("  and then it is opened, and changed while it is open")
+        abre_la_sesion(mundo)
+        sesion = serve.cities.sesion("e2e", mundo.datos)
+        ventanas = mundo.ventanas(sesion)
+        afirma("· the session opens with the chair and the house",
+               "seat" in ventanas and "api" in ventanas, str(ventanas))
+        antes = mundo.paneles(sesion)
+
+        # ── 5. a second house, while the city is running ────────────────────
+        st, _ = pide(puerto, "/api/agentes", metodo="POST",
+                     cuerpo={"name": "manual", "kind": "knowledge", "role": "seo"})
+        pide(puerto, "/api/montaje", metodo="POST",
+             cuerpo={"agent": "manual", "add": mundo.papeles})
+        afirma("· a house can be added to a city that is already open", st == 200)
+        afirma(
+            "· non-happy: and until the city is opened again, it is not there",
+            "manual" not in mundo.ventanas(sesion),
+            str(mundo.ventanas(sesion)),
+        )
+
+        # ── 6. open it again: reconcile, do not rebuild ─────────────────────
+        salida = abre_la_sesion(mundo)
+        ventanas = mundo.ventanas(sesion)
+        despues = mundo.paneles(sesion)
+        afirma("· opening it again brings the new house in", "manual" in ventanas, str(ventanas))
+        afirma(
+            "· non-happy: without disturbing a single window that was already there",
+            despues.get("seat") == antes.get("seat") and despues.get("api") == antes.get("api"),
+            f"{antes} → {despues}",
+        )
+        comprueba("· and the city is not opened twice", len(ventanas), 3)
+        afirma("· it says what it did", "manual" in salida.stderr, salida.stderr[-300:])
+
+        # A window whose agent left the card is somebody's work in progress.
+        mundo.corre("tmux", "new-window", "-t", sesion, "-n", "viejo")
+        salida = abre_la_sesion(mundo)
+        afirma(
+            "· non-happy: a window nobody's card claims is reported, never closed",
+            "viejo" in mundo.ventanas(sesion) and "viejo" in salida.stderr,
+            salida.stderr[-400:],
+        )
+
+        # ── 7. the chair reaches into somebody's repo ───────────────────────
+        print("  and the chair is a chair")
+        del_lanzador = mundo.entorno_de_la_sesion(sesion)
+        afirma(
+            "· the launcher tells the window which city it belongs to",
+            del_lanzador.get("AGENTS_CITY_DATA") == mundo.datos,
+            str(del_lanzador),
+        )
+        propio, _ = llama_al_gancho(mundo, sesion, "Read", {"file_path": ficha})
+        comprueba("· happy: its own card is its own business", decision(propio), "")
+        ajeno, bruto = llama_al_gancho(
+            mundo, sesion, "Bash",
+            {"command": f"cd {mundo.repo} && grep -rn router app"},
+        )
+        comprueba("· non-happy: its agent's repo is not", decision(ajeno), "deny")
+        afirma(
+            "· and the refusal hands over the house, the role and the way to ask",
+            "api" in motivo(ajeno) and "dev" in motivo(ajeno)
+            and "--member api" in motivo(ajeno),
+            motivo(ajeno)[:400] or bruto.stderr[-300:],
+        )
+        otro, _ = llama_al_gancho(mundo, sesion, "Read",
+                                  {"file_path": os.path.join(mundo.papeles, "guia.md")})
+        afirma(
+            "· non-happy: and a folder of documents is ground too, with its own owner",
+            decision(otro) == "deny" and "manual" in motivo(otro),
+            motivo(otro)[:200],
+        )
+        puerta, _ = llama_al_gancho(
+            mundo, sesion, "Bash",
+            {"command": f'agents-city committee open --member api --question "about {mundo.repo}"'},
+        )
+        comprueba("· happy: and asking is never the thing that is stopped",
+                  decision(puerta), "")
+
+        # ── 8. the refusal is on disk, and readable from the browser ────────
+        st, diario = pide(puerto, "/api/diario")
+        lineas = [x for x in (diario.get("lineas") or diario.get("entradas") or [])
+                  if x.get("tipo") == "alcance"]
+        afirma(
+            "· the refusal is in the journal the owner can send me",
+            st == 200 and any(x.get("agente") == "api" for x in lineas),
+            json.dumps(diario)[:400],
+        )
+
+        # ── 9. and the owner can open the chair's hands ─────────────────────
+        r = mundo.corre("bash", os.path.join(RAIZ, "bin", "seat"),
+                        "--city", mundo.datos, "--seat-reach", "open")
+        abierto, _ = llama_al_gancho(
+            mundo, sesion, "Bash", {"command": f"grep -rn router {mundo.repo}"})
+        afirma(
+            "· happy: `--seat-reach open` is the owner's call, and it takes effect",
+            r.returncode == 0 and decision(abierto) == "",
+            f"{r.stdout}{r.stderr}\n{motivo(abierto)[:200]}",
+        )
+        r = mundo.corre("bash", os.path.join(RAIZ, "bin", "seat"),
+                        "--city", mundo.datos, "--seat-reach", "closed")
+        cerrado, _ = llama_al_gancho(
+            mundo, sesion, "Bash", {"command": f"grep -rn router {mundo.repo}"})
+        comprueba("· and closing it again puts the boundary back",
+                  decision(cerrado), "deny")
+
+        # ── 10. and after all of it, the city still describes itself ────────
+        st, estado = pide(puerto, "/api/estado")
+        nombres = sorted(a["name"] for a in estado.get("agents", []))
+        comprueba("· the city ends the day with the two houses it was given",
+                  (st, nombres), (200, ["api", "manual"]))
+    finally:
+        servidor.shutdown()
+        servidor.server_close()
+        serve.cities.REGISTRO = registro_previo
+        for k, v in previo.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+        mundo.limpia()
+    return resumen("e2e")
+
+
+if __name__ == "__main__":
+    sys.exit(main())