agents-city 0.3.0-beta.21 → 0.3.0

package/bin/serve.py

@@ -27,6 +27,7 @@ import socketserver
 import subprocess
 import sys
 import threading
+import time
 import urllib.parse
 import webbrowser
 
@@ -35,6 +36,7 @@ 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
@@ -48,6 +50,8 @@ import avatar  # noqa: E402
 import workspace  # noqa: E402
 import crecimiento  # noqa: E402
 import runtime_processes  # noqa: E402
+import reset as reinicio  # noqa: E402
+import actualiza  # noqa: E402
 import importlib.machinery as _mach
 import importlib.util as _iu  # noqa: E402
 
@@ -84,16 +88,38 @@ def es_demo(datos):
 # every page load and after every sheet edit. Ninety seconds of memory keeps the
 # sheet honest enough while sparing the walk on each click.
 _CRECIDO = {}
+_CRECIENDO = threading.Lock()
 
 
-def _cuenta_git(ruta, extra):
+def _historia_git(ruta, desde):
+    """(merges, plain commits, commits since `desde`) in ONE walk of a repo.
+
+    Three `rev-list --count` calls asked git to walk the same history three
+    times, three processes deep; one `log` carrying each commit's timestamp and
+    parents answers all three questions from the same pass. On a 57k-commit repo
+    that is 0.61s instead of 0.83s, and one process instead of three.
+    """
     salida = subprocess.run(
-        ["git", "-C", ruta, "rev-list", "--count", *extra, "HEAD"],
+        ["git", "-C", ruta, "log", "--format=%ct %p", "HEAD"],
         capture_output=True,
         text=True,
-        timeout=10,
+        timeout=30,
     )
-    return int(salida.stdout.strip() or 0) if salida.returncode == 0 else 0
+    if salida.returncode != 0:
+        return 0, 0, 0
+    fusiones = sueltos = recientes = 0
+    for linea in salida.stdout.splitlines():
+        cuando, _, padres = linea.partition(" ")
+        if len(padres.split()) > 1:
+            fusiones += 1
+        else:
+            sueltos += 1
+        try:
+            if int(cuando) >= desde:
+                recientes += 1
+        except ValueError:
+            pass
+    return fusiones, sueltos, recientes
 
 
 def contador_git_local(a, datos):
@@ -102,11 +128,16 @@ def contador_git_local(a, datos):
     Floors are merge commits (a merged PR lands as exactly one), bricks the
     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."""
+    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.
+    """
+    import time
+
     if a.legacy:
         rutas = [capabilities.ruta_de(a.nombre)]
     else:
         rutas = [a.workspace] + list(workspace.mount_targets(a, datos) or [])
+    desde = int(time.time()) - crecimiento.DIAS_RECIENTE * 24 * 3600
     prs = commits = act = 0
     vistos = set()
     for r in rutas:
@@ -114,12 +145,64 @@ def contador_git_local(a, datos):
         if not real or real in vistos or not os.path.exists(os.path.join(real, ".git")):
             continue
         vistos.add(real)
-        prs += _cuenta_git(real, ["--merges"])
-        commits += _cuenta_git(real, ["--no-merges"])
-        act += _cuenta_git(real, ["--since=30.days"])
+        f, s, rec = _historia_git(real, desde)
+        prs += f
+        commits += s
+        act += rec
     return prs, commits, act
 
 
+_SKILLS = {}
+
+
+def skills_de_ciudad(datos):
+    """Live skill discovery, remembered while the card has not changed.
+
+    Discovery reads a SKILL.md for every mount of every agent, and /api/estado
+    runs on every page load and after every mount, agent-add and skill install.
+    The card's mtime is the honest key: everything discovery depends on — who
+    the agents are and what they mount — is written there, so a card that has
+    not moved cannot have a different answer, and one that has invalidates
+    immediately rather than after a timeout.
+    """
+    owner = cities.lee_clave(datos, "owner") or seat.quien_soy()
+    ficha = os.path.join(datos, f"{owner}.md")
+    try:
+        sello = (os.path.realpath(datos), os.path.getmtime(ficha))
+    except OSError:
+        return capabilities.descubre_ciudad(datos)
+    if _SKILLS.get("sello") == sello:
+        return _SKILLS["valor"]
+    valor = capabilities.descubre_ciudad(datos)
+    _SKILLS["sello"], _SKILLS["valor"] = sello, valor
+    return valor
+
+
+def estado_seguro_agentes(datos):
+    """How many agents this city has, or none when the card cannot be read."""
+    owner = cities.lee_clave(datos, "owner") or seat.quien_soy()
+    try:
+        texto = card.lee(os.path.join(datos, f"{owner}.md")).get("texto") or ""
+        return workspace.agentes(texto, datos)
+    except (OSError, ValueError):
+        return []
+
+
+def olvida_skills():
+    """Forget the discovery memo: a skill was installed or removed, and that
+    changes the answer without touching the card."""
+    _SKILLS.pop("sello", None)
+
+
+def olvida_crecimiento(datos, slug):
+    """Drop one agent's remembered growth: it just changed for a known reason.
+
+    Mounting a folder changes exactly what growth counts, and a sheet that
+    answers with the pre-mount number for the next ninety seconds looks like
+    the mount did not take."""
+    _CRECIDO.pop((os.path.realpath(datos), slug), None)
+
+
 def _crecimiento_cacheado(a, datos, vida=90):
     import time
 
@@ -127,11 +210,18 @@ def _crecimiento_cacheado(a, datos, vida=90):
     momento, valor = _CRECIDO.get(clave, (0, None))
     if valor is not None and time.monotonic() - momento < vida:
         return valor
-    try:
-        valor = crecimiento.crece(a, datos, contador_git_local)
-    except (OSError, ValueError, subprocess.SubprocessError):
-        valor = {"floors": 0, "bricks": 0, "activity30": 0, "signal": "unavailable"}
-    _CRECIDO[clave] = (time.monotonic(), valor)
+    # One walk at a time, and the loser of the race reads the winner's answer:
+    # this is a directory walk plus git behind a threaded server, so two tabs
+    # loading at once would otherwise both pay for it.
+    with _CRECIENDO:
+        momento, valor = _CRECIDO.get(clave, (0, None))
+        if valor is not None and time.monotonic() - momento < vida:
+            return valor
+        try:
+            valor = crecimiento.crece(a, datos, contador_git_local)
+        except (OSError, ValueError, subprocess.SubprocessError):
+            valor = {"floors": 0, "bricks": 0, "activity30": 0, "signal": "unavailable"}
+        _CRECIDO[clave] = (time.monotonic(), valor)
     return valor
 
 
@@ -157,11 +247,28 @@ def ficha_de_agente(a, texto, datos, ventanas):
         "avatar": avatar.data_uri(a.nombre, a.clase, semilla=semilla, rol=a.rol),
         "cli": estado_del_cli(a, ventanas),
         "legacy": a.legacy,
-        "mounts": len(a.mounts),
+        "mounts": montajes_de_agente(a, datos),
         "growth": crecido,
     }
 
 
+def montajes_de_agente(a, datos):
+    """What this agent actually works on: the mounts materialised in its
+    workspace, or the sources its card declares when nothing is on disk yet.
+
+    The sheet used to carry only how MANY there were, which is the one thing a
+    person cannot act on — you cannot unmount a number."""
+    if a.legacy:
+        return [{"label": a.slug, "target": a.workspace, "fixed": True}]
+    en_disco = workspace.mounts_en_disco(datos, a.slug)
+    if en_disco:
+        return [{"label": e, "target": t, "fixed": False} for e, t in en_disco]
+    return [
+        {"label": card.ventana(os.path.basename(str(m).rstrip("/"))), "target": m, "fixed": False}
+        for m in a.mounts
+    ]
+
+
 def binario_del_agente(a):
     """The executable behind this agent's runtime: the first token of the
     configured command, basename only — a path or flags never leak into which()."""
@@ -231,16 +338,7 @@ def hogar_escribible(a, datos, crear=True):
     return hogar, ""
 
 
-def raiz_de_skills(hogar):
-    """The agent home's own `.claude/skills`, verified to still be inside the
-    home after resolution. A repo can commit `.claude/skills` (or `.claude`)
-    as a symlink to anywhere this user can write — the global skills folder
-    included — and both the install and the rmtree would follow it. A linked
-    root returns '' and every caller refuses."""
-    real = os.path.realpath(os.path.join(hogar, ".claude", "skills"))
-    if real != os.path.join(os.path.realpath(hogar), ".claude", "skills"):
-        return ""
-    return real
+raiz_de_skills = workspace.raiz_de_skills
 
 
 def skills_con_gestion(a, hogar, skills):
@@ -262,64 +360,12 @@ def skills_con_gestion(a, hogar, skills):
     return fuera
 
 
-# One skill's extraction budget. The base64 cap in p_skill bounds the upload;
-# only these bound what a hostile deflate ratio inflates it to on disk.
-MAX_ENTRADAS_ZIP = 2048
-MAX_EXTRAIDO = 64 * 1024 * 1024
-
-
-def _zip_inseguro(entradas):
-    """The shapes a hostile zip uses, refused by name before a byte lands."""
-    if len(entradas) > MAX_ENTRADAS_ZIP:
-        return "the zip holds too many files for one skill"
-    if sum(info.file_size for info in entradas) > MAX_EXTRAIDO:
-        return "the zip inflates too large for one skill"
-    for info in entradas:
-        nombre = info.filename
-        if nombre.startswith(("/", "\\")) or ".." in nombre.split("/"):
-            return "the zip tries to escape its folder"
-        if (info.external_attr >> 16) & 0o170000 == 0o120000:
-            return "symlinks in a skill are refused"
-    return ""
-
-
-def _nombre_de_skill(entradas, pedido):
-    """The skill's name and its base inside the zip: the single top folder when
-    there is one, else the zip root plus a name from the payload."""
-    raices = {e.filename.split("/")[0] for e in entradas if e.filename.strip("/")}
-    con_carpeta = len(raices) == 1 and any(
-        "/" in e.filename or e.filename.endswith("/") for e in entradas
-    )
-    base = (next(iter(raices)) + "/") if con_carpeta else ""
-    crudo = next(iter(raices)) if con_carpeta else str(pedido or "")
-    nombre = card.rol_seguro(crudo, defecto="")
-    rutas = {e.filename[len(base):] for e in entradas if e.filename.startswith(base)}
-    return nombre, base, rutas
-
-
-def _extrae_skill(archivo, entradas, base, destino):
-    """Write the zip's files under `destino`, containment resolved twice and
-    the decompressed bytes metered as they land — the headers already passed
-    _zip_inseguro, but a header's declared size is the sender's word."""
-    presupuesto = MAX_EXTRAIDO
-    for info in entradas:
-        relativa = info.filename[len(base):] if info.filename.startswith(base) else ""
-        if not relativa or relativa.endswith("/"):
-            continue
-        ruta = os.path.realpath(os.path.join(destino, relativa))
-        if not ruta.startswith(destino + os.sep) and ruta != destino:
-            return "the zip tries to escape its folder"
-        os.makedirs(os.path.dirname(ruta), exist_ok=True)
-        with archivo.open(info) as origen, open(ruta, "wb") as salida:
-            while True:
-                trozo = origen.read(1024 * 64)
-                if not trozo:
-                    break
-                presupuesto -= len(trozo)
-                if presupuesto < 0:
-                    return "the zip inflates too large for one skill"
-                salida.write(trozo)
-    return ""
+# The zip guards and the skills root live in workspace.py: the Hall's upload and
+# the wizard's question are two doors onto one deliberate write, and containment
+# rules that exist twice are containment rules that drift apart.
+_zip_inseguro = workspace.zip_inseguro
+_nombre_de_skill = workspace._nombre_de_skill_en_zip
+_extrae_skill = workspace.extrae_zip
 
 
 def _instala_skill(archivo, entradas, base, nombre, hogar):
@@ -393,10 +439,20 @@ def lee_clave(fichero, clave, defecto=""):
 
 
 def lista_con(datos):
+    """Every city this owner has, with the one being looked at marked — and how
+    many agents live in each.
+
+    The count is not decoration: an agent belongs to ONE city because its
+    workspace and its mounts live inside that city's folder, and a menu that
+    lists "Cities" and "Agents" as two unrelated things hides exactly that. One
+    card read per city, which is cheaper than the page that draws it.
+    """
     real = os.path.realpath(datos)
     fuera = [dict(c, actual=(c["ruta"] == real)) for c in cities.lista(seat.quien_soy())]
     if not any(c["actual"] for c in fuera):
         fuera.insert(0, {"ruta": real, "nombre": cities.nombre(real), "actual": True})
+    for c in fuera:
+        c["agentes"] = len(estado_seguro_agentes(c["ruta"]))
     return fuera
 
 
@@ -466,6 +522,14 @@ 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 carpetas_probables():
     """Existing folders under $HOME that look like where the work lives."""
     casa = os.path.expanduser("~")
@@ -646,8 +710,12 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         "/api/mapa": "p_mapa",
         "/api/sesion": "p_sesion",
         "/api/ciudades": "p_ciudades",
+        "/api/ciudad-archiva": "p_archiva_ciudad",
+        "/api/ciudad-reinicia": "p_reinicia_ciudad",
         "/api/roads": "p_roads",
         "/api/agente": "p_agente",
+        "/api/agentes": "p_agentes",
+        "/api/montaje": "p_montaje",
         "/api/motor": "p_motor",
         "/api/instrucciones": "p_instrucciones",
         "/api/skill": "p_skill",
@@ -713,7 +781,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         retratos = {"seat": avatar.data_uri("seat", "coordinator", rol="chair")}
         agentes = []
         ventanas = ventanas_vivas(owner, datos)
-        habilidades = capabilities.descubre_ciudad(datos)
+        habilidades = skills_de_ciudad(datos)
         for f in sorted(glob_fichas(datos)):
             c = card.lee(f)
             if c.get("user") == owner:
@@ -773,6 +841,10 @@ class Manejador(http.server.BaseHTTPRequestHandler):
                 "avatars": retratos,
                 "agents": agentes,
                 "demo": es_demo(datos),
+                # A person who opened the Hall deliberately is exactly who
+                # should hear that a newer version exists; the check is cached
+                # for a day and never runs on a plain terminal command.
+                "update": actualiza.aviso(),
                 "paleta": [{"hex": c_, "nombre": n} for c_, n in W.PALETA],
             }
         )
@@ -781,28 +853,36 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         return self.responde(actividad_viva(self.ciudad(q)))
 
     def g_misrepos(self, q):
-        # The whole disk by remote (find-repos.sh's cached index), with the
-        # ones this person has commits in already marked — the seat's own
-        # question, served to a page instead of a terminal.
-        quien = q.get("user", [seat.quien_soy()])[0]
-        # ?refresh=1 rebuilds the disk index first. The cache lasts a day, and
-        # the repo somebody just cloned is exactly the one they came to tick.
-        if q.get("refresh", [""])[0]:
-            gh.sh(
-                [
-                    os.path.join(os.path.dirname(AQUI), "plugin", "scripts", "find-repos.sh"),
-                    "--refresh",
-                ],
-                timeout=600,
-            )
-        todos = seat.repos_del_disco()
-        correo = gh.sh(["git", "config", "user.email"]).strip()
-        mios = seat.mios(quien, correo, todos)
+        """Everything on this disk an agent could be given to work on.
+
+        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.
+
+        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.
+        """
+        # ?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.
+        try:
+            sitios = busca.lugares(refrescar=bool(q.get("refresh", [""])[0]))
+        except OSError:
+            sitios = []
+        frontera = time.time() - 60 * 86400
         return self.responde(
             {
                 "repos": [
-                    {"nombre": n, "ruta": r, "cuando": seat.ultimo_commit(r), "mio": n in mios}
-                    for n, r in todos
+                    {
+                        "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
                 ]
             }
         )
@@ -917,38 +997,39 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         dominio = domains.canonico(cuerpo.get("domain") or domains.de_ciudad(datos))
         if not domains.obtiene(dominio):
             return self.responde({"error": f"unknown domain: {dominio}"}, codigo=400)
-        repos_e = [str(r) for r in (cuerpo.get("repos") or [])]
-        repo_roles_raw = cuerpo.get("repo_roles", {})
-        if repo_roles_raw is None:
-            repo_roles_raw = {}
-        if not isinstance(repo_roles_raw, dict):
-            return self.responde({"error": "repo_roles must be an object"}, codigo=400)
+        # The roster is NOT this endpoint's business: /api/agentes and
+        # /api/montaje own it, and the wizard owns it in the terminal. What is
+        # already on the card is carried over verbatim, so saving your seat
+        # never silently empties your city.
+        ficha_previa = os.path.join(datos, f"{quien}.md")
         try:
-            repo_roles = card.normaliza_roles_repos(repos_e, repo_roles_raw)
-        except ValueError as e:
-            return self.responde({"error": str(e)}, codigo=400)
-        obj = cuerpo.get("objetivo") or None
-        if obj is not None and not isinstance(obj, dict):
-            obj = None
-        if obj and not str(obj.get("title", "")).strip():
-            obj = None
+            texto_previo = card.lee(ficha_previa).get("texto") or ""
+            roster = [workspace.como_ficha(a) for a in workspace.agentes(texto_previo, datos)]
+        except (OSError, ValueError):
+            roster = []
+        # Absent means unchanged, present means replace. This endpoint rewrites
+        # the whole card, so anything it does not carry over is destroyed: a
+        # page that saves your role must not silently drop the goal you set in
+        # the terminal (the roster above is the same rule).
+        if "objetivo" not in cuerpo:
+            obj = card.objetivo(texto_previo, quien)
+        else:
+            obj = cuerpo.get("objetivo") or None
+            if obj is not None and not isinstance(obj, dict):
+                obj = None
+            if obj and not str(obj.get("title", "")).strip():
+                obj = None
         try:
             seat.escribe_ficha(
-                os.path.join(datos, f"{quien}.md"),
-                quien,
-                rol,
-                repos_e,
-                obj,
-                cities.slug_ciudad(datos),
-                repo_roles,
+                ficha_previa, quien, rol, roster, obj, cities.slug_ciudad(datos)
             )
             hechos = []
             if cities.gestionada(datos, quien):
-                hechos = seat.escribe_suelo(datos, repos_e, dominio)
+                hechos = seat.escribe_suelo(datos, [a["nombre"] for a in roster], dominio)
             domains.selecciona(datos, dominio)
             hechos += domains.materializa(datos, dominio, rol)
-            for rol_repo in sorted(set(repo_roles.values()) - {"blank", rol}):
-                hechos += domains.materializa(datos, dominio, rol_repo)
+            for rol_agente in sorted({a["rol"] for a in roster} - {"blank", rol}):
+                hechos += domains.materializa(datos, dominio, rol_agente)
         except OSError as e:
             return self.responde({"error": str(e)}, codigo=500)
         cities.registra(datos)
@@ -1009,6 +1090,70 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             {"ok": True, "city": datos, "address": cities.direccion(usuario, datos)}
         )
 
+    def p_archiva_ciudad(self, q, cuerpo):
+        """Take one city out of use — recoverably, and never the last one.
+
+        Not a delete: `cities.archiva` MOVES the folder into the owner's
+        backups. A city is somebody's cards, deliberations and map, and a
+        product that erases that on one click will erase the wrong one.
+        """
+        pedida = str(cuerpo.get("city") or "")
+        usuario = seat.quien_soy()
+        datos = cities.resuelve(pedida, usuario) if pedida else ""
+        if not datos:
+            return self.responde({"error": f"no city called {pedida!r}"}, codigo=404)
+        try:
+            copia = cities.archiva(datos, usuario)
+        except (OSError, ValueError) as e:
+            return self.responde({"error": str(e)}, codigo=409)
+        return self.responde(
+            {"ok": True, "backup": copia, "ciudades": lista_con(cities.actual(usuario))}
+        )
+
+    def p_reinicia_ciudad(self, q, cuerpo):
+        """Take a city back to its first day — after showing exactly what that
+        means, and only when the person types its name.
+
+        Two calls, on purpose. Without `confirm` it answers with the effects and
+        changes nothing; with `confirm` matching the city's own name it does the
+        work. A dangerous button that fires on one click will eventually be
+        clicked by an elbow, and the answer "are you sure?" is not information —
+        the list below is.
+        """
+        datos = self.ciudad(q)
+        usuario = cities.lee_clave(datos, "owner") or seat.quien_soy()
+        nombre = cities.nombre(datos)
+        try:
+            copia = reinicio.reinicia(datos, usuario, dry_run=True)
+        except (OSError, ValueError) as e:
+            return self.responde({"error": str(e)}, codigo=409)
+        agentes = len(estado_seguro_agentes(datos))
+        efectos = {
+            "city": nombre,
+            "backup": copia,
+            "agents": agentes,
+            "roads": len(roads.lee(datos)),
+            "deliberations": len(deliberations.lista(datos)),
+            "keeps": [
+                "every repository and folder your agents mount — untouched",
+                f"a full copy of this city at {copia}",
+            ],
+            "loses": [
+                "your seat card: role, goal and the whole roster",
+                "each agent's workspace, its mounts and the skills installed in it",
+                "the committee history and every recorded decision",
+                "the map's districts and houses",
+            ],
+        }
+        if str(cuerpo.get("confirm") or "") != nombre:
+            return self.responde({"ok": False, "preview": efectos})
+        try:
+            copia = reinicio.reinicia(datos, usuario)
+        except (OSError, ValueError) as e:
+            return self.responde({"error": str(e)}, codigo=409)
+        olvida_skills()
+        return self.responde({"ok": True, "backup": copia, "preview": efectos})
+
     def p_roads(self, q, cuerpo):
         origen = self.ciudad(q)
         accion = str(cuerpo.get("action") or "")
@@ -1100,6 +1245,115 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         "avatar": ("avatar", re.compile(r"[a-z0-9-]{1,16}"), "an avatar seed is short and plain"),
     }
 
+    def p_agentes(self, q, cuerpo):
+        """Add one agent to this city, from the web: name, kind and role.
+
+        The same roster the wizard builds one question at a time, reachable
+        from the Hall — a person who never opens a terminal must be able to say
+        who works in their city, not just tune whoever is already there. Its
+        engine, mounts and skills are the sheet's own controls afterwards.
+        """
+        datos = self.ciudad(q)
+        owner = cities.lee_clave(datos, "owner") or seat.quien_soy()
+        ficha = os.path.join(datos, f"{owner}.md")
+        texto = card.lee(ficha).get("texto") or ""
+        if not texto:
+            return self.responde({"error": "this city has no owner card yet"}, codigo=409)
+        nombre = " ".join(str(cuerpo.get("name") or "").split())
+        slug = card.ventana(nombre)
+        if not nombre or not card.ventana_valida(slug):
+            return self.responde({"error": "an agent needs a plain name"}, codigo=400)
+        clase = str(cuerpo.get("kind") or workspace.CLASE_DEFECTO).strip().lower()
+        if clase not in workspace.CLASES:
+            return self.responde(
+                {"error": "kind is code, knowledge or coordinator"}, codigo=400
+            )
+        rol = card.rol_seguro(str(cuerpo.get("role") or "blank"), defecto="")
+        if not rol:
+            return self.responde({"error": "that is not a role id"}, codigo=400)
+        try:
+            ya = workspace.agentes(texto, datos)
+        except ValueError as e:
+            return self.responde({"error": str(e)}, codigo=409)
+        if any(x.slug == slug for x in ya):
+            return self.responde({"error": f"{slug} is already an agent here"}, codigo=409)
+
+        # A legacy `repos:` card is upgraded in place rather than half-migrated:
+        # every repo it listed is written back as the agent it always was, and
+        # the new one joins them. Nothing that was working stops working. The
+        # keys come from workspace, which owns what a roster looks like on a
+        # card — the wizard writes the very same ones after its seven questions.
+        roster = [workspace.como_ficha(x) for x in ya]
+        roster.append(
+            {"nombre": nombre, "slug": slug, "clase": clase, "rol": rol,
+             "mounts": [], "motor": {}, "skills": []}
+        )
+        for clave, valor in workspace.claves_de_roster(roster).items():
+            card.pon_campo(ficha, clave, valor)
+        workspace.crea_workspace(datos, slug)
+        return self.responde({"ok": True, "agent": slug, "name": nombre})
+
+    def p_montaje(self, q, cuerpo):
+        """Add or remove one of an agent's mounts — a repo, a worktree, or a
+        folder of documents — from the Hall.
+
+        The card is what the launcher and the cage read, so both the symlink and
+        the card key move together; a mount that exists on disk but not on the
+        card would vanish on the next sync.
+        """
+        a, ficha, datos = self._agente(q, cuerpo.get("agent"))
+        if not a:
+            return self.responde({"error": "no such agent here"}, codigo=404)
+        if a.legacy:
+            return self.responde(
+                {"error": "this agent is a legacy repo; add an agents-first one to mount folders"},
+                codigo=409,
+            )
+        quitar = str(cuerpo.get("remove") or "").strip()
+        anadir = str(cuerpo.get("add") or "").strip()
+        fuentes = list(a.mounts)
+        if quitar:
+            reales = {e: t for e, t in workspace.mounts_en_disco(datos, a.slug)}
+            etiqueta = card.ventana(quitar)
+            if etiqueta not in reales:
+                return self.responde({"error": f"{quitar} is not mounted here"}, codigo=404)
+            destino = reales[etiqueta]
+            workspace.desmonta(datos, a.slug, etiqueta)
+            fuentes = [
+                m for m in fuentes
+                if os.path.realpath(os.path.expanduser(m)) != destino
+                and card.ventana(os.path.basename(str(m).rstrip("/"))) != etiqueta
+            ]
+        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)
+            try:
+                workspace.monta(datos, a.slug, destino)
+            except (OSError, ValueError) as e:
+                return self.responde({"error": str(e)}, codigo=400)
+            if destino not in [os.path.realpath(os.path.expanduser(m)) for m in fuentes]:
+                fuentes.append(destino)
+        else:
+            return self.responde({"error": "add or remove a folder"}, codigo=400)
+        # An empty value REMOVES the key: `mounts.x: []` is a leftover that says
+        # "this agent declares no mounts" in a longer, staler way.
+        lista = ("[" + ", ".join(fuentes) + "]") if fuentes else ""
+        card.pon_campo(ficha, f"mounts.{a.slug}", lista)
+        # What this agent works on just changed, which is exactly what growth
+        # counts: remembering the old number for 90s would read as a failed mount.
+        olvida_crecimiento(datos, a.slug)
+        return self.responde(
+            {
+                "ok": True,
+                "agent": a.slug,
+                "mounts": [
+                    {"label": e, "target": t}
+                    for e, t in workspace.mounts_en_disco(datos, a.slug)
+                ],
+            }
+        )
+
     def p_agente(self, q, cuerpo):
         """Tune one agent from its character sheet: model, effort, runtime and
         avatar seed, written to the card keys the launcher already resolves. An
@@ -1154,7 +1408,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         except ValueError:
             return None, None, None
         pedido = str(nombre or "").strip().lower()
-        if not re.fullmatch(r"[a-z0-9][a-z0-9-]{0,79}", pedido):
+        if not card.ventana_valida(pedido):
             pedido = ""
         return agentes.get(pedido), ficha, datos
 
@@ -1256,6 +1510,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         destino, mal, codigo = _instala_skill(archivo, entradas, base_zip, nombre_skill, hogar)
         if mal:
             return self.responde({"error": mal}, codigo=codigo)
+        olvida_skills()
         return self.responde({"ok": True, "agent": a.slug, "skill": nombre_skill, "home": destino})
 
     def p_motor(self, q, cuerpo):
@@ -1326,6 +1581,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
                 {"error": f"no skill called {nombre} in this agent's home"}, codigo=404
             )
         shutil.rmtree(destino)
+        olvida_skills()
         return self.responde({"ok": True, "agent": a.slug, "removed": nombre})
 
     def p_demo(self, q, cuerpo):