agents-city 0.3.0 → 0.5.1

package/bin/test-contracts.py

@@ -328,6 +328,140 @@ def varias_ciudades():
     shutil.rmtree(casa)
 
 
+def motor_para_todos():
+    """The card says which model a window runs, once, whatever CLI runs it.
+
+    Both fields used to be Claude's alone. They are not: the native gateways
+    parse `--model` — and Codex `--effort` — out of the command string and send
+    them with the turn, which is why one key on the card can mean the same thing
+    for all four. This checks the launcher actually hands them over, because a
+    dropdown whose value never reaches a process is a lie with a nice font.
+    """
+    print('  the engine reaches every runtime')
+    fuente = open(os.path.join(RAIZ, 'plugin/scripts/city-session.sh'), encoding='utf-8').read()
+    afirma('· a native runtime command goes through con_motor, not raw',
+           'con_motor "$win" "$KIND" "$OTRO"' in fuente, '')
+    afirma('· and so does the seat when it runs one',
+           'con_motor seat "$SEAT_RUNTIME" "$SEAT_OTRO"' in fuente, '')
+
+    # The two functions, lifted out and exercised against a stub card reader.
+    casa = tempfile.mkdtemp()
+    # A stand-in for read-card.py, in the language the launcher invokes it in.
+    lector = os.path.join(casa, 'leer.py')
+    # It answers the batched form too, because that is what the launcher asks:
+    # a stub that only knows the one-field call would test a door nobody uses.
+    open(lector, 'w', encoding='utf-8').write(
+        'import sys\n'
+        "CARD = {'model.dbt': 'gpt-5.6-sol', 'effort.dbt': 'max'}\n"
+        "campos = sys.argv[3:] if sys.argv[1:2] == ['--varios'] else sys.argv[-1:]\n"
+        "print('\\n'.join(CARD.get(c, '') for c in campos))\n"
+    )
+    trozo = fuente[fuente.index('motor_de() {'):fuente.index('runtime_de() {')]
+    guion = os.path.join(casa, 'motor.sh')
+    open(guion, 'w', encoding='utf-8').write(
+        f'LEER="{lector}"\nFICHA=/dev/null\n{trozo}\n'
+        'printf "%s\\n" "$(con_motor "$1" "$2" "$3")"\n'
+    )
+
+    def con(ventana, motor, orden):
+        return subprocess.run(['bash', guion, ventana, motor, orden],
+                              capture_output=True, text=True).stdout.strip()
+
+    comprueba('· claude gets both flags',
+              con('dbt', 'claude', 'claude'), 'claude --model gpt-5.6-sol --effort max')
+    comprueba('· codex gets both too — its gateway reads them off the command',
+              con('dbt', 'codex', 'codex'), 'codex --model gpt-5.6-sol --effort max')
+    comprueba('· opencode gets the model and no effort it cannot read',
+              con('dbt', 'opencode', 'opencode'), 'opencode --model gpt-5.6-sol')
+    comprueba('· and neither does kimi',
+              con('dbt', 'kimi', 'kimi'), 'kimi --model gpt-5.6-sol')
+    comprueba('· a window with nothing on the card gets no flags at all',
+              con('otra', 'codex', 'codex'), 'codex')
+    # A command that already says it wins: somebody who wrote the flag meant it.
+    comprueba('· an explicit --model on the card is never doubled',
+              con('dbt', 'codex', 'codex --model o3'), 'codex --model o3 --effort max')
+    comprueba('· nor an explicit --effort',
+              con('dbt', 'codex', 'codex --effort low'),
+              'codex --effort low --model gpt-5.6-sol')
+    shutil.rmtree(casa, ignore_errors=True)
+
+
+def asiento_con_su_arnes():
+    """The chair keeps the harness the person came with.
+
+    Claude behind the gateway is headless with a `city>` prompt in front of it.
+    That is right for a house, which must be able to RECEIVE work from the bus,
+    and wrong for the chair, where somebody works by hand with their own
+    plugins, statusline and slash commands. The city plugin's hooks already
+    report a normal session's prompts and answers onto the bus, so the chair
+    loses nothing by opening its own interface.
+
+    What must never differ between the two shapes are the two flags that make
+    the bus the only route between agents. A quieter product with a hole in it
+    is the failure this checks for.
+    """
+    print('  the chair keeps its own interface')
+    fuente = open(os.path.join(RAIZ, 'plugin/scripts/city-session.sh'), encoding='utf-8').read()
+    cuerpo = fuente[fuente.index('lanza_asiento_claude() {'):fuente.index('# The seat runs Claude')]
+    afirma('· both shapes of the chair come out of one function',
+           fuente.count('lanza_asiento_claude "') == 2, '')
+    afirma('· the tui branch runs the command itself',
+           'lanza "$SESSION:seat" seat "$EQUIPO" "$entorno${CLAUDE_AUTH_PREFIX}$orden"' in cuerpo,
+           cuerpo)
+    afirma('· the gateway branch is still there, one card key away',
+           'gateway_line seat "$EQUIPO" "$orden"' in cuerpo, cuerpo)
+    afirma('· and the flags are built once, before the branch, so they cannot differ',
+           cuerpo.count('$SETTINGS') == 0 and cuerpo.count('NO_PEER_TOOLS') == 0, cuerpo)
+    # Every Claude command in the file is built the same way: the engine
+    # through `con_motor` (which carries the "an explicit flag wins" guard) and
+    # the deal through `$CLAUDE_TRATO` (which is asked of the declaration). A
+    # branch that skips either is a window that silently runs differently.
+    ordenes = [l for l in fuente.split('\n')
+               if 'CLAUDE_SEAT="' in l or 'CLAUDE_REPO="' in l
+               or 'lanza_asiento_claude "' in l]
+    afirma('· every Claude launch in the file was found', len(ordenes) == 5, str(ordenes))
+    for linea in ordenes:
+        if linea.strip().startswith('lanza_asiento_claude "$CLAUDE_SEAT"'):
+            continue  # this one passes a command already built above
+        afirma(f'· the engine goes through con_motor: {linea.strip()[:40]}…',
+               'con_motor' in linea, linea)
+        afirma(f'· and the deal through the declaration: {linea.strip()[:40]}…',
+               '$CLAUDE_TRATO' in linea, linea)
+    afirma('· the chair still opens with its yolo flag',
+           any('$SEAT_YOLO_FLAG' in l for l in ordenes), str(ordenes))
+    afirma('· and the deal is asked of arnes.py, not respelled here',
+           'arnes.py" flags claude' in fuente
+           and "crossSessionInbound" not in fuente
+           and "SendMessage,ListAgents" not in fuente, '')
+
+    # A house is not a chair: it must still be reachable from the bus.
+    afirma('· an agent house still goes through the gateway',
+           'gateway_line "$win" "$path" "$CLAUDE_REPO"' in fuente, '')
+
+    # `ui.<window>`, lifted out and exercised.
+    casa = tempfile.mkdtemp()
+    lector = os.path.join(casa, 'leer.py')
+    open(lector, 'w', encoding='utf-8').write(
+        'import sys\n'
+        "print({'ui.seat': 'gateway', 'ui.raro': 'nonsense'}.get(sys.argv[-1], ''))\n"
+    )
+    trozo = fuente[fuente.index('ui_de() {'):fuente.index('runtime_de() {')]
+    guion = os.path.join(casa, 'ui.sh')
+    open(guion, 'w', encoding='utf-8').write(
+        f'LEER="{lector}"\nFICHA=/dev/null\n{trozo}\nprintf "%s\\n" "$(ui_de "$1" "$2")"\n'
+    )
+
+    def ui(ventana, defecto):
+        return subprocess.run(['bash', guion, ventana, defecto],
+                              capture_output=True, text=True).stdout.strip()
+
+    comprueba('· a card that says gateway gets the gateway', ui('seat', 'tui'), 'gateway')
+    comprueba('· a card that says nothing gets the default', ui('otra', 'tui'), 'tui')
+    comprueba('· and a house defaults the other way', ui('otra', 'gateway'), 'gateway')
+    comprueba('· a card that says nonsense is not obeyed', ui('raro', 'tui'), 'tui')
+    shutil.rmtree(casa, ignore_errors=True)
+
+
 def ventanas_gemelas():
     """Window, engine key and bus actor share one canonical repo slug."""
     print('  the window slug has one owner')
@@ -529,6 +663,83 @@ def ci_bootstrap():
            'the clean checkout would launch WebSocket doubles without ws installed')
 
 
+def publicar_es_verificable():
+    """A release is a tag, and what it publishes can be checked by a stranger.
+
+    Three properties, and each one is a way this has already gone wrong or
+    could: the suite runs before the registry sees anything; the tag and the
+    manifests are made to agree, because a tag that lies publishes one version
+    under another's name forever; and the credential is an OIDC identity rather
+    than a stored token, because a secret that does not exist cannot leak.
+    """
+    print('  a release is a tag, and it is verifiable')
+    ruta = os.path.join(RAIZ, '.github', 'workflows', 'release.yml')
+    afirma('· there is a release workflow at all', os.path.isfile(ruta), ruta)
+    if not os.path.isfile(ruta):
+        return
+    release = open(ruta, encoding='utf-8').read()
+    prueba = open(os.path.join(RAIZ, '.github', 'workflows', 'test.yml'),
+                  encoding='utf-8').read()
+
+    afirma('· it runs on a tag, not on a push to a branch',
+           "tags: ['v*']" in release and 'branches' not in release, release[:400])
+    # The last occurrence: the header comment names `npm publish` while
+    # explaining what this replaced, and a check that cannot tell a command
+    # from a sentence about it fails on its own documentation.
+    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'),
+           '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')
+    afirma('· needs: test — the dependency is declared, not implied',
+           'needs: test' in release, release)
+    afirma('· the tag has to agree with package.json before it publishes',
+           'GITHUB_REF_NAME#v' in release and 'exit 1' in release,
+           'a tag that disagrees would publish one version under another name')
+    afirma('· it publishes with provenance, so the tarball names its commit',
+           '--provenance' in release, release)
+    afirma('· through a short-lived identity, with no token stored anywhere',
+           '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')
+    afirma('· and it asks for nothing else',
+           release.count('write') == 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
+    # to find out.
+    afirma('· with an npm new enough to exchange the token at all',
+           'npm install -g npm@^11' in release and '11.5.1' in release,
+           '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)
+    # 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
+    # only fail. It did, on a flaky test, after everything real had passed.
+    afirma('· and it does not run the suite a fourth time to publish',
+           '--ignore-scripts' in release,
+           'prepublishOnly duplicates what needs: test already proved')
+    # Skipping the scripts also skips the BUILD, and `city/web/dist*` are
+    # gitignored — they exist only because something builds them. Turning the
+    # test half off by turning the whole script off shipped a package with no
+    # 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'),
+           '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,
+           'the gitignored artifacts are the ones nobody notices missing')
+    paquete = json.load(open(os.path.join(RAIZ, 'package.json'), encoding='utf-8'))
+    afirma('· and the build has one spelling, shared with a publish by hand',
+           paquete['scripts'].get('prepublishOnly', '').startswith('npm run build')
+           and 'city/web' in paquete['scripts'].get('build', ''),
+           str(paquete.get('scripts')))
+
+
 def main():
     print()
     resolvedores()
@@ -539,11 +750,14 @@ def main():
     demo_coherente()
     varias_ciudades()
     ventanas_gemelas()
+    motor_para_todos()
+    asiento_con_su_arnes()
     canal_compilado()
     plugin_canal()
     puerta_npm()
     documentacion_publica()
     ci_bootstrap()
+    publicar_es_verificable()
     return resumen('contracts')
 
 

package/bin/test-demo.py

@@ -86,6 +86,72 @@ def ordered(actual, expected):
     return cursor == len(expected)
 
 
+def grabaciones():
+    """The recordings the Hall plays back must still be the story they claim.
+
+    They are made by running the real thing (`demo/graba.py`), which means they
+    can go stale silently: somebody edits a story, the terminal demo changes,
+    and the browser keeps playing last month's committee as if it were current.
+    This is the check that turns that into a failure instead of a lie.
+    """
+    print("  the recordings the Hall plays back")
+    sys.path.insert(0, os.path.join(RAIZ, "plugin", "scripts"))
+    sys.path.insert(0, os.path.join(RAIZ, "demo"))
+    import demos  # noqa: PLC0415
+    from stories import STORIES  # noqa: PLC0415
+
+    catalogo = demos.catalogo()
+    ids = [d["id"] for d in catalogo]
+    afirma("· every story has a recording", sorted(ids) == sorted(STORIES), str(ids))
+    for ficha in catalogo:
+        eventos = demos.eventos(ficha["id"])
+        historia = STORIES[ficha["id"]]
+        afirma(
+            f"· {ficha['id']}: the recording says what the story says",
+            ficha["titulo"] == historia["title"], f"{ficha['titulo']} != {historia['title']}",
+        )
+        afirma(
+            f"· {ficha['id']}: it opens with the story's own question",
+            eventos[0]["kind"] == "committee.opened"
+            and eventos[0]["summary"] == historia["turns"][0]["payload"]["question"],
+            str(eventos[0])[:200],
+        )
+        afirma(
+            f"· {ficha['id']}: and ends with the committee closed",
+            eventos[-1]["kind"] == "committee.closed", str(eventos[-1])[:200],
+        )
+        afirma(
+            f"· {ficha['id']}: every invited specialist speaks",
+            all(
+                quien in ficha["reparto"]
+                for quien in historia["turns"][0]["payload"]["participants"]
+            ),
+            f"{ficha['reparto']} vs {historia['turns'][0]['payload']['participants']}",
+        )
+        afirma(
+            f"· {ficha['id']}: the turns are in order and numbered",
+            [e["seq"] for e in eventos] == list(range(1, len(eventos) + 1)),
+            str([e["seq"] for e in eventos]),
+        )
+        # A recording that carried ids, timestamps or a thread would replay a
+        # dead city's identifiers into somebody else's Hall.
+        afirma(
+            f"· {ficha['id']}: nothing volatile was recorded",
+            not any(
+                clave in e for e in eventos for clave in ("id", "at", "city", "thread", "sourceId")
+            ),
+            str(eventos[0]),
+        )
+        afirma(
+            f"· {ficha['id']}: and no raw payload leaked into it",
+            all(set(e) <= {
+                "protocol", "seq", "kind", "actor", "role", "phase", "tone",
+                "title", "summary", "details", "target",
+            } for e in eventos),
+            str(sorted({k for e in eventos for k in e})),
+        )
+
+
 def main():
     global FIXTURE
     print("\n  full Aurora demo on the real local bus")
@@ -301,6 +367,7 @@ def main():
             stop_hubs(app)
             shutil.rmtree(base, ignore_errors=True)
 
+    grabaciones()
     return resumen("demo")
 
 

package/bin/test-desinstala.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Getting the product off a machine, without taking anything else with it.
+
+One assertion here matters more than the rest put together: an agent's home is
+full of symlinks into real repositories and real folders of documents, and the
+uninstaller walks straight through it. If it ever followed one of those links,
+it would delete somebody's work. That is the check this file exists for.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+
+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 cities  # noqa: E402
+import desinstala  # noqa: E402
+from testlib import afirma, comprueba, resumen  # noqa: E402
+
+
+def monta():
+    """A machine with the product on it, and one repository beside it."""
+    casa = tempfile.mkdtemp()
+    trabajo = tempfile.mkdtemp()
+
+    repo = os.path.join(trabajo, "el-repo")
+    os.makedirs(os.path.join(repo, "src"))
+    with open(os.path.join(repo, "src", "importante.txt"), "w") as f:
+        # Deliberately big: the size check below has to be able to tell "walked
+        # into the repository" apart from "the product wrote a few more bytes
+        # than this fixture did", and a 17-byte file cannot carry that.
+        f.write("this must survive\n" + "x" * 400_000)
+
+    docs = os.path.join(trabajo, "manual")
+    os.makedirs(docs)
+    with open(os.path.join(docs, "uno.md"), "w") as f:
+        f.write("so must this")
+
+    ciudad = os.path.join(casa, "agents-city", "yo", "home")
+    agente = os.path.join(ciudad, "agents", "api")
+    os.makedirs(agente)
+    with open(os.path.join(ciudad, "city.yml"), "w") as f:
+        f.write("owner: yo\nname: home\n")
+    # The two links an agent's home is made of.
+    os.symlink(repo, os.path.join(agente, "el-repo"))
+    os.symlink(docs, os.path.join(agente, "manual"))
+    with open(os.path.join(agente, "CLAUDE.md"), "w") as f:
+        f.write("mine")
+    return casa, trabajo, repo, docs, ciudad
+
+
+def enlaces(casa, trabajo, repo, docs, ciudad):
+    print("  what it must never follow")
+    raiz = os.path.join(casa, "agents-city")
+    afirma("· the fixture really does link out of the city",
+           os.path.islink(os.path.join(ciudad, "agents", "api", "el-repo")), "")
+
+    tam = desinstala._tamano(raiz)
+    afirma("· measuring the install does not count the linked repo",
+           tam < 100_000, f"{tam} bytes — it walked into the repo")
+
+    quitado = desinstala._quita_carpeta(raiz)
+    afirma("· the install folder is gone", quitado and not os.path.exists(raiz), raiz)
+    afirma("· and the linked repository is untouched",
+           os.path.isfile(os.path.join(repo, "src", "importante.txt")), repo)
+    afirma("· and so is the linked folder of documents",
+           os.path.isfile(os.path.join(docs, "uno.md")), docs)
+    afirma("· the work folder still holds both",
+           sorted(os.listdir(trabajo)) == ["el-repo", "manual"], str(os.listdir(trabajo)))
+
+    print("  and what it does with what is not there")
+    comprueba("· removing a folder that never existed is not an error",
+              desinstala._quita_carpeta(os.path.join(casa, "no-existe")), False)
+    suelto = os.path.join(casa, "suelto")
+    os.symlink(repo, suelto)
+    afirma("· a link that IS the target is unlinked, not descended into",
+           desinstala._quita_carpeta(suelto) and not os.path.lexists(suelto)
+           and os.path.isdir(repo), repo)
+
+
+def el_plan(casa):
+    print("  the plan")
+    pasos = desinstala.plan()
+    clases = [p["clase"] for p in pasos]
+    afirma("· it stops what is running before it deletes anything",
+           clases[0] == "procesos", str(clases))
+    afirma("· it asks Claude to forget the plugin", "plugin" in clases, str(clases))
+    carpetas = [p["ruta"] for p in pasos if p["clase"] == "carpeta"]
+    afirma("· it removes the cities root", any("agents-city" in r for r in carpetas), str(carpetas))
+    afirma("· it removes the cached disk index",
+           any(r.endswith(os.path.join("cache", "agents-city")) for r in carpetas), str(carpetas))
+    afirma("· it removes the bus folder", any("city-bus" in r for r in carpetas), str(carpetas))
+    afirma("· every folder in the plan actually exists",
+           all(os.path.exists(r) for r in carpetas), str(carpetas))
+    afirma("· nothing outside this product is in the plan",
+           all(casa in r or ".claude" in r or ".config" in r or ".cache" in r for r in carpetas),
+           str(carpetas))
+
+    print("  keeping your cities")
+    conservado = [p["ruta"] for p in desinstala.plan(conservar_ciudades=True)
+                  if p["clase"] == "carpeta"]
+    afirma("· --keep-cities leaves the cities root alone",
+           not any(r == cities.raiz() for r in conservado), str(conservado))
+    afirma("· and still unwires the machine", len(conservado) >= 1, str(conservado))
+
+    print("  the npm package")
+    afirma("· it is not removed unless asked",
+           "npm" not in [p["clase"] for p in desinstala.plan()], "")
+    afirma("· and it is the very last thing when it is",
+           desinstala.plan(con_npm=True)[-1]["clase"] == "npm", "")
+
+
+def la_puerta():
+    print("  the front door")
+    import io
+    from contextlib import redirect_stdout
+
+    salida = io.StringIO()
+    with redirect_stdout(salida):
+        codigo = desinstala.main([])
+    texto = salida.getvalue()
+    comprueba("· a bare uninstall exits cleanly", codigo, 0)
+    afirma("· and says plainly that it removed nothing",
+           "Nothing was removed" in texto, texto)
+    afirma("· and promises not to touch your repositories",
+           "NOT touch your repositories" in texto, texto)
+    afirma("· the cities root is still there afterwards",
+           os.path.isdir(cities.raiz()), cities.raiz())
+
+
+def main():
+    casa, trabajo, repo, docs, ciudad = monta()
+    viejo = dict(os.environ)
+    registro = cities.REGISTRO
+    try:
+        os.environ["AGENTS_CITY_HOME"] = os.path.join(casa, "agents-city")
+        os.environ["AGENTS_CITY_USER"] = "yo"
+        os.environ["XDG_CACHE_HOME"] = os.path.join(casa, "cache")
+        os.environ["CITY_DIR"] = os.path.join(casa, ".claude", "channels", "city-bus")
+        os.environ["CITY_DESKTOP"] = tempfile.mkdtemp()
+        cities.REGISTRO = os.path.join(casa, ".config", "agents-city", "cities")
+        for ruta in (os.environ["XDG_CACHE_HOME"] + "/agents-city",
+                     os.environ["CITY_DIR"],
+                     os.path.dirname(cities.REGISTRO)):
+            os.makedirs(ruta, exist_ok=True)
+            with open(os.path.join(ruta, "algo"), "w") as f:
+                f.write("x")
+        # city_env read CITY_DIR at import time, like the rest of the product.
+        import city_env
+
+        city_env.CANAL = os.environ["CITY_DIR"]
+
+        el_plan(casa)
+        la_puerta()
+        enlaces(casa, trabajo, repo, docs, ciudad)
+    finally:
+        cities.REGISTRO = registro
+        os.environ.clear()
+        os.environ.update(viejo)
+        shutil.rmtree(casa, ignore_errors=True)
+        shutil.rmtree(trabajo, ignore_errors=True)
+    return resumen("desinstala")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bin/test-doctor.py

@@ -135,5 +135,36 @@ def revision_del_entorno():
 
 
 
+def puerta_de_config():
+    """`doctor --config` is a door on the environment report, not a new binary.
+
+    It is the command that turns "we respect your CLI configuration" from a
+    sentence in a README into something a person can check on their own machine
+    before trusting this with it.
+    """
+    print('  the config report has a door')
+    import io
+    from contextlib import redirect_stdout
+
+    guion = os.path.join(RAIZ, 'plugin', 'scripts', 'doctor.py')
+    afirma('· doctor --help mentions it',
+           '--config' in open(guion, encoding='utf-8').read(), '')
+    for bandera in ('--config', 'config'):
+        salida = io.StringIO()
+        with redirect_stdout(salida):
+            codigo = doctor.main(['doctor', bandera])
+        texto = salida.getvalue()
+        comprueba(f'· `doctor {bandera}` exits cleanly', codigo, 0)
+        afirma(f'· `doctor {bandera}` prints the deal, not the environment',
+               'the deal' in texto and 'we inherit' in texto, texto[:300])
+    salida = io.StringIO()
+    with redirect_stdout(salida):
+        doctor.main(['doctor', '--config', '--json'])
+    datos = json.loads(salida.getvalue())
+    afirma('· and --json answers with data, one entry per runtime',
+           isinstance(datos, list) and len(datos) == 4, str(datos)[:200])
+
+
 revision_del_entorno()
+puerta_de_config()
 sys.exit(resumen("doctor"))