agents-city 0.5.2 → 0.5.3

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "city",
       "source": "./plugin",
-      "version": "0.5.2",
+      "version": "0.5.3",
       "description": "Operate one autonomous city seat, its domain, role, repo support agents, goal, recognised skills and explicit roads to other cities."
     }
   ]

package/bin/serve.py

@@ -619,6 +619,23 @@ class Manejador(http.server.BaseHTTPRequestHandler):
     _ultimo = None
     _error = None
 
+    def _ciudad_para_apuntar(self, q):
+        """The same city `ciudad` would resolve, resolved without touching it.
+
+        `ciudad` calls `asegura_metadata`, which does `makedirs` and writes
+        `city.yml` — right when a request is about to act on a city, and wrong
+        when the only reason we are asking is to write a log line. The journal
+        runs AFTER the handler, so on a request that archived or reset a city it
+        recreated the very folder that had just been taken away, leaving a ghost
+        behind. Observing something must not create it.
+        """
+        pedida = q.get("city", [""])[0]
+        if pedida:
+            resuelta = self.resuelve_conocida(pedida)
+            if resuelta:
+                return resuelta
+        return seat.donde_viven_las_fichas()
+
     def apunta(self, q, tipo, **campos):
         """One journal line, in the journal of the city the request acted on.
 
@@ -628,7 +645,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         record, because it is a record that lies about where.
         """
         try:
-            diario.apunta(self.ciudad(q), tipo, **campos)
+            diario.apunta(self._ciudad_para_apuntar(q), tipo, **campos)
         except Exception:  # noqa: BLE001  logging must not break the request
             pass
 

package/bin/test-arnes.py

@@ -20,6 +20,7 @@ So there are two things to defend here, and the second is the hard one:
 import json
 import os
 import re
+import subprocess
 import sys
 import tempfile
 
@@ -119,12 +120,119 @@ def sin_deriva():
            arnes.banderas("codex") == "" and arnes.banderas("opencode") == "",
            f"codex={arnes.banderas('codex')!r}")
 
+    # And it survives a SHELL, which is what receives it.
+    #
+    # This is the check that was missing, and its absence cost every Claude
+    # window in a city. Emitted bare, `--settings {"a":"b","c":true}` is
+    # destroyed twice before Claude sees it: brace expansion splits it on the
+    # comma, quote removal eats the double quotes, and what arrives is
+    # `--settings {a:b}` — "Invalid JSON provided to --settings".
+    #
+    # Asserting that the string CONTAINS the right words could never have
+    # caught that. So this parses the line the way a shell does and reads the
+    # value back as JSON, which is the only claim that matters.
+    import shlex  # noqa: PLC0415
+
+    palabras = shlex.split(arnes.banderas("claude"))
+    afirma("· the flags survive shell parsing as separate words",
+           "--settings" in palabras and "--disallowed-tools" in palabras, str(palabras))
+    valor = palabras[palabras.index("--settings") + 1]
+    try:
+        ajustes = json.loads(valor)
+    except json.JSONDecodeError as e:
+        ajustes = None
+        afirma("· and the settings value is still JSON afterwards", False, f"{valor!r}: {e}")
+    if ajustes is not None:
+        afirma("· and the settings value is still JSON afterwards", True, "")
+        comprueba("· with the cross-session path closed",
+                  ajustes.get("crossSessionInbound"), "refuse")
+        afirma("· and every declared settings key inside it",
+               all(t["clave"] in ajustes
+                   for t in arnes.declaracion()["claude"]["trato"]
+                   if t.get("rinde") == "settings"),
+               str(ajustes))
+    # A real shell, not just a parser: brace expansion is the half `shlex`
+    # forgives, and it is the half that broke.
+    import subprocess  # noqa: PLC0415
+
+    r = subprocess.run(
+        ["bash", "-c", 'set -- ' + arnes.banderas("claude") + '; printf "%s\n" "$@"'],
+        capture_output=True, text=True,
+    )
+    entregado = [l for l in r.stdout.split("\n") if l]
+    comprueba("· a real shell hands over exactly four words", len(entregado), 4)
+    try:
+        json.loads(entregado[1])
+        afirma("· and the second is the settings, intact", True, "")
+    except json.JSONDecodeError as e:
+        afirma("· and the second is the settings, intact", False, f"{entregado!r}: {e}")
+
 
 def _es_metodo_declarado(aguja, declaradas):
     """`approvalPolicy` declared, read through a method of the same name."""
     return any(aguja.lower() == d.lower() for d in declaradas)
 
 
+def valores_que_no_sobrevivirian(tmp):
+    """Values that a shell would eat, or run.
+
+    The happy checks above prove today's declaration survives. They cannot
+    prove the NEXT one will: the values there are mild strings, and the bug
+    that broke every Claude window was a comma. The day somebody declares a
+    value with a space in it, or a quote, this has to hold — and if it does
+    not, it must fail here rather than in a person's terminal.
+
+    The last two are not a formatting concern. `$(...)` and backticks in an
+    unquoted argument are executed by the shell, and this declaration is read
+    from a file: a value that runs a command is a value that runs somebody
+    else's command.
+    """
+    print("  values a shell would eat, or run")
+    testigo = os.path.join(tmp, "ejecutado")
+    hostiles = {
+        "conEspacio": "dos palabras",
+        "conComillas": 'dice "hola" y \'adios\'',
+        "conLlaves": "{a,b}",
+        "conPuntoYComa": "uno; echo dos",
+        "conDolar": "$HOME y ${OTRO}",
+        "conSustitucion": f"$(touch {testigo})",
+        "conAcentoGrave": f"`touch {testigo}`",
+    }
+    real = arnes.declaracion
+    arnes.declaracion = lambda: {
+        "claude": {
+            "trato": [
+                {"clave": k, "valor": v, "via": "x", "porque": "y" * 30, "rinde": "settings"}
+                for k, v in hostiles.items()
+            ]
+        }
+    }
+    try:
+        linea = arnes.banderas("claude")
+    finally:
+        arnes.declaracion = real
+
+    # A real shell, because `shlex` forgives what bash does not.
+    r = subprocess.run(
+        ["bash", "-c", "set -- " + linea + '; printf "%s\\n" "$@"'],
+        capture_output=True, text=True,
+    )
+    entregado = [l for l in r.stdout.split("\n") if l]
+    afirma("· a hostile declaration still comes out as two words",
+           len(entregado) == 2 and entregado[0] == "--settings",
+           f"{entregado!r} from {linea!r}")
+    afirma("· nothing in it was executed on the way",
+           not os.path.exists(testigo),
+           f"{testigo} exists: a declared value ran a command")
+    try:
+        vuelta = json.loads(entregado[1]) if len(entregado) > 1 else {}
+    except json.JSONDecodeError as e:
+        vuelta = {}
+        afirma("· and it is still JSON on the other side", False, f"{entregado[1]!r}: {e}")
+    for clave, valor in hostiles.items():
+        comprueba(f"· {clave} arrives exactly as declared", vuelta.get(clave), valor)
+
+
 def lo_que_hay_en_el_disco():
     print("  it reads the machine, and admits what it cannot read")
     casa = tempfile.mkdtemp()
@@ -183,6 +291,7 @@ def el_informe():
 def main():
     la_declaracion()
     sin_deriva()
+    valores_que_no_sobrevivirian(tempfile.mkdtemp())
     lo_que_hay_en_el_disco()
     el_informe()
     return resumen("arnes")

package/bin/test-channel.py

@@ -22,6 +22,37 @@ CHANNEL = os.path.join(RAIZ, 'plugin', 'channel', 'run.sh')
 CLIENT = os.path.join(RAIZ, 'plugin', 'channel', 'client.js')
 
 
+def espera_avisos(bus, quieto=0.6, tope=10):
+    """The seat's wake-ups, once they have arrived AND stopped arriving.
+
+    Reading `bus.mensajes` at a fixed moment samples a race, and a sample lies
+    in both directions: it saw zero on a loaded Linux runner and failed a
+    working product, and on a slow one it could see two of a hundred and pass a
+    broken one. Both halves of the assertion need the burst to be over — the
+    lower bound needs them to have arrived, the upper bound needs no more to be
+    coming.
+
+    So: wait for the first, then wait until none has appeared for `quieto`.
+    Quiescence, not a guess at how long a hundred arrivals take.
+    """
+    def cuantos():
+        return sum(1 for m in bus.mensajes
+                   if m.get('method') == 'notifications/claude/channel')
+
+    limite = time.monotonic() + tope
+    bus.espera(lambda m: m.get('method') == 'notifications/claude/channel', segundos=tope)
+    ultimo, estable = cuantos(), time.monotonic()
+    while time.monotonic() < limite:
+        time.sleep(0.05)
+        ahora = cuantos()
+        if ahora != ultimo:
+            ultimo, estable = ahora, time.monotonic()
+        elif time.monotonic() - estable >= quieto:
+            break
+    return [m for m in bus.mensajes
+            if m.get('method') == 'notifications/claude/channel']
+
+
 def espera(condicion, segundos=8):
     limite = time.monotonic() + segundos
     while time.monotonic() < limite:
@@ -398,8 +429,9 @@ def main():
                'alice/home' in texto(roster)
                and 'alice/ghost' not in texto(roster)
                and '"online": true' in texto(roster), texto(roster))
-        road_notices = [m for m in b.mensajes
-                        if m.get('method') == 'notifications/claude/channel']
+        # Waited for, not sampled. Reading the list at a fixed moment saw zero
+        # on a loaded runner and failed a product that was working.
+        road_notices = espera_avisos(b)
         # Coalesced, not exactly-one. The property is that a hundred arrivals
         # do not become a hundred interruptions; whether the window happens to
         # close once or twice mid-burst is the machine's business, and asserting

package/bin/test-seat.py

@@ -1101,6 +1101,56 @@ def motores_del_puesto():
             )
 
 
+def el_settings_sobrevive_a_la_shell(asiento, api):
+    """The launch line, parsed the way a shell parses it.
+
+    Asserting the words appear somewhere in the string is not enough, and the
+    gap cost every Claude window in a city: `--settings {"a":"b","c":true}`
+    emitted without quotes is split by brace expansion on the comma and
+    stripped of its double quotes, so what reached Claude was `{a:b}` and it
+    exited with "Invalid JSON provided to --settings". The string contained
+    every word a substring check looks for.
+    """
+    import shlex
+
+    def ajustes_de(linea):
+        """The `--settings` value, dug out through however many shells wrap it.
+
+        A repo window is launched through `tmux send-keys`, so its whole command
+        is one quoted word inside the line; the chair's is not. Splitting once
+        and giving up would test the chair and quietly skip the houses — which
+        is exactly the window that broke.
+        """
+        pendientes, visto = [linea], 0
+        while pendientes and visto < 6:
+            visto += 1
+            actual = pendientes.pop(0)
+            try:
+                palabras = shlex.split(actual)
+            except ValueError:
+                continue
+            if "--settings" in palabras:
+                return palabras[palabras.index("--settings") + 1]
+            pendientes.extend(x for x in palabras if "--settings" in x and x != actual)
+        return None
+
+    for etiqueta, linea in (("the chair", asiento), ("an agent house", api)):
+        crudo = ajustes_de(linea)
+        if crudo is None:
+            afirma(f"· {etiqueta} is launched with --settings", False, linea[:250])
+            continue
+        try:
+            ajustes = json.loads(crudo)
+        except json.JSONDecodeError as e:
+            afirma(f"· {etiqueta}'s --settings is still JSON after the shell has it",
+                   False, f"{crudo!r}: {e}")
+            continue
+        afirma(f"· {etiqueta}'s --settings is still JSON after the shell has it",
+               isinstance(ajustes, dict), crudo)
+        comprueba(f"· and {etiqueta} still refuses cross-session inbound",
+                  ajustes.get("crossSessionInbound"), "refuse")
+
+
 def arranque_escalonado():
     """Claude windows must not all start in the same millisecond.
 
@@ -1310,6 +1360,8 @@ def arranque_escalonado():
         "CITY_BUS_URL= CITY_BUS_TOKEN=" in api and "CITY_BUS_URL= CITY_BUS_TOKEN=" in docs,
     )
     claude_contract = (asiento + "\n" + api).replace("\\", "")
+    el_settings_sobrevive_a_la_shell(asiento, api)
+
     afirma(
         "· Claude native peer messaging is refused and its tools denied",
         claude_contract.count("crossSessionInbound") == 2

package/bin/test-serve.py

@@ -937,7 +937,31 @@ def main():
             not os.path.exists(os.path.join(hallDatos, "units.yml"))
             or "u1" not in open(os.path.join(hallDatos, "units.yml")).read(),
         )
+        # Observing must not create.
+        #
+        # The journal runs after the handler, and it used to resolve its city
+        # through `ciudad`, which does `makedirs` and writes `city.yml`. On a
+        # request that archived a city, the log line recreated the folder that
+        # had just been taken away — a ghost city, left behind by the act of
+        # recording that it had gone. It also raced this very cleanup.
         shutil.rmtree(otra)
+        # The resolver the journal uses, on its own: it must answer where
+        # to write without bringing anything into being.
+        #
+        # (A handler is a different matter. It resolves through `ciudad`, which
+        # creates metadata for a city it is about to act on, so a request naming
+        # a deleted city can recreate its folder. That predates the journal and
+        # is not what this is about.)
+        fantasma = os.path.join(tempfile.mkdtemp(), "no-existe")
+        manejador = serve.Manejador.__new__(serve.Manejador)
+        donde = manejador._ciudad_para_apuntar(
+            {"city": [fantasma]}
+        )
+        afirma(
+            "· the journal's own resolver creates nothing",
+            not os.path.exists(fantasma) and isinstance(donde, str),
+            f"{fantasma} exists after only asking where to log",
+        )
 
         # ── the demo's remote control ────────────────────────────────────────
         print("  the demo's remote control")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-city",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Run autonomous agent cities: one chair seat, role-aware repo agents, repo-owned skills, and explicit roads.",
   "bin": {
     "agents-city": "bin/agents-city.js"

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "city",
   "displayName": "Agents City",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "One autonomous city seat with a work domain, role, goal, repo support agents, recognised skills and explicit roads to other cities.",
   "author": {
     "name": "jlcases",

package/plugin/scripts/arnes.py

@@ -24,6 +24,7 @@ Three columns, and the distinction between them is the whole point:
 
 import json
 import os
+import shlex
 
 AQUI = os.path.dirname(os.path.abspath(__file__))
 RAIZ = os.path.dirname(os.path.dirname(AQUI))
@@ -200,7 +201,15 @@ def banderas(nombre):
             flags.append(f"--{guion} {valor}")
     partes = []
     if ajustes:
-        partes.append("--settings " + json.dumps(ajustes, separators=(",", ":")))
+        # Quoted for a shell, because a shell is what receives this.
+        #
+        # Emitted bare, `--settings {"a":"b","c":true}` is destroyed twice over
+        # before Claude ever sees it: brace expansion splits it on the comma,
+        # and quote removal eats the double quotes. What arrived was
+        # `--settings {a:b}` and every window died with "Invalid JSON provided
+        # to --settings". The line this replaced was `--settings '$SETTINGS'`,
+        # and the quotes were the part that mattered.
+        partes.append("--settings " + shlex.quote(json.dumps(ajustes, separators=(",", ":"))))
     partes += flags
     return " ".join(partes)