agents-city 0.3.0-beta.21 → 0.3.0

package/bin/test-serve.py

@@ -169,6 +169,53 @@ def main():
             and b".liveAvatar" in cuerpo,
             cuerpo[:500].decode(errors="replace"),
         )
+        # Two skins, one set of names. A colour written straight into a rule is
+        # a colour that exists in one theme only — the classic unreadable-page
+        # bug — so the palette is asserted to be the only place naming one.
+        pagina = cuerpo.decode(errors="replace")
+        cabecera = pagina.split("*{box-sizing", 1)[0]
+        cuerpo_css = pagina.split("*{box-sizing", 1)[1].split("</style>", 1)[0]
+        afirma(
+            "· daylight is the default skin, in the tokens of agentscity.net",
+            "--suelo:#f3f0e8" in cabecera
+            and "--tinta:#1d2229" in cabecera
+            and "--lampara:#7048e8" in cabecera,
+            cabecera[-500:],
+        )
+        afirma(
+            "· night is declared once and only mapped, never written twice",
+            "--noche-suelo:#131a24" in cabecera
+            and cabecera.count("--noche-suelo:#131a24") == 1,
+            cabecera[-500:],
+        )
+        afirma(
+            # Daylight is THE default, not a default a dark desktop overrides:
+            # the owner asked for light and a machine setting does not outvote
+            # them. Night is reachable only through the switch, and remembered.
+            "· night is a choice made here, never one the machine makes",
+            '[data-tema="oscuro"]' in cabecera
+            # The RULE, not the word: the palette block explains in prose
+            # that there deliberately is no media query, and a test that
+            # cannot tell a comment from a rule fails on its own docs.
+            and "@media(prefers-color-scheme" not in cabecera,
+            cabecera[-700:],
+        )
+        import re as _re
+
+        sueltos = [
+            c for c in _re.findall(r"#[0-9a-fA-F]{6}\b", cuerpo_css)
+            # The kind chips are brand identity, the same hue in both skins.
+            if c.lower() not in ("#3b82f6", "#8b5cf6", "#f59e0b", "#0f172a", "#f4efe5")
+        ]
+        afirma(
+            "· and no rule outside the palette hardcodes a colour of its own",
+            not sueltos, ", ".join(sorted(set(sueltos))),
+        )
+        afirma(
+            "· the switch is in the page, and says which skin is showing",
+            'id="temaBoton"' in pagina, "",
+        )
+
         map_html = open(os.path.join(RAIZ, "city", "web", "index.html")).read()
         hall_source = open(os.path.join(RAIZ, "city", "web", "src", "hall.ts")).read()
         speech_source = open(os.path.join(RAIZ, "city", "web", "src", "game-speech.ts")).read()
@@ -283,6 +330,10 @@ def main():
         )
 
         # A seat written through the hall is the same card as everywhere else.
+        # The roster is NOT part of it: agents are added through /api/agentes,
+        # and saving the seat must carry them over untouched — the whole point
+        # of having one writer per fact. The card comes first: an agent lives on
+        # its owner's card, so there is nothing to join until that exists.
         st, cuerpo = pide(
             puerto,
             "/api/ficha",
@@ -291,8 +342,6 @@ def main():
                 "user": "Ana.López@x.com",
                 "domain": "healthcare",
                 "role": "clinical-director",
-                "repos": ["api"],
-                "repo_roles": {"api": "seo"},
                 "objetivo": {
                     "title": "One goal",
                     "signal": "s",
@@ -306,11 +355,33 @@ def main():
         r = json.loads(cuerpo)
         comprueba("· a card is written through the hall", st, 200)
         comprueba("· body.user cannot create a second person in the city", r["user"], owner)
+        st_alta, cuerpo_alta = pide(
+            puerto, "/api/agentes", metodo="POST",
+            cuerpo={"name": "api", "kind": "code", "role": "seo"},
+        )
+        comprueba("· an agent joins the city through its own endpoint", st_alta, 200)
+        # Saving the seat a second time is where the old shape would have
+        # silently replaced the roster with whatever the page happened to send.
+        pide(
+            puerto, "/api/ficha", metodo="POST",
+            cuerpo={"domain": "healthcare", "role": "clinical-director"},
+        )
         c = card.lee(os.path.join(hallDatos, f"{owner}.md"))
+        texto_ficha = c.get("texto") or ""
         comprueba(
             "· and reads back through the shared reader",
-            (c["agent"], c["role"], c["repos"], c["repo_roles"]),
-            (address, "clinical-director", ["api"], {"api": "seo"}),
+            (c["agent"], c["role"]),
+            (address, "clinical-director"),
+        )
+        afirma(
+            "· saving the seat carries the roster over instead of emptying the city",
+            "agents: [api]" in texto_ficha and "role.api: seo" in texto_ficha,
+            texto_ficha.split("---")[1],
+        )
+        afirma(
+            "· and nothing writes the legacy repos: shape any more",
+            "repos:" not in texto_ficha,
+            texto_ficha.split("---")[1],
         )
         estado_salud = json.loads(pide(puerto, "/api/estado")[1])
         afirma(
@@ -334,6 +405,9 @@ def main():
             "· an empty command is manual, not an empty string to run", c["objetivo"]["command"], ""
         )
 
+        # The seat endpoint no longer takes a roster in any shape: sending one
+        # is ignored rather than obeyed, because agents have their own door and
+        # a second way in is how the two doors drifted apart in the first place.
         st, cuerpo = pide(
             puerto,
             "/api/ficha",
@@ -341,14 +415,15 @@ def main():
             cuerpo={
                 "domain": "healthcare",
                 "role": "clinical-director",
-                "repos": ["api"],
-                "repo_roles": [],
+                "repos": ["inventado"],
+                "repo_roles": {"inventado": "seo"},
             },
         )
+        texto_tras = card.lee(os.path.join(hallDatos, f"{owner}.md")).get("texto") or ""
         afirma(
-            "· malformed repo-role mappings are a visible 400",
-            st == 400 and "repo_roles must be an object" in json.loads(cuerpo)["error"],
-            cuerpo.decode(),
+            "· a roster sent to the seat endpoint is ignored, not written",
+            st == 200 and "inventado" not in texto_tras and "agents: [api]" in texto_tras,
+            texto_tras.split("---")[1],
         )
 
         # A goal with no title is no goal, not a goal called nothing.
@@ -664,6 +739,92 @@ def main():
         )
         pide(puerto, "/api/agente", metodo="POST", cuerpo={"agent": "notas", "model": ""})
 
+        # ── the roster, from the web ─────────────────────────────────────────
+        print("  building the roster from the Hall")
+        st, cuerpo = pide(
+            puerto,
+            "/api/agentes",
+            metodo="POST",
+            cuerpo={"name": "urgencias web", "kind": "knowledge", "role": "triage"},
+        )
+        carta = open(os.path.join(hallDatos, "halltest.md"), encoding="utf-8").read()
+        afirma(
+            "· happy: an agent can be added without ever opening a terminal",
+            st == 200
+            and "urgencias web" in carta
+            and "kind.urgencias-web: knowledge" in carta
+            and "role.urgencias-web: triage" in carta,
+            carta,
+        )
+        st, _ = pide(
+            puerto, "/api/agentes", metodo="POST",
+            cuerpo={"name": "urgencias web", "kind": "code", "role": "dev"},
+        )
+        comprueba("· non-happy: two agents cannot share one identity", st, 409)
+        st, _ = pide(
+            puerto, "/api/agentes", metodo="POST",
+            cuerpo={"name": "nova", "kind": "wizard", "role": "dev"},
+        )
+        comprueba("· non-happy: a kind is code, knowledge or coordinator", st, 400)
+        st, _ = pide(
+            puerto, "/api/agentes", metodo="POST",
+            cuerpo={"name": "nova", "kind": "code", "role": "dev; rm -rf /"},
+        )
+        comprueba("· non-happy: a role is an id, never a shell fragment", st, 400)
+        st, _ = pide(puerto, "/api/agentes", metodo="POST", cuerpo={"name": "  "})
+        comprueba("· non-happy: an agent needs a name", st, 400)
+
+        # Mounts: what an agent works on, from the same page.
+        carpeta = tempfile.mkdtemp()
+        st, cuerpo = pide(
+            puerto, "/api/montaje", metodo="POST",
+            cuerpo={"agent": "urgencias-web", "add": carpeta},
+        )
+        montado = json.loads(cuerpo)
+        # The label is slugged: it is a card key and a filename, not free text.
+        etiqueta = card.ventana(os.path.basename(carpeta))
+        carta = open(os.path.join(hallDatos, "halltest.md"), encoding="utf-8").read()
+        afirma(
+            "· happy: a document folder is mounted, on disk and on the card together",
+            st == 200
+            and any(m["label"] == etiqueta for m in montado.get("mounts", []))
+            and f"mounts.urgencias-web: [{os.path.realpath(carpeta)}]" in carta,
+            f"{cuerpo!r} {carta}",
+        )
+        st, cuerpo = pide(puerto, "/api/estado")
+        hoja_web = next(
+            x for x in json.loads(cuerpo)["agents"] if x["slug"] == "urgencias-web"
+        )
+        afirma(
+            "· and the sheet says what it works on, not merely how many",
+            [m["label"] for m in hoja_web["mounts"]] == [etiqueta],
+            str(hoja_web["mounts"]),
+        )
+        st, _ = pide(
+            puerto, "/api/montaje", metodo="POST",
+            cuerpo={"agent": "urgencias-web", "add": "/nope/not/here"},
+        )
+        comprueba("· non-happy: a folder that is not there is refused", st, 400)
+        st, cuerpo = pide(
+            puerto, "/api/montaje", metodo="POST",
+            cuerpo={"agent": "urgencias-web", "remove": etiqueta},
+        )
+        carta = open(os.path.join(hallDatos, "halltest.md"), encoding="utf-8").read()
+        afirma(
+            "· happy: unmounting clears the link and the card key, and keeps the folder",
+            st == 200
+            and not json.loads(cuerpo)["mounts"]
+            and "mounts.urgencias-web" not in carta
+            and os.path.isdir(carpeta),
+            carta,
+        )
+        st, _ = pide(
+            puerto, "/api/montaje", metodo="POST",
+            cuerpo={"agent": "urgencias-web", "remove": "fantasma"},
+        )
+        comprueba("· non-happy: unmounting what is not mounted is a 404", st, 404)
+        shutil.rmtree(carpeta, ignore_errors=True)
+
         # ── instructions and skills, into the agent's own home ──────────────
         print("  instructions and skills, written only into the agent's own home")
         st, cuerpo = pide(puerto, "/api/instrucciones?agent=notas&file=CLAUDE.md")
@@ -1006,6 +1167,50 @@ def main():
             if otro.get("s"):
                 otro["s"].server_close()
 
+        # Two memos serve /api/estado, and a memo without an invalidation is a
+        # lie waiting to be told: mounting a folder changes exactly what growth
+        # counts, and installing a skill changes discovery without touching the
+        # card that keys it. A healthy card first — the checks above deliberately
+        # left a broken one behind.
+        with open(os.path.join(hallDatos, "halltest.md"), "w", encoding="utf-8") as f:
+            f.write(
+                "---\nuser: halltest\nname: Hall Test\nrole: cpto\nagent: halltest/seat\n"
+                "agents: [notas]\nkind.notas: knowledge\nrole.notas: apuntes\n"
+                "goals_defined: true\n---\n"
+            )
+        serve._CRECIDO[(os.path.realpath(hallDatos), "notas")] = (
+            __import__("time").monotonic(),
+            {"floors": 999, "bricks": 0, "activity30": 0, "signal": "stale"},
+        )
+        pide(
+            puerto, "/api/montaje", metodo="POST",
+            cuerpo={"agent": "notas", "add": tempfile.mkdtemp()},
+        )
+        afirma(
+            "· mounting a folder forgets that agent's remembered growth",
+            (os.path.realpath(hallDatos), "notas") not in serve._CRECIDO,
+            str(sorted(serve._CRECIDO)),
+        )
+        st, cuerpo = pide(puerto, "/api/estado")
+        primera = json.loads(cuerpo)["skills"]
+        sello_antes = serve._SKILLS.get("sello")
+        pide(puerto, "/api/estado")
+        afirma(
+            "· discovery is remembered while the card has not moved",
+            sello_antes is not None and serve._SKILLS.get("sello") == sello_antes,
+            str(sello_antes),
+        )
+        pide(
+            puerto, "/api/agentes", metodo="POST",
+            cuerpo={"name": "efimero", "kind": "code", "role": "dev"},
+        )
+        st, cuerpo = pide(puerto, "/api/estado")
+        afirma(
+            "· and a card that moves invalidates it at once, not on a timer",
+            "efimero" in json.loads(cuerpo)["skills"] and "efimero" not in primera,
+            str(sorted(json.loads(cuerpo)["skills"])),
+        )
+
         # A code agent's growth reads real local git history — merge commits
         # as floors — instead of answering zero for lack of a counter.
         import subprocess as _sp

package/bin/test-workspace.py

@@ -179,8 +179,71 @@ def _rechaza(fn):
         return True
 
 
+def skills_instaladas():
+    """The one deliberate write: a skill the owner hands over, into one home.
+
+    Both doors (the wizard's question, the Hall's upload) come through here, so
+    the containment rules are tested once — where they live.
+    """
+    print("  installing a skill into one agent's own home")
+    base = tempfile.mkdtemp(prefix="agents-city-skill-")
+    try:
+        origen = os.path.join(base, "triage-skill")
+        os.makedirs(origen)
+        with open(os.path.join(origen, "SKILL.md"), "w") as f:
+            f.write("---\nname: triage\n---\n")
+        nombre, mal = ws.instala_skill(base, "urgencias", origen)
+        destino = os.path.join(ws.workspace_de(base, "urgencias"), ".claude", "skills",
+                               "triage-skill", "SKILL.md")
+        afirma("· a folder with a SKILL.md installs into the agent's home",
+               nombre == "triage-skill" and not mal and os.path.isfile(destino), f"{nombre} {mal}")
+        _, otra_vez = ws.instala_skill(base, "urgencias", origen)
+        afirma("· installing the same skill twice is refused, never overwritten",
+               "already exists" in otra_vez, otra_vez)
+        sin = os.path.join(base, "not-a-skill")
+        os.makedirs(sin)
+        _, mal = ws.instala_skill(base, "urgencias", sin)
+        afirma("· a folder with no SKILL.md is not a skill", "SKILL.md" in mal, mal)
+        _, mal = ws.instala_skill(base, "urgencias", os.path.join(base, "ghost"))
+        afirma("· a source that is not there is an answer, not a traceback",
+               "nothing at" in mal, mal)
+
+        # A committed `.claude/skills` symlink would carry the install straight
+        # out of the agent's home — the global skills folder included.
+        fuera = os.path.join(base, "elsewhere")
+        os.makedirs(fuera)
+        hogar = ws.crea_workspace(base, "fugado")
+        os.makedirs(os.path.join(hogar, ".claude"), exist_ok=True)
+        os.symlink(fuera, os.path.join(hogar, ".claude", "skills"))
+        _, mal = ws.instala_skill(base, "fugado", origen)
+        afirma("· a symlinked skills root refuses the install and writes nothing",
+               "link out of its home" in mal and not os.listdir(fuera),
+               f"{mal} {os.listdir(fuera)}")
+
+        # A zip is the same skill by another door, through the same guards.
+        import io
+        import zipfile
+        crudo = os.path.join(base, "bomba.zip")
+        with zipfile.ZipFile(crudo, "w", zipfile.ZIP_DEFLATED) as z:
+            z.writestr("boom/SKILL.md", "---\nname: boom\n---\n")
+            z.writestr("boom/ceros.bin", b"\0" * (80 * 1024 * 1024))
+        _, mal = ws.instala_skill(base, "urgencias", crudo)
+        afirma("· a zip bomb is refused by what it inflates to, not what it weighs",
+               "inflates too large" in mal, mal)
+        bueno = os.path.join(base, "buena.zip")
+        with zipfile.ZipFile(bueno, "w") as z:
+            z.writestr("deploy/SKILL.md", "---\nname: deploy\n---\n")
+        nombre, mal = ws.instala_skill(base, "urgencias", bueno)
+        afirma("· a well-formed zip installs under its own folder name",
+               nombre == "deploy" and not mal, f"{nombre} {mal}")
+        del io
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
 legacy_subsume()
 nuevo_modelo()
+skills_instaladas()
 montajes()
 colisiones_de_basename()
 slugs_colisionados_rechazados()

package/bin/testlib.py

@@ -93,3 +93,26 @@ def resumen(etiqueta):
         return 1
     print(f'  {etiqueta} ok — {HECHAS} checks\n')
     return 0
+
+
+def roster(*agentes):
+    """The roster shape the card writers take, from `(name, kind, role)` tuples.
+
+    Written once here because two suites build the same fixture, and a fixture
+    copied per file is how the tests stop agreeing with each other.
+    """
+    import card
+
+    fuera = []
+    for entrada in agentes:
+        nombre, clase, rol = (list(entrada) + ['code', 'blank'])[:3]
+        fuera.append({
+            'nombre': nombre,
+            'slug': card.ventana(nombre),
+            'clase': clase,
+            'rol': rol,
+            'mounts': [],
+            'motor': {},
+            'skills': [],
+        })
+    return fuera

package/bin/update

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Install the newest published version, or ask whether there is one.
+exec python3 "$(cd "$(dirname "$0")/../plugin/scripts" && pwd)/actualiza.py" "$@"