agents-city 0.3.0 → 0.4.0

package/bin/serve.py

@@ -27,7 +27,6 @@ import socketserver
 import subprocess
 import sys
 import threading
-import time
 import urllib.parse
 import webbrowser
 
@@ -36,13 +35,13 @@ sys.path.insert(0, AQUI)
 import setup as W  # noqa: E402  legacy template catalogue used by the Hall
 
 sys.path.insert(0, os.path.join(os.path.dirname(AQUI), "plugin", "scripts"))
-import busca  # noqa: E402  the one disk scanner: repos, worktrees, documents
 import card  # noqa: E402
 import domains  # noqa: E402
 import gh  # noqa: E402
 import parcels  # noqa: E402
 import units  # noqa: E402
 import cities  # noqa: E402
+import demos  # noqa: E402  the recorded demos the Hall plays back
 import roads  # noqa: E402
 import capabilities  # noqa: E402
 import deliberations  # noqa: E402
@@ -129,7 +128,7 @@ def contador_git_local(a, datos):
     plain commits, activity the last thirty days. Without this, `_code`
     honestly answers zero and every code agent's sheet showed an empty house
     no matter how much it had built. The disk index a legacy agent needs is
-    memoised inside capabilities, so N agents cost one find-repos scan.
+    memoised inside capabilities, so N agents cost one disk scan.
     """
     import time
 
@@ -522,12 +521,15 @@ def actividad_viva(datos):
         return {"online": False, "url": "", "city": "", "started_at": ""}
 
 
-def _dia(cuando):
-    """A unix time as a plain date, or nothing. The picker shows when a place
-    was last touched, and an epoch integer is not something anybody reads."""
-    if not cuando:
-        return ""
-    return time.strftime("%Y-%m-%d", time.localtime(cuando))
+def _que_es_git(ruta):
+    """`repo`, `worktree`, or nothing. A label on a row, never a filter: the
+    picker shows every folder and lets the person decide which one matters."""
+    marca = os.path.join(ruta, ".git")
+    if os.path.isdir(marca):
+        return "repo"
+    if os.path.isfile(marca):
+        return "worktree"
+    return ""
 
 
 def carpetas_probables():
@@ -699,7 +701,8 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         "/api/estado": "g_estado",
         "/api/instrucciones": "g_instrucciones",
         "/api/live": "g_live",
-        "/api/misrepos": "g_misrepos",
+        "/api/carpeta": "g_carpeta",
+        "/api/demos": "g_demos",
         "/api/domains": "g_domains",
         "/api/roles": "g_roles",
     }
@@ -852,38 +855,88 @@ class Manejador(http.server.BaseHTTPRequestHandler):
     def g_live(self, q):
         return self.responde(actividad_viva(self.ciudad(q)))
 
-    def g_misrepos(self, q):
-        """Everything on this disk an agent could be given to work on.
+    def g_demos(self, q):
+        """The recorded demos, and one of them in full when asked by name.
 
-        Repositories, linked worktrees and folders of documents, most recently
-        touched first — the same index the seat and the launcher read, so the
-        picker and the terminal can never disagree about what is out there.
+        These are recordings, not simulations: `demo/graba.py` plays each story
+        over the real local bus and keeps the exact stream a spectator saw, so
+        the Hall can replay a committee without a provider account and without
+        the browser owning a second, drifting copy of the state machine.
+        """
+        cual = q.get("story", [""])[0]
+        catalogo = demos.catalogo()
+        if not cual:
+            return self.responde({"demos": catalogo})
+        historia = next((d for d in catalogo if d["id"] == cual), None)
+        if not historia:
+            return self.responde({"error": "no such demo"}, codigo=404)
+        eventos = demos.eventos(cual)
+        if not eventos:
+            return self.responde(
+                {"error": "that demo has no recording; run demo/graba.py"}, codigo=409
+            )
+        return self.responde({**historia, "eventos": eventos})
 
-        The version before this one ran `git log` in every repository to mark
-        the ones you had committed to. On a machine with three hundred clones
-        that is three hundred processes while somebody watches a spinner, and
-        the answer it bought — "yours" — is one a single-user product can read
-        off the filesystem for free: what you touched this month is yours.
+    def g_carpeta(self, q):
+        """One folder, listed: what is in it, and what each thing is.
+
+        This replaced a picker that scanned the whole disk and offered what it
+        thought you wanted. It was wrong to do that. A person choosing what an
+        agent works on knows where their work is, and being handed a guessed
+        list of two hundred repositories is not help — it is a second thing to
+        read before you can do the thing you came to do. So: a folder, its
+        contents, and you walk.
+
+        Read-only, and metadata only. It never opens a file. The Hall is already
+        bound to the loopback behind a per-run token, and mounting an arbitrary
+        path was always allowed from here; listing one is strictly less.
         """
-        # ?refresh=1 rebuilds the index first. The cache lasts a day, and the
-        # repo somebody just cloned is exactly the one they came to tick.
+        pedida = q.get("path", ["~"])[0] or "~"
+        ruta = os.path.realpath(os.path.expanduser(pedida))
+        if not os.path.isdir(ruta):
+            return self.responde({"error": f"there is no folder at {ruta}"}, codigo=404)
+        ocultos = bool(q.get("hidden", [""])[0])
+        entradas = []
         try:
-            sitios = busca.lugares(refrescar=bool(q.get("refresh", [""])[0]))
-        except OSError:
-            sitios = []
-        frontera = time.time() - 60 * 86400
+            with os.scandir(ruta) as it:
+                for e in it:
+                    if e.name.startswith(".") and not ocultos:
+                        continue
+                    try:
+                        es_dir = e.is_dir(follow_symlinks=True)
+                    except OSError:
+                        es_dir = False
+                    entradas.append(
+                        {
+                            "nombre": e.name,
+                            "ruta": os.path.join(ruta, e.name),
+                            "dir": es_dir,
+                            # What kind of place this is, said plainly rather
+                            # than used to filter anything out: a folder is
+                            # yours to pick whether or not it holds a .git.
+                            "git": _que_es_git(os.path.join(ruta, e.name)) if es_dir else "",
+                            "enlace": e.is_symlink(),
+                        }
+                    )
+        except OSError as error:
+            return self.responde({"error": str(error)}, codigo=403)
+        # Folders first, then files, each alphabetical and case-insensitive —
+        # the order every file picker has used for forty years.
+        entradas.sort(key=lambda x: (not x["dir"], x["nombre"].lower()))
+        casa = os.path.expanduser("~")
+        arriba = os.path.dirname(ruta)
         return self.responde(
             {
-                "repos": [
-                    {
-                        "nombre": s["nombre"],
-                        "ruta": s["ruta"],
-                        "clase": s.get("clase", "repo"),
-                        "cuando": _dia(s.get("cuando", 0.0)),
-                        "mio": s.get("cuando", 0.0) >= frontera,
-                    }
-                    for s in sitios
-                ]
+                "ruta": ruta,
+                "arriba": arriba if arriba != ruta else "",
+                "casa": casa,
+                "atajos": [
+                    {"nombre": os.path.basename(c) or c, "ruta": c}
+                    for c in [casa] + [os.path.join(casa, n) for n in CANDIDATAS]
+                    if os.path.isdir(c)
+                ],
+                "entradas": entradas[:2000],
+                "recortada": len(entradas) > 2000,
             }
         )
 
@@ -1326,8 +1379,11 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             ]
         elif anadir:
             destino = os.path.realpath(os.path.expanduser(anadir))
-            if not os.path.isdir(destino):
-                return self.responde({"error": f"there is no folder at {destino}"}, codigo=400)
+            # A folder, or one exact file. Both are things somebody legitimately
+            # wants an agent to work on — a handbook is a folder, a spec is a
+            # file — and the workspace links either the same way.
+            if not os.path.exists(destino):
+                return self.responde({"error": f"there is nothing at {destino}"}, codigo=400)
             try:
                 workspace.monta(datos, a.slug, destino)
             except (OSError, ValueError) as e:

package/bin/test

@@ -22,7 +22,7 @@ if [ -d .git ] && [ -x .githooks/pre-commit ] \
     && printf '  pre-commit gate armed (core.hooksPath .githooks)\n'
 fi
 
-SUITES=(widgets card parcels domains busca serve seat cities channel committee live-feed runtime claude-runtime runtime-ui runtime-failures stress adapter benchmark demo contracts exit rutas cage broker evidencia admision pairing hall-protocol doctor security workspace avatar crecimiento atajos navegador actualiza launch)
+SUITES=(widgets card parcels domains busca serve seat cities channel committee live-feed runtime claude-runtime runtime-ui runtime-failures stress adapter benchmark demo contracts exit rutas cage broker evidencia admision pairing hall-protocol doctor security workspace avatar crecimiento atajos navegador actualiza desinstala launch)
 [ $# -gt 0 ] && SUITES=("$@")
 
 fallos=0
@@ -89,7 +89,8 @@ necesarios = ["bin/agents-city.js", "bin/hall", "bin/seat", "bin/city", "bin/dem
               "plugin/scripts/hall_protocol.py", "plugin/scripts/doctor.py",
               "plugin/scripts/workspace.py", "plugin/scripts/avatar.py",
               "plugin/scripts/crecimiento.py",
-              "plugin/scripts/reset.py", "plugin/scripts/capabilities.py",
+              "plugin/scripts/reset.py", "plugin/scripts/desinstala.py",
+              "plugin/scripts/demos.py", "plugin/scripts/capabilities.py",
               "plugin/scripts/deliberations.py",
               "plugin/scripts/runtime_processes.py",
               "plugin/scripts/runtime_log.py", "plugin/scripts/logs.py",
@@ -102,7 +103,9 @@ necesarios = ["bin/agents-city.js", "bin/hall", "bin/seat", "bin/city", "bin/dem
               "plugin/channel/runtime-gateway.js",
               "plugin/.mcp.json",
               "bin/cities", "bin/road", "bin/bus", "bin/committee", "bin/agents",
-              "bin/reset", "bin/skills", "bin/benchmark", "bin/logs",
+              "bin/reset", "bin/uninstall", "bin/skills", "bin/benchmark", "bin/logs",
+              "demo/graba.py", "demo/grabaciones/software.jsonl",
+              "demo/grabaciones/medicina.jsonl", "demo/grabaciones/legal.jsonl",
               "benchmarks/committee/run.py",
               "benchmarks/latency/live.py", "benchmarks/latency/README.md",
               "benchmarks/latency/fake-native-server.mjs",

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-navegador.py

@@ -143,6 +143,8 @@ def main():
             if limpia.startswith("ok  ·") or limpia.startswith("FAIL·"):
                 vistas += 1
                 afirma("· " + limpia.split("·", 1)[1].strip(), limpia.startswith("ok"), "")
+            elif limpia and vistas and not limpia.startswith("ok"):
+                print("      " + limpia[:400])
         if not vistas:
             afirma("· the browser checks ran at all", False, texto.strip()[-500:])
         elif salida.returncode != 0:

package/bin/test-serve.py

@@ -60,8 +60,7 @@ def main():
     hilo.start()
 
     # The hall reads whatever city AGENTS_CITY_DATA points at; give it one of its
-    # own so this suite never touches the caller's, and an empty disk index so
-    # /api/misrepos cannot wander off crawling the real home directory.
+    # own so this suite never touches the caller's.
     hallDatos = tempfile.mkdtemp()
     appDatos = tempfile.mkdtemp()
     arbitraryDatos = tempfile.mkdtemp()
@@ -237,6 +236,32 @@ def main():
             and "MAP_ACTIVITY_PROTOCOL" in hall_source
             and "enviaActividadAlMapa(event)" in hall_source,
         )
+        # The map is framed by the Hall, and it shipped with no day palette at
+        # all: `:root` was the night one and the "light" floor colour was in
+        # fact DARKER than the night floor, so asking for daylight dimmed the
+        # map. A light Hall around a night map reads as two products.
+        mapa_fuente = open(os.path.join(RAIZ, "city", "web", "src", "main.ts")).read()
+        claro = int(_re.search(r"const SUELO_CLARO = 0x([0-9a-f]{6})", mapa_fuente).group(1), 16)
+        noche = int(_re.search(r"const SUELO = 0x([0-9a-f]{6})", mapa_fuente).group(1), 16)
+        afirma(
+            "· the map's daylight floor is actually lighter than its night one",
+            claro > noche, f"light={claro:#08x} night={noche:#08x}",
+        )
+        afirma(
+            "· and the map's own palette is day first, night only when stamped",
+            ':root[data-tema="dark"]{' in map_html.replace("\n", "")
+            and "@media(prefers-color-scheme" not in map_html.replace(" ", "")
+            and map_html.index(":root{") < map_html.index(':root[data-tema="dark"]'),
+            map_html[:900],
+        )
+        plano = " ".join(mapa_fuente.split())
+        afirma(
+            "· the map boots on the skin its own stylesheet defaults to",
+            "esDeDia ? SUELO_CLARO : SUELO" in plano
+            and "background: esDeDia ? SUELO_CLARO : SUELO" in plano,
+            "",
+        )
+
         afirma(
             "· game speech is anchored to a real actor and starts with its recipient",
             "speech.target.getBounds()" in speech_source
@@ -739,6 +764,101 @@ def main():
         )
         pide(puerto, "/api/agente", metodo="POST", cuerpo={"agent": "notas", "model": ""})
 
+        # ── the demo shelf ───────────────────────────────────────────────────
+        print("  the demos the Hall plays back")
+        st, cuerpo = pide(puerto, "/api/demos")
+        lista = json.loads(cuerpo)["demos"]
+        comprueba("· the shelf lists", st, 200)
+        afirma("· one demo per work domain, each named",
+               len(lista) == 3 and all(d["titulo"] and d["ciudad"] and d["dominio"] for d in lista),
+               str(lista)[:300])
+        afirma("· with its cast and its length, so a card can be read before playing",
+               all(d["turnos"] > 5 and len(d["reparto"]) >= 3 for d in lista), str(lista)[:300])
+        afirma("· and the shelf alone carries no turns — a card is not a download",
+               all("eventos" not in d for d in lista), str(lista)[:200])
+
+        st, cuerpo = pide(puerto, "/api/demos?story=software")
+        grabacion = json.loads(cuerpo)
+        comprueba("· one demo comes back in full", st, 200)
+        afirma("· as the very events the real bus produced",
+               all(e.get("protocol") == "agents-city-activity/1" for e in grabacion["eventos"])
+               and grabacion["eventos"][0]["kind"] == "committee.opened",
+               str(grabacion["eventos"][0])[:200])
+        afirma("· carrying no dead city's identifiers into this one",
+               not any(k in grabacion["eventos"][0] for k in ("id", "at", "city", "thread")),
+               str(grabacion["eventos"][0])[:200])
+        st, _ = pide(puerto, "/api/demos?story=../../etc/passwd")
+        comprueba("· and a demo nobody recorded is a 404, never a file read", st, 404)
+
+        # ── walking the disk ─────────────────────────────────────────────────
+        # The picker before this one scanned the whole machine and offered what
+        # it guessed you wanted, which could only ever offer what it knew how to
+        # look for. This one lists one folder and gets out of the way.
+        print("  the folder picker")
+        paseo = tempfile.mkdtemp()
+        os.makedirs(os.path.join(paseo, "un-repo", ".git"))
+        os.makedirs(os.path.join(paseo, "un-arbol"))
+        open(os.path.join(paseo, "un-arbol", ".git"), "w").close()
+        os.makedirs(os.path.join(paseo, "notas"))
+        open(os.path.join(paseo, "una-nota.md"), "w").close()
+        open(os.path.join(paseo, ".escondido"), "w").close()
+
+        st, cuerpo = pide(puerto, "/api/carpeta?path=" + urllib.parse.quote(paseo))
+        datos_carpeta = json.loads(cuerpo)
+        nombres = [e["nombre"] for e in datos_carpeta["entradas"]]
+        clases = {e["nombre"]: e for e in datos_carpeta["entradas"]}
+        comprueba("· a folder lists", st, 200)
+        afirma(
+            "· folders first, then files, each alphabetical",
+            nombres == ["notas", "un-arbol", "un-repo", "una-nota.md"], str(nombres),
+        )
+        afirma("· a file is offered too — it is a thing somebody works on",
+               clases["una-nota.md"]["dir"] is False, str(clases["una-nota.md"]))
+        afirma("· a clone is labelled, not filtered out",
+               clases["un-repo"]["git"] == "repo", str(clases["un-repo"]))
+        afirma("· and so is a worktree",
+               clases["un-arbol"]["git"] == "worktree", str(clases["un-arbol"]))
+        afirma("· a folder with nothing special is offered exactly the same",
+               clases["notas"]["git"] == "" and clases["notas"]["dir"], str(clases["notas"]))
+        afirma("· dotfiles stay out of the way unless asked for",
+               ".escondido" not in nombres, str(nombres))
+        st, cuerpo = pide(
+            puerto, "/api/carpeta?hidden=1&path=" + urllib.parse.quote(paseo)
+        )
+        afirma("· and are there when they are asked for",
+               ".escondido" in [e["nombre"] for e in json.loads(cuerpo)["entradas"]], cuerpo)
+        afirma("· it says where you are and what is above you",
+               datos_carpeta["ruta"] == os.path.realpath(paseo)
+               and datos_carpeta["arriba"] == os.path.dirname(os.path.realpath(paseo)),
+               str(datos_carpeta)[:200])
+        afirma("· and offers the usual places to start from",
+               any(a["ruta"] == os.path.expanduser("~") for a in datos_carpeta["atajos"]),
+               str(datos_carpeta["atajos"]))
+        st, _ = pide(puerto, "/api/carpeta?path=" + urllib.parse.quote(paseo + "/no-existe"))
+        comprueba("· a folder that is not there is a 404, not a crash", st, 404)
+        st, cuerpo = pide(
+            puerto, "/api/carpeta?path=" + urllib.parse.quote(os.path.join(paseo, "una-nota.md"))
+        )
+        comprueba("· and neither is a file a folder", st, 404)
+
+        # A mount may be one exact file: a handbook is a folder, a spec is a file.
+        st, cuerpo = pide(
+            puerto,
+            "/api/montaje",
+            metodo="POST",
+            cuerpo={"agent": "notas", "add": os.path.join(paseo, "una-nota.md")},
+        )
+        afirma("· one exact file can be mounted, not only a folder",
+               st == 200 and json.loads(cuerpo).get("ok"), f"{st} {cuerpo}")
+        st, cuerpo = pide(
+            puerto,
+            "/api/montaje",
+            metodo="POST",
+            cuerpo={"agent": "notas", "add": os.path.join(paseo, "no-hay-nada")},
+        )
+        comprueba("· and something that is not there is still refused", st, 400)
+        shutil.rmtree(paseo, ignore_errors=True)
+
         # ── the roster, from the web ─────────────────────────────────────────
         print("  building the roster from the Hall")
         st, cuerpo = pide(

package/bin/uninstall

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Remove agents-city and everything it wrote on this machine.
+# Preview by default; --yes goes through with it.
+set -euo pipefail
+exec python3 "$(dirname "$0")/../plugin/scripts/desinstala.py" "$@"